void pm_mangle_name(com32sys_t *regs)
{
const char *src = MK_PTR(regs->ds, regs->esi.w[0]);
char *dst = MK_PTR(regs->es, regs->edi.w[0]);
mangle_name(dst, src);
}
/*
* Convert a relative pathname to an absolute pathname
* In the future this might also resolve symlinks...
*/
void pm_realpath(com32sys_t *regs)
{
const char *src = MK_PTR(regs->ds, regs->esi.w[0]);
char *dst = MK_PTR(regs->es, regs->edi.w[0]);
realpath(dst, src, FILENAME_MAX);
}
void __constructor __syslinux_get_derivative_info(void)
{
com32sys_t *const r = &__syslinux_derivative_info.rr.r;
r->eax.w[0] = 0x000A;
__intcall(0x22, r, r);
__syslinux_derivative_info.r.esbx = MK_PTR(r->es, r->ebx.w[0]);
__syslinux_derivative_info.r.fssi = MK_PTR(r->fs, r->esi.w[0]);
__syslinux_derivative_info.r.gsdi = MK_PTR(r->gs, r->edi.w[0]);
}
void __constructor __syslinux_get_version(void)
{
static com32sys_t reg;
reg.eax.w[0] = 0x0001;
__intcall(0x22, ®, ®);
__syslinux_version.version = reg.ecx.w[0];
__syslinux_version.max_api = reg.eax.w[0];
__syslinux_version.filesystem = reg.edx.b[0];
__syslinux_version.version_string = MK_PTR(reg.es, reg.esi.w[0]);
__syslinux_version.copyright_string = MK_PTR(reg.es, reg.edi.w[0]);
}
void getfsbytes(com32sys_t *regs)
{
int sectors;
bool have_more;
uint32_t bytes_read;
char *buf;
struct file *file;
uint16_t handle;
handle = regs->esi.w[0];
file = handle_to_file(handle);
sectors = regs->ecx.w[0] >> SECTOR_SHIFT(file->fs);
buf = MK_PTR(regs->es, regs->ebx.w[0]);
bytes_read = file->fs->fs_ops->getfssec(file, buf, sectors, &have_more);
/*
* If we reach EOF, the filesystem driver will have already closed
* the underlying file... this really should be cleaner.
*/
if (!have_more) {
_close_file(file);
regs->esi.w[0] = 0;
}
regs->ecx.l = bytes_read;
}
void __constructor __syslinux_get_ipappend_strings(void)
{
static com32sys_t reg;
int i;
reg.eax.w[0] = 0x000f;
__intcall(0x22, ®, ®);
if (!(reg.eflags.l & EFLAGS_CF)) {
__syslinux_ipappend_strings.count = reg.ecx.w[0];
__syslinux_ipappend_strings.ptr =
syslinux_ipappend_string_list;
for (i = 0; i < reg.ecx.w[0]; i++) {
syslinux_ipappend_string_list[i] =
MK_PTR(reg.es, *(uint16_t *)MK_PTR(reg.es, reg.ebx.w[0]+i*2));
}
}
}
void __constructor __syslinux_get_keyboard_map(void)
{
static com32sys_t reg;
reg.eax.w[0] = 0x001e;
__intcall(0x22, ®, ®);
if (!(reg.eflags.l & EFLAGS_CF)) {
__syslinux_keyboard_map.version = reg.eax.w[0];
__syslinux_keyboard_map.length = reg.ecx.w[0];
__syslinux_keyboard_map.map = MK_PTR(reg.es, reg.ebx.w[0]);
}
}
void
test_pre()
{
/* char tmp_buf[256]; */
DBUG_ENTER("test_pre");
DBUG_PRINT("", ("sizeof(int)=%d", sizeof(int)));
DBUG_PRINT("", ("sizeof(CONS*)=%d", sizeof(CONS*)));
DBUG_PRINT("", ("sizeof(BEH)=%d", sizeof(BEH)));
assert(sizeof(int) == sizeof(CONS*));
assert(sizeof(BEH) == sizeof(CONS*));
DBUG_PRINT("", ("NIL=16#%08lx (%p)", NIL, NIL));
assert(nilp(NIL));
assert(nilp(NIL) == _nilp(NIL));
DBUG_PRINT("", ("sizeof(BOOL)=%d", sizeof(BOOL)));
assert(sizeof(BOOL) == sizeof(CONS*));
DBUG_PRINT("", ("TRUE=16#%08lx (%p)", TRUE, TRUE));
DBUG_PRINT("", ("FALSE=16#%08lx (%p)", FALSE, FALSE));
assert(TRUE);
assert(!FALSE);
assert(TRUE == ((BOOL)(0 == 0)));
assert(FALSE == ((BOOL)(0 != 0)));
#if TYPETAG_USES_3MSB
DBUG_PRINT("", ("Type tag in MSB[31:29]"));
#endif /* TYPETAG_USES_3MSB */
#if TYPETAG_USES_2LSB
DBUG_PRINT("", ("Type tag in LSB[1:0]"));
#endif /* TYPETAG_USES_2LSB */
#if TYPETAG_USES_3LSB
DBUG_PRINT("", ("Type tag in LSB[2/1:0]"));
#endif /* TYPETAG_USES_3LSB */
#if TYPETAG_USES_1LSB_2MSB
DBUG_PRINT("", ("Type tag in LSB[0]+MSB[31:30]"));
#endif /* TYPETAG_USES_1LSB_2MSB */
DBUG_PRINT("", ("_Program[]=16#%08lx (%p)", _Program, _Program));
assert(_Program == MK_PTR(MK_REF(_Program)));
/* FIXME: enable this test when stack allocation is allowed
DBUG_PRINT("", ("tmp_buf[]=%p", tmp_buf));
assert(tmp_buf == MK_PTR(MK_REF(tmp_buf)));
*/
DBUG_PRINT("", ("test_pre()=16#%08lx (%p)", test_pre, test_pre));
assert(test_pre == MK_BEH(MK_FUNC(test_pre)));
DBUG_RETURN;
}
void pm_searchdir(com32sys_t *regs)
{
char *name = MK_PTR(regs->ds, regs->edi.w[0]);
int rv;
rv = searchdir(name);
if (rv < 0) {
regs->esi.w[0] = 0;
regs->eax.l = 0;
regs->eflags.l |= EFLAGS_ZF;
} else {
regs->esi.w[0] = rv;
regs->eax.l = handle_to_file(rv)->inode->size;
regs->eflags.l &= ~EFLAGS_ZF;
}
}
void pm_open_file(com32sys_t *regs)
{
int rv;
struct file *file;
const char *name = MK_PTR(regs->es, regs->esi.w[0]);
char mangled_name[FILENAME_MAX];
dprintf("pm_open_file %s\n", name);
mangle_name(mangled_name, name);
rv = searchdir(mangled_name);
if (rv < 0) {
regs->eflags.l |= EFLAGS_CF;
} else {
file = handle_to_file(rv);
regs->eflags.l &= ~EFLAGS_CF;
regs->eax.l = file->inode->size;
regs->ecx.w[0] = SECTOR_SIZE(file->fs);
regs->esi.w[0] = rv;
}
}
/* Copy the data stored in a Cache struct into a continuously allocated memory block in *p.
* All sub structure status are either uninitialized or compressed, which meaning that they are not allocated separately and therefore should not be deallocated.
* Only coreRuleSet and coreFuncDescIndex are copied.
* Starting from *p+size backwards, a list of pointers to pointers in the copied data structures are stored.
* There pointers are used to quickly access all pointers in the stored data structures so that they can be offset when they are copied to a new memory address.
* This function returns NULL if it runs out of memory allocated between in *p and *p+size.
* The rule engine status is also set to uninitialized. */
Cache *copyCache( unsigned char **p, size_t size, Cache *ptr ) {
/* size should be large enough and divisible by ALIGNMENT */
if (size < DEFAULT_BLOCK_SIZE || 0 != size % REGION_ALIGNMENT) {
return NULL;
}
unsigned char *buf = *p;
unsigned char *pointers0 = buf + size;
/* shared objects */
unsigned char **pointers = &pointers0;
int generatePtrDesc = 1;
allocateInBuffer( Cache, ecopy, ptr );
MK_POINTER( &( ecopy->address ) );
MK_POINTER( &( ecopy->pointers ) );
// objectMap will use a hash table size that is twice the number of objects being held (to favor speed).
// Example: The shared memory region has a size of SHMMAX (see shared_memory.hpp). SHMMAX == 30000000.
// The upper bound of the passed-in size is the shared memory region size.
// With an average compiled object size of 75 bytes (taken over sample of 9000 lines of rule code), SHMMAX / 75 = 400000 objects.
// The maximum size of the hash table should be twice the objects that can fit in shared memory (400000 * 2 = 800000).
// The ratio of the shared memory region size to the maximum hash table size is 30000000 / 800000 = 37.5
// Since the calculations are based on an average size, the ratio is rounded to 40 to avoid imbuing too much significance.
// The size of the hash table for a cache of the passed-in size, then, should be the size of the cache divided by the ratio.
// hashtable size upper limit == cache size upper limit / 40 == 30000000 / 40 < 800000
const int SHMEM_TO_MAX_HASHTABLE_SIZE_RATIO{40};
Hashtable *objectMap = newHashTable(size / SHMEM_TO_MAX_HASHTABLE_SIZE_RATIO);
MK_PTR( RuleSet, coreRuleSet );
ecopy->coreRuleSetStatus = COMPRESSED;
ecopy->appRuleSet = NULL;
ecopy->appRuleSetStatus = UNINITIALIZED;
ecopy->extRuleSet = NULL;
ecopy->extRuleSetStatus = UNINITIALIZED;
MK_PTR_TAPP( Env, coreFuncDescIndex, PARAM( Node ) );
ecopy->coreFuncDescIndexStatus = COMPRESSED; /* The coreFuncDescIndex is stored in a continuously allocated memory block in *buf */
ecopy->appFuncDescIndex = NULL;
ecopy->appFuncDescIndexStatus = UNINITIALIZED;
ecopy->extFuncDescIndex = NULL;
ecopy->extFuncDescIndexStatus = UNINITIALIZED;
ecopy->dataSize = ( *p - buf );
ecopy->address = buf;
ecopy->pointers = pointers0;
ecopy->cacheSize = size;
ecopy->cacheStatus = INITIALIZED;
ecopy->appRegion = NULL;
ecopy->appRegionStatus = UNINITIALIZED;
ecopy->coreRegion = NULL;
ecopy->coreRegionStatus = UNINITIALIZED;
ecopy->extRegion = NULL;
ecopy->extRegionStatus = UNINITIALIZED;
ecopy->sysRegion = NULL;
ecopy->sysRegionStatus = UNINITIALIZED;
ecopy->sysFuncDescIndex = NULL;
ecopy->sysFuncDescIndexStatus = UNINITIALIZED;
ecopy->ruleEngineStatus = UNINITIALIZED;
MK_VAR_ARRAY_IN_STRUCT( char, ruleBase );
deleteHashTable( objectMap, nop );
return ecopy;
}
