/* * cpu_up: * * Flag specified cpu as up and running. Called when a processor comes * online. */ void cpu_up( int cpu) { register struct machine_slot *ms; register processor_t processor; spl_t s; processor = cpu_to_processor(cpu); /* * Can't risk blocking with no current thread established. * Just twiddle our thumbs; we've got nothing better to do * yet, anyway. */ while (!pset_lock_try(&default_pset)) ; s = splsched(); processor_lock(processor); #if NCPUS > 1 init_ast_check(processor); #endif /* NCPUS > 1 */ ms = &machine_slot[cpu]; ms->running = TRUE; machine_info.avail_cpus++; pset_add_processor(&default_pset, processor); processor->state = PROCESSOR_RUNNING; processor_unlock(processor); splx(s); pset_unlock(&default_pset); }
/* * ipc_processor_terminate: * * Processor is off-line. Destroy ipc control port. */ void ipc_processor_terminate( processor_t processor) { ipc_port_t myport; spl_t s; s = splsched(); processor_lock(processor); myport = processor->processor_self; if (myport == IP_NULL) { processor_unlock(processor); splx(s); return; } processor->processor_self = IP_NULL; processor_unlock(processor); splx(s); ipc_port_dealloc_kernel(myport); }
/* * processor_shutdown() queues a processor up for shutdown. * Any assignment in progress is overriden. It does not synchronize * with the shutdown (can be called from interrupt level). */ kern_return_t processor_shutdown( processor_t processor) { spl_t s; s = splsched(); processor_lock(processor); if(processor->state == PROCESSOR_OFF_LINE || processor->state == PROCESSOR_SHUTDOWN) { /* * Already shutdown or being shutdown -- nothing to do. */ processor_unlock(processor); splx(s); return(KERN_SUCCESS); } (void) processor_request_action(processor, PROCESSOR_SET_NULL); processor_unlock(processor); splx(s); return(KERN_SUCCESS); }
ipc_port_t convert_processor_to_port( processor_t processor) { ipc_port_t port; spl_t s; s = splsched(); processor_lock(processor); if (processor->processor_self != IP_NULL) port = ipc_port_make_send(processor->processor_self); else port = IP_NULL; processor_unlock(processor); splx(s); return port; }
void cpu_down( int cpu) { register struct machine_slot *ms; register processor_t processor; spl_t s; processor = cpu_to_processor(cpu); s = splsched(); processor_lock(processor); ms = &machine_slot[cpu]; ms->running = FALSE; machine_info.avail_cpus--; /* * processor has already been removed from pset. */ processor->processor_set_next = PROCESSOR_SET_NULL; processor->state = PROCESSOR_OFF_LINE; processor_unlock(processor); splx(s); }
void processor_doaction( processor_t processor) { thread_t this_thread; spl_t s; register processor_set_t pset; #if MACH_HOST register processor_set_t new_pset; register thread_t thread; register thread_t prev_thread = THREAD_NULL; thread_act_t thr_act; boolean_t have_pset_ref = FALSE; #endif /* MACH_HOST */ /* * Get onto the processor to shutdown */ this_thread = current_thread(); thread_bind(this_thread, processor); thread_block((void (*)(void)) 0); pset = processor->processor_set; #if MACH_HOST /* * If this is the last processor in the processor_set, * stop all the threads first. */ pset_lock(pset); if (pset->processor_count == 1) { thread = (thread_t) queue_first(&pset->threads); prev_thread = THREAD_NULL; pset->ref_count++; have_pset_ref = TRUE; pset->empty = TRUE; /* * loop through freezing the processor set assignment * and reference counting the threads; */ while (!queue_end(&pset->threads, (queue_entry_t) thread)) { thread_reference(thread); pset_unlock(pset); /* * Freeze the thread on the processor set. * If it's moved, just release the reference. * Get the next thread in the processor set list * from the last one which was frozen. */ if( thread_stop_freeze(thread, pset) ) prev_thread = thread; else thread_deallocate(thread); pset_lock(pset); if( prev_thread != THREAD_NULL ) thread = (thread_t)queue_next(&prev_thread->pset_threads); else thread = (thread_t) queue_first(&pset->threads); } /* * Remove the processor from the set so that when the threads * are unstopped below the ones blocked in the kernel don't * start running again. */ s = splsched(); processor_lock(processor); pset_remove_processor(pset, processor); /* * Prevent race with another processor being added to the set * See code after Restart_pset: * while(new_pset->empty && new_pset->processor_count > 0) * * ... it tests for the condition where a new processor is * added to the set while the last one is still being removed. */ pset->processor_count++; /* block new processors being added */ assert( pset->processor_count == 1 ); /* * Release the thread assignment locks, unstop the threads and * release the thread references which were taken above. */ thread = (thread_t) queue_first(&pset->threads); while( !queue_empty( &pset->threads) && (thread != THREAD_NULL) ) { prev_thread = thread; if( queue_end(&pset->threads, (queue_entry_t) thread) ) thread = THREAD_NULL; else thread = (thread_t) queue_next(&prev_thread->pset_threads); pset_unlock(pset); thread_unfreeze(prev_thread); thread_unstop(prev_thread); thread_deallocate(prev_thread); pset_lock(pset); } /* * allow a processor to be added to the empty pset */ pset->processor_count--; } else { /* not last processor in set */ #endif /* MACH_HOST */ /* * At this point, it is ok to rm the processor from the pset. */ s = splsched(); processor_lock(processor); pset_remove_processor(pset, processor); #if MACH_HOST } pset_unlock(pset); /* * Copy the next pset pointer into a local variable and clear * it because we are taking over its reference. */ new_pset = processor->processor_set_next; processor->processor_set_next = PROCESSOR_SET_NULL; if (processor->state == PROCESSOR_ASSIGN) { Restart_pset: /* * Nasty problem: we want to lock the target pset, but * we have to enable interrupts to do that which requires * dropping the processor lock. While the processor * is unlocked, it could be reassigned or shutdown. */ processor_unlock(processor); splx(s); /* * Lock target pset and handle remove last / assign first race. * Only happens if there is more than one action thread. */ pset_lock(new_pset); while (new_pset->empty && new_pset->processor_count > 0) { pset_unlock(new_pset); while (*(volatile boolean_t *)&new_pset->empty && *(volatile int *)&new_pset->processor_count > 0) /* spin */; pset_lock(new_pset); } /* * Finally relock the processor and see if something changed. * The only possibilities are assignment to a different pset * and shutdown. */ s = splsched(); processor_lock(processor); if (processor->state == PROCESSOR_SHUTDOWN) { pset_unlock(new_pset); goto shutdown; /* will release pset reference */ } if (processor->processor_set_next != PROCESSOR_SET_NULL) { /* * Processor was reassigned. Drop the reference * we have on the wrong new_pset, and get the * right one. Involves lots of lock juggling. */ processor_unlock(processor); splx(s); pset_unlock(new_pset); pset_deallocate(new_pset); s = splsched(); processor_lock(processor); new_pset = processor->processor_set_next; processor->processor_set_next = PROCESSOR_SET_NULL; goto Restart_pset; } /* * If the pset has been deactivated since the operation * was requested, redirect to the default pset. */ if (!(new_pset->active)) { pset_unlock(new_pset); pset_deallocate(new_pset); new_pset = &default_pset; pset_lock(new_pset); new_pset->ref_count++; } /* * Do assignment, then wakeup anyone waiting for it. * Finally context switch to have it take effect. */ pset_add_processor(new_pset, processor); if (new_pset->empty) { /* * Set all the threads loose */ thread = (thread_t) queue_first(&new_pset->threads); while (!queue_end(&new_pset->threads,(queue_entry_t)thread)) { thr_act = thread_lock_act(thread); thread_release(thread->top_act); act_unlock_thread(thr_act); thread = (thread_t) queue_next(&thread->pset_threads); } new_pset->empty = FALSE; } processor->processor_set_next = PROCESSOR_SET_NULL; processor->state = PROCESSOR_RUNNING; thread_wakeup((event_t)processor); processor_unlock(processor); splx(s); pset_unlock(new_pset); /* * Clean up dangling references, and release our binding. */ pset_deallocate(new_pset); if (have_pset_ref) pset_deallocate(pset); if (prev_thread != THREAD_NULL) thread_deallocate(prev_thread); thread_bind(this_thread, PROCESSOR_NULL); thread_block((void (*)(void)) 0); return; } shutdown: #endif /* MACH_HOST */ /* * Do shutdown, make sure we live when processor dies. */ if (processor->state != PROCESSOR_SHUTDOWN) { printf("state: %d\n", processor->state); panic("action_thread -- bad processor state"); } processor_unlock(processor); /* * Clean up dangling references, and release our binding. */ #if MACH_HOST if (new_pset != PROCESSOR_SET_NULL) pset_deallocate(new_pset); if (have_pset_ref) pset_deallocate(pset); if (prev_thread != THREAD_NULL) thread_deallocate(prev_thread); #endif /* MACH_HOST */ thread_bind(this_thread, PROCESSOR_NULL); switch_to_shutdown_context(this_thread, processor_doshutdown, processor); splx(s); }
/* * processor_assign() changes the processor set that a processor is * assigned to. Any previous assignment in progress is overriden. * Synchronizes with assignment completion if wait is TRUE. */ kern_return_t processor_assign( processor_t processor, processor_set_t new_pset, boolean_t wait) { spl_t s; register processor_set_t old_next_pset; /* * Check for null arguments. * XXX Can't assign master processor. */ if (processor == PROCESSOR_NULL || new_pset == PROCESSOR_SET_NULL || processor == master_processor) { return(KERN_FAILURE); } /* * Get pset reference to donate to processor_request_action. */ pset_reference(new_pset); s = splsched(); processor_lock(processor); if(processor->state == PROCESSOR_OFF_LINE || processor->state == PROCESSOR_SHUTDOWN) { /* * Already shutdown or being shutdown -- Can't reassign. */ processor_unlock(processor); splx(s); pset_deallocate(new_pset); return(KERN_FAILURE); } old_next_pset = processor_request_action(processor, new_pset); /* * Synchronization with completion. */ if (wait) { while (processor->state == PROCESSOR_ASSIGN || processor->state == PROCESSOR_SHUTDOWN) { assert_wait((event_t)processor, TRUE); processor_unlock(processor); splx(s); thread_block((void (*)(void)) 0); s = splsched(); processor_lock(processor); } } processor_unlock(processor); splx(s); if (old_next_pset != PROCESSOR_SET_NULL) pset_deallocate(old_next_pset); return(KERN_SUCCESS); }