int main (int argc, char *argv[])
{
printf("main enter\n");
thread_data_create(NUM_THREADS,fHello);
thread_data_join(NUM_THREADS);
thread_data_create(NUM_THREADS,fBusyWork);
thread_data_join(NUM_THREADS);
//pthread_exit((void*)threadarg);
printf("main exit\n");
exit(EXIT_SUCCESS);
}
void copy_task_struct(task_t *task, task_t *parent, char share_thread_data)
{
task->parent = parent;
task->pid = add_atomic(&next_pid, 1)-1;
/* copy over the data if we're a new process. If this is going to be a thread,
* then add to the count and set the pointer */
if(!share_thread_data) {
task->thread = thread_data_create();
copy_thread_data(task, parent);
} else {
add_atomic(&parent->thread->count, 1);
task->thread = parent->thread;
assert(parent->thread->magic == THREAD_MAGIC);
}
task->tty = parent->tty;
task->sig_mask = parent->sig_mask;
task->priority = parent->priority;
task->stack_end = parent->stack_end;
task->heap_end = parent->heap_end;
task->heap_start = parent->heap_start;
task->system = parent->system;
task->cmask = parent->cmask;
task->path_loc_start = parent->path_loc_start;
copy_file_handles(parent, task);
/* this flag gets cleared on the first scheduling of this task */
task->flags = TF_FORK;
task->phys_mem_usage = parent->phys_mem_usage;
}
void init_multitasking()
{
printk(KERN_DEBUG, "[sched]: Starting multitasking system...\n");
/* make the kernel task */
task_t *task = task_create();
task->pid = next_pid++;
task->pd = (page_dir_t *)kernel_dir;
task->stack_end=STACK_LOCATION;
task->priority = 1;
task->cpu = primary_cpu;
task->thread = thread_data_create();
/* alarm_mutex is aquired inside a kernel tick, so we may not schedule. */
alarm_mutex = mutex_create(0, MT_NOSCHED);
kill_queue = ll_create(0);
primary_queue = tqueue_create(0, 0);
primary_cpu->active_queue = tqueue_create(0, 0);
tqueue_insert(primary_queue, (void *)task, task->listnode);
tqueue_insert(primary_cpu->active_queue, (void *)task, task->activenode);
primary_cpu->cur = task;
primary_cpu->ktask = task;
primary_cpu->numtasks=1;
/* make this the "current_task" by assigning a specific location
* in the page directory as the pointer to the task. */
arch_specific_set_current_task((addr_t *)kernel_dir, (addr_t)task);
kernel_task = task;
/* this is the final thing to allow the system to begin scheduling
* once interrupts are enabled */
primary_cpu->flags |= CPU_TASK;
add_atomic(&running_processes, 1);
#if CONFIG_MODULES
add_kernel_symbol(delay);
add_kernel_symbol(delay_sleep);
add_kernel_symbol(schedule);
add_kernel_symbol(run_scheduler);
add_kernel_symbol(exit);
add_kernel_symbol(sys_setsid);
add_kernel_symbol(do_fork);
add_kernel_symbol(kill_task);
add_kernel_symbol(do_send_signal);
add_kernel_symbol(dosyscall);
add_kernel_symbol(task_pause);
add_kernel_symbol(task_resume);
add_kernel_symbol(got_signal);
#if CONFIG_SMP
add_kernel_symbol(get_cpu);
#endif
_add_kernel_symbol((addr_t)(task_t **)&kernel_task, "kernel_task");
#endif
}
static void
event_thread_init(void *drcontext)
{
per_thread_t *data;
static volatile int thread_count;
if (options.native_until_thread > 0) {
int local_count = dr_atomic_add32_return_sum(&thread_count, 1);
NOTIFY(1, "@@@@@@@@@@@@@ new thread #%d "TIDFMT"\n",
local_count, dr_get_thread_id(drcontext));
if (go_native && local_count == options.native_until_thread) {
void **drcontexts = NULL;
uint num_threads, i;
go_native = false;
NOTIFY(1, "thread "TIDFMT" suspending all threads\n",
dr_get_thread_id(drcontext));
if (dr_suspend_all_other_threads_ex(&drcontexts, &num_threads, NULL,
DR_SUSPEND_NATIVE)) {
NOTIFY(1, "suspended %d threads\n", num_threads);
for (i = 0; i < num_threads; i++) {
if (dr_is_thread_native(drcontexts[i])) {
NOTIFY(2, "\txxx taking over thread #%d "TIDFMT"\n",
i, dr_get_thread_id(drcontexts[i]));
dr_retakeover_suspended_native_thread(drcontexts[i]);
} else {
NOTIFY(2, "\tthread #%d "TIDFMT" under DR\n",
i, dr_get_thread_id(drcontexts[i]));
}
}
if (!dr_resume_all_other_threads(drcontexts, num_threads)) {
ASSERT(false, "failed to resume threads");
}
} else {
ASSERT(false, "failed to suspend threads");
}
}
}
/* allocate thread private data for per-thread cache */
if (drcov_per_thread)
data = thread_data_create(drcontext);
else
data = thread_data_copy(drcontext);
drmgr_set_tls_field(drcontext, tls_idx, data);
}
static void *
global_data_create(void)
{
return thread_data_create(NULL);
}
