/*
* 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);
}
