void perfmon_init(void) { size_t i; long nr; if (cpu_type == CPU_TIMER_INT) return; if (!no_xen) { xen_ctx = xmalloc(sizeof(struct child)); xen_ctx->pid = getpid(); xen_ctx->up_pipe[0] = -1; xen_ctx->up_pipe[1] = -1; xen_ctx->sigusr1 = 0; xen_ctx->sigusr2 = 0; xen_ctx->sigterm = 0; create_context(xen_ctx); write_pmu(xen_ctx); load_context(xen_ctx); return; } nr = sysconf(_SC_NPROCESSORS_ONLN); if (nr == -1) { fprintf(stderr, "Couldn't determine number of CPUs.\n"); exit(EXIT_FAILURE); } nr_cpus = nr; children = xmalloc(sizeof(struct child) * nr_cpus); bzero(children, sizeof(struct child) * nr_cpus); for (i = 0; i < nr_cpus; ++i) { int ret; if (pipe(children[i].up_pipe)) { perror("Couldn't create child pipe"); exit(EXIT_FAILURE); } ret = fork(); if (ret == -1) { perror("Couldn't fork perfmon child"); exit(EXIT_FAILURE); } else if (ret == 0) { close(children[i].up_pipe[0]); run_child(i); } else { children[i].pid = ret; close(children[i].up_pipe[1]); printf("Waiting on CPU%d\n", (int)i); wait_for_child(&children[i]); } } }
static void run_child(size_t cpu) { struct child * self = &children[cpu]; self->pid = getpid(); self->sigusr1 = 0; self->sigusr2 = 0; self->sigterm = 0; inner_child = self; if (atexit(close_pipe)){ close_pipe(); exit(EXIT_FAILURE); } umask(0); /* Change directory to allow directory to be removed */ if (chdir("/") < 0) { perror("Unable to chdir to \"/\""); exit(EXIT_FAILURE); } setup_signals(); set_affinity(cpu); create_context(self); write_pmu(self); load_context(self); notify_parent(self, cpu); /* Redirect standard files to /dev/null */ freopen( "/dev/null", "r", stdin); freopen( "/dev/null", "w", stdout); freopen( "/dev/null", "w", stderr); for (;;) { sigset_t sigmask; sigfillset(&sigmask); sigdelset(&sigmask, SIGUSR1); sigdelset(&sigmask, SIGUSR2); sigdelset(&sigmask, SIGTERM); if (self->sigusr1) { perfmon_start_child(self->ctx_fd); self->sigusr1 = 0; } if (self->sigusr2) { perfmon_stop_child(self->ctx_fd); self->sigusr2 = 0; } sigsuspend(&sigmask); } }
void PendSV_Handler( void ) { static unsigned stackPointer = 0; stackPointer = save_context(); stackPointer = cHwRTOS_MCU::schedule( stackPointer, false ); load_context( stackPointer ); }
void SysTick_Handler( void ) { static unsigned stackPointer = 0; stackPointer = save_context(); cHwRTOS_MCU::sysTic++; stackPointer = cHwRTOS_MCU::schedule( stackPointer, true ); load_context( stackPointer ); }
void thread_terminate() { thread_t *me = scheduler_running_thread(); (void) scheduler_remove_thread(me->tid); schedule_thread(); me = scheduler_running_thread(); load_context(me->context); }
/* * Start up the first thread on a CPU. * First thread is specified for the master CPU. */ void cpu_launch_first_thread( register thread_t th) { register int mycpu; mycpu = cpu_number(); #if MACH_ASSERT if (watchacts & WA_BOOT) printf("cpu_launch_first_thread(%x) cpu=%d\n", th, mycpu); #endif /* MACH_ASSERT */ cpu_up(mycpu); start_timer(&kernel_timer[mycpu]); /* * Block all interrupts for choose_thread. */ (void) splhigh(); if (th == THREAD_NULL) { th = cpu_to_processor(mycpu)->idle_thread; if (th == THREAD_NULL || !rem_runq(th)) panic("cpu_launch_first_thread"); } rtclock_reset(); /* start realtime clock ticking */ PMAP_ACTIVATE_KERNEL(mycpu); thread_machine_set_current(th); thread_lock(th); th->state &= ~TH_UNINT; thread_unlock(th); timer_switch(&th->system_timer); PMAP_ACTIVATE_USER(th->top_act, mycpu); assert(mycpu == cpu_number()); /* The following is necessary to keep things balanced */ disable_preemption(); load_context(th); /*NOTREACHED*/ }
void kernel_run() { thread_t *init; unsigned i; for (i = 0; i < NELEMENTS(start_array); i++) { start_array[i](); } kprintf("system is running.\n"); schedule_thread(); init = scheduler_running_thread(); load_context(init->context); }
static void run_child(size_t cpu) { struct child * self = &children[cpu]; self->pid = getpid(); self->sigusr1 = 0; self->sigusr2 = 0; self->sigterm = 0; setup_signals(); set_affinity(cpu); create_context(self); write_pmu(self); load_context(self); notify_parent(self, cpu); for (;;) { sigset_t sigmask; sigfillset(&sigmask); sigdelset(&sigmask, SIGUSR1); sigdelset(&sigmask, SIGUSR2); sigdelset(&sigmask, SIGTERM); if (self->sigusr1) { printf("PFM_START on CPU%d\n", (int)cpu); fflush(stdout); perfmon_start_child(self->ctx_fd); self->sigusr1 = 0; } if (self->sigusr2) { printf("PFM_STOP on CPU%d\n", (int)cpu); fflush(stdout); perfmon_stop_child(self->ctx_fd); self->sigusr2 = 0; } sigsuspend(&sigmask); } }
/* * slave_main: * * Load the first thread to start a processor. */ void slave_main(void *machine_param) { processor_t processor = current_processor(); thread_t thread; /* * Use the idle processor thread if there * is no dedicated start up thread. */ if (processor->next_thread == THREAD_NULL) { thread = processor->idle_thread; thread->continuation = (thread_continue_t)processor_start_thread; thread->parameter = machine_param; } else { thread = processor->next_thread; processor->next_thread = THREAD_NULL; } load_context(thread); /*NOTREACHED*/ }
void kernel_bootstrap(void) { kern_return_t result; thread_t thread; char namep[16]; printf("%s\n", version); /* log kernel version */ #define kernel_bootstrap_kprintf(x...) /* kprintf("kernel_bootstrap: " x) */ if (PE_parse_boot_argn("-l", namep, sizeof (namep))) /* leaks logging */ turn_on_log_leaks = 1; PE_parse_boot_argn("trace", &new_nkdbufs, sizeof (new_nkdbufs)); /* i386_vm_init already checks for this ; do it aagin anyway */ if (PE_parse_boot_argn("serverperfmode", &serverperfmode, sizeof (serverperfmode))) { serverperfmode = 1; } scale_setup(); kernel_bootstrap_kprintf("calling vm_mem_bootstrap\n"); vm_mem_bootstrap(); kernel_bootstrap_kprintf("calling vm_mem_init\n"); vm_mem_init(); machine_info.memory_size = (uint32_t)mem_size; machine_info.max_mem = max_mem; machine_info.major_version = version_major; machine_info.minor_version = version_minor; kernel_bootstrap_kprintf("calling sched_init\n"); sched_init(); kernel_bootstrap_kprintf("calling wait_queue_bootstrap\n"); wait_queue_bootstrap(); kernel_bootstrap_kprintf("calling ipc_bootstrap\n"); ipc_bootstrap(); #if CONFIG_MACF mac_policy_init(); #endif kernel_bootstrap_kprintf("calling ipc_init\n"); ipc_init(); /* * As soon as the virtual memory system is up, we record * that this CPU is using the kernel pmap. */ kernel_bootstrap_kprintf("calling PMAP_ACTIVATE_KERNEL\n"); PMAP_ACTIVATE_KERNEL(master_cpu); kernel_bootstrap_kprintf("calling mapping_free_prime\n"); mapping_free_prime(); /* Load up with temporary mapping blocks */ kernel_bootstrap_kprintf("calling machine_init\n"); machine_init(); kernel_bootstrap_kprintf("calling clock_init\n"); clock_init(); ledger_init(); /* * Initialize the IPC, task, and thread subsystems. */ kernel_bootstrap_kprintf("calling task_init\n"); task_init(); kernel_bootstrap_kprintf("calling thread_init\n"); thread_init(); /* * Create a kernel thread to execute the kernel bootstrap. */ kernel_bootstrap_kprintf("calling kernel_thread_create\n"); result = kernel_thread_create((thread_continue_t)kernel_bootstrap_thread, NULL, MAXPRI_KERNEL, &thread); if (result != KERN_SUCCESS) panic("kernel_bootstrap: result = %08X\n", result); thread->state = TH_RUN; thread_deallocate(thread); kernel_bootstrap_kprintf("calling load_context - done\n"); load_context(thread); /*NOTREACHED*/ }
void kernel_bootstrap(void) { kern_return_t result; thread_t thread; char namep[16]; printf("%s\n", version); /* log kernel version */ if (PE_parse_boot_argn("-l", namep, sizeof (namep))) /* leaks logging */ turn_on_log_leaks = 1; PE_parse_boot_argn("trace", &new_nkdbufs, sizeof (new_nkdbufs)); PE_parse_boot_argn("trace_wake", &wake_nkdbufs, sizeof (wake_nkdbufs)); PE_parse_boot_argn("trace_panic", &write_trace_on_panic, sizeof(write_trace_on_panic)); PE_parse_boot_argn("trace_typefilter", &trace_typefilter, sizeof(trace_typefilter)); scale_setup(); kernel_bootstrap_log("vm_mem_bootstrap"); vm_mem_bootstrap(); kernel_bootstrap_log("cs_init"); cs_init(); kernel_bootstrap_log("vm_mem_init"); vm_mem_init(); machine_info.memory_size = (uint32_t)mem_size; machine_info.max_mem = max_mem; machine_info.major_version = version_major; machine_info.minor_version = version_minor; #if CONFIG_TELEMETRY kernel_bootstrap_log("telemetry_init"); telemetry_init(); #endif #if CONFIG_CSR kernel_bootstrap_log("csr_init"); csr_init(); #endif kernel_bootstrap_log("stackshot_lock_init"); stackshot_lock_init(); kernel_bootstrap_log("sched_init"); sched_init(); kernel_bootstrap_log("waitq_bootstrap"); waitq_bootstrap(); kernel_bootstrap_log("ipc_bootstrap"); ipc_bootstrap(); #if CONFIG_MACF kernel_bootstrap_log("mac_policy_init"); mac_policy_init(); #endif kernel_bootstrap_log("ipc_init"); ipc_init(); /* * As soon as the virtual memory system is up, we record * that this CPU is using the kernel pmap. */ kernel_bootstrap_log("PMAP_ACTIVATE_KERNEL"); PMAP_ACTIVATE_KERNEL(master_cpu); kernel_bootstrap_log("mapping_free_prime"); mapping_free_prime(); /* Load up with temporary mapping blocks */ kernel_bootstrap_log("machine_init"); machine_init(); kernel_bootstrap_log("clock_init"); clock_init(); ledger_init(); /* * Initialize the IPC, task, and thread subsystems. */ #if CONFIG_COALITIONS kernel_bootstrap_log("coalitions_init"); coalitions_init(); #endif kernel_bootstrap_log("task_init"); task_init(); kernel_bootstrap_log("thread_init"); thread_init(); #if CONFIG_ATM /* Initialize the Activity Trace Resource Manager. */ kernel_bootstrap_log("atm_init"); atm_init(); #endif #if CONFIG_BANK /* Initialize the BANK Manager. */ kernel_bootstrap_log("bank_init"); bank_init(); #endif /* initialize the corpse config based on boot-args */ corpses_init(); /* * Create a kernel thread to execute the kernel bootstrap. */ kernel_bootstrap_log("kernel_thread_create"); result = kernel_thread_create((thread_continue_t)kernel_bootstrap_thread, NULL, MAXPRI_KERNEL, &thread); if (result != KERN_SUCCESS) panic("kernel_bootstrap: result = %08X\n", result); thread->state = TH_RUN; thread->last_made_runnable_time = mach_absolute_time(); thread_deallocate(thread); kernel_bootstrap_log("load_context - done"); load_context(thread); /*NOTREACHED*/ }
void mod_setup(unsigned int setupfr) { //default key bindings exec_commands("defaults"); //make the mother object fr[setupfr].objs[0] = (object){ mother_type, 0, 0, sizeof(mother), malloc(sizeof(mother)) }; memset( fr[setupfr].objs[0].data, 0, sizeof(mother) ); //make default context object (map) fr[setupfr].objs[1] = (object){ context_type, OBJF_REFC, 0, sizeof(context), malloc(sizeof(context)) }; context *co = fr[setupfr].objs[1].data; co->bsx = co->bsy = co->bsz = 16; co->x = co->y = co->z = 15; co->tileuw = 48; co->tileuh = 24; co->projection = DIMETRIC; int volume = co->x * co->y * co->z; co->map = hack_map = malloc( (sizeof *co->map ) * volume ); //FIXME remove hack co->dmap = hack_dmap = malloc( (sizeof *co->dmap) * volume ); memset( co->map, 0, (sizeof *co->map ) * volume ); memset( co->dmap, 0, (sizeof *co->dmap) * volume ); int i; for( i=0; i<volume; i++ ) { co->map[ i].spr = 0; co->dmap[i].flags = CBF_NULL; } load_context("noise", 1, setupfr); //load a default map //make some dummys #define MAYBE_A_DUMMY(i,x,y,w,h) { \ dummy *du; \ fr[setupfr].objs[i+20].type = dummy_type; \ fr[setupfr].objs[i+20].flags = OBJF_POS|OBJF_VEL|OBJF_HULL|OBJF_VIS|OBJF_PLAT|OBJF_CLIP| \ OBJF_BNDX|OBJF_BNDZ|OBJF_BNDB; \ fr[setupfr].objs[i+20].context = 1; \ fr[setupfr].objs[i+20].size = sizeof *du; \ du = fr[setupfr].objs[i+20].data = malloc(sizeof *du); \ du->pos = (V){x*8,y*8,0}; \ du->vel = (V){0,0,0}; \ du->hull[0] = (V){-w*8,-h*8,-8}; \ du->hull[1] = (V){ w*8, h*8, 8}; \ du->model = 0; } MAYBE_A_DUMMY(20, 3,-25,1,1); MAYBE_A_DUMMY(21, 3,-20,1,1); MAYBE_A_DUMMY(22, 3,-15,1,1); MAYBE_A_DUMMY(23, 3,-10,1,1); MAYBE_A_DUMMY(24, 5,-15,1,1); MAYBE_A_DUMMY(25, 9,-15,1,1); MAYBE_A_DUMMY(26, 43,-20,1,1); MAYBE_A_DUMMY(27, 43,-15,1,1); MAYBE_A_DUMMY(28, 45,-25,1,1); MAYBE_A_DUMMY(29, 45,-20,1,1); MAYBE_A_DUMMY(30, 45,-15,1,1); #undef MAYBE_A_DUMMY fr[setupfr+1].cmds[0].flags |= CMDF_NEW; //server is a client echo("Default controls: \\#F80A, S, Numpad Arrows, F11"); }
mm_html_template::mm_html_template(const wxString& arg_template): html_template(arg_template.ToStdWstring()) { load_context(); }
void SLoader::load_context( const int num_attrs, std::vector<const char*> &positive_context, std::vector<const char*> &negative_context) const { load_context(_path, num_attrs, positive_context, negative_context); }