void X86ContextCreateAndFork(X86Context *self, X86Context *forked)
{
/* Initialize baseline contect */
X86ContextDoCreate(self, forked->emu);
/* Copy registers */
x86_regs_copy(self->regs, forked->regs);
/* Memory */
self->address_space_index = self->emu->address_space_index++;
self->mem = mem_create();
self->spec_mem = spec_mem_create(self->mem);
mem_clone(self->mem, forked->mem);
/* Loader */
self->loader = x86_loader_link(forked->loader);
/* Signal handlers and file descriptor table */
self->signal_handler_table = x86_signal_handler_table_create();
self->file_desc_table = x86_file_desc_table_create();
/* Libc segment */
self->glibc_segment_base = forked->glibc_segment_base;
self->glibc_segment_limit = forked->glibc_segment_limit;
/* Set parent */
self->parent = forked;
}
void test_mem_clone()
{
fprintf( stderr, " Testing mem_clone ... " );
char *pt;
char *pt_clone;
size_t pt_size = 10000;
size_t i;
pt = mem_get( pt_size );
memset( pt, 'X', pt_size );
pt_clone = mem_clone( pt, pt_size );
assert( pt_clone != pt );
assert( &pt_clone != &pt );
for ( i = 0; i < pt_size; i++ ) {
assert( pt[ i ] == pt_clone[ i ] );
}
mem_free( ( void * ) &pt );
mem_free( ( void * ) &pt_clone );
fprintf( stderr, "OK\n" );
}
list_sl *bed_entries_get( char *path, const int cols )
{
/* Martin A. Hansen, September 2008 */
/* Get a singly linked list with all BED entries (of a given number of coluns */
/* from a specified file. */
list_sl *list = list_sl_new();
node_sl *node = node_sl_new();
node_sl *old_node = NULL;
bed_entry *entry = NULL;
FILE *fp = NULL;
entry = bed_entry_new( cols );
fp = read_open( path );
if ( ( bed_entry_get( fp, &entry ) ) )
{
node->val = mem_clone( entry, sizeof( bed_entry ) );
list_sl_add_beg( &list, &node );
old_node = node;
}
while ( ( bed_entry_get( fp, &entry ) ) )
{
node = node_sl_new();
node->val = mem_clone( entry, sizeof( bed_entry ) );
list_sl_add_after( &old_node, &node );
old_node = node;
}
close_stream( fp );
return list;
}
int pagemap_alloc(ptptr p)
{
unsigned int proc = udata.u_page;
unsigned int nproc = p - ptab;
p->p_page = nproc;
/* Init is special */
if (p->p_pid == 1) {
store[nproc] = mem_alloc();
store[nproc]->last = p;
mem[nproc] = store[nproc];
return 0;
}
/* Allocate memory for the old process as a copy of the new as the
new will run first. We know that mem[proc] = store[proc] as proc
is running the fork() */
store[proc] = mem_clone(mem[proc]);
if (store[proc] == NULL)
return ENOMEM;
mem[nproc] = mem[proc];
/* Last for our child is us */
store[nproc]->last = udata.u_ptab;
return 0;
}
