void
stack_free_reserved(
thread_t thread)
{
if (thread->reserved_stack != thread->kernel_stack) {
stack_free_stack(thread->reserved_stack);
STACK_ZINFO_PFREE(thread);
}
}
/*
* stack_free:
*
* Detach and free the stack for a thread.
*/
void
stack_free(
thread_t thread)
{
vm_offset_t stack = machine_stack_detach(thread);
assert(stack);
if (stack != thread->reserved_stack)
stack_free_stack(stack);
}
/*
* stack_free:
*
* Detach and free the stack for a thread.
*/
void
stack_free(
thread_t thread)
{
vm_offset_t stack = machine_stack_detach(thread);
assert(stack);
if (stack != thread->reserved_stack) {
STACK_ZINFO_PFREE(thread);
stack_free_stack(stack);
}
}
/*
* thread_terminate_self:
*/
void
thread_terminate_self(void)
{
thread_t thread = current_thread();
task_t task;
spl_t s;
int lastthread = 0;
thread_mtx_lock(thread);
ulock_release_all(thread);
ipc_thread_disable(thread);
thread_mtx_unlock(thread);
s = splsched();
thread_lock(thread);
/*
* Cancel priority depression, wait for concurrent expirations
* on other processors.
*/
if (thread->sched_mode & TH_MODE_ISDEPRESSED) {
thread->sched_mode &= ~TH_MODE_ISDEPRESSED;
if (timer_call_cancel(&thread->depress_timer))
thread->depress_timer_active--;
}
while (thread->depress_timer_active > 0) {
thread_unlock(thread);
splx(s);
delay(1);
s = splsched();
thread_lock(thread);
}
thread_unlock(thread);
splx(s);
thread_policy_reset(thread);
/*
* If we are the last thread to terminate and the task is
* associated with a BSD process, perform BSD process exit.
*/
task = thread->task;
uthread_cleanup(task, thread->uthread, task->bsd_info);
if (hw_atomic_sub(&task->active_thread_count, 1) == 0 &&
task->bsd_info != NULL) {
lastthread = 1;
}
if (lastthread != 0)
proc_exit(task->bsd_info);
uthread_cred_free(thread->uthread);
s = splsched();
thread_lock(thread);
/*
* Cancel wait timer, and wait for
* concurrent expirations.
*/
if (thread->wait_timer_is_set) {
thread->wait_timer_is_set = FALSE;
if (timer_call_cancel(&thread->wait_timer))
thread->wait_timer_active--;
}
while (thread->wait_timer_active > 0) {
thread_unlock(thread);
splx(s);
delay(1);
s = splsched();
thread_lock(thread);
}
/*
* If there is a reserved stack, release it.
*/
if (thread->reserved_stack != 0) {
if (thread->reserved_stack != thread->kernel_stack)
stack_free_stack(thread->reserved_stack);
thread->reserved_stack = 0;
}
/*
* Mark thread as terminating, and block.
*/
thread->state |= TH_TERMINATE;
thread_mark_wait_locked(thread, THREAD_UNINT);
assert(thread->promotions == 0);
thread_unlock(thread);
/* splsched */
thread_block((thread_continue_t)thread_terminate_continue);
/*NOTREACHED*/
}
