Sneed-Group/gems-kernel
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
gems-kernel/source/THIRDPARTY/xnu/bsd/kern/kern_fork.c

1573 lines
46 KiB
C
Raw Normal View History

add darwin/xnu functionality
2024-06-03 11:29:39 -05:00
/*
* Copyright (c) 2000-2020 Apple Inc. All rights reserved.
*
* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
*
* This file contains Original Code and/or Modifications of Original Code
* as defined in and that are subject to the Apple Public Source License
* Version 2.0 (the 'License'). You may not use this file except in
* compliance with the License. The rights granted to you under the License
* may not be used to create, or enable the creation or redistribution of,
* unlawful or unlicensed copies of an Apple operating system, or to
* circumvent, violate, or enable the circumvention or violation of, any
* terms of an Apple operating system software license agreement.
*
* Please obtain a copy of the License at
* http://www.opensource.apple.com/apsl/ and read it before using this file.
*
* The Original Code and all software distributed under the License are
* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
* Please see the License for the specific language governing rights and
* limitations under the License.
*
* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
*/
/* Copyright (c) 1995, 1997 Apple Computer, Inc. All Rights Reserved */
/*
* Copyright (c) 1982, 1986, 1989, 1991, 1993
* The Regents of the University of California. All rights reserved.
* (c) UNIX System Laboratories, Inc.
* All or some portions of this file are derived from material licensed
* to the University of California by American Telephone and Telegraph
* Co. or Unix System Laboratories, Inc. and are reproduced herein with
* the permission of UNIX System Laboratories, Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* @(#)kern_fork.c 8.8 (Berkeley) 2/14/95
*/
/*
* NOTICE: This file was modified by McAfee Research in 2004 to introduce
* support for mandatory and extensible security protections. This notice
* is included in support of clause 2.2 (b) of the Apple Public License,
* Version 2.0.
*/
/*
* NOTICE: This file was modified by SPARTA, Inc. in 2005 to introduce
* support for mandatory and extensible security protections. This notice
* is included in support of clause 2.2 (b) of the Apple Public License,
* Version 2.0.
*/
#include <kern/assert.h>
#include <kern/bits.h>
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/filedesc.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/proc_internal.h>
#include <sys/kauth.h>
#include <sys/user.h>
#include <sys/reason.h>
#include <sys/resourcevar.h>
#include <sys/vnode_internal.h>
#include <sys/file_internal.h>
#include <sys/acct.h>
#include <sys/codesign.h>
#include <sys/sysent.h>
#include <sys/sysproto.h>
#include <sys/ulock.h>
#if CONFIG_PERSONAS
#include <sys/persona.h>
#endif
#include <sys/doc_tombstone.h>
#if CONFIG_DTRACE
/* Do not include dtrace.h, it redefines kmem_[alloc/free] */
extern void (*dtrace_proc_waitfor_exec_ptr)(proc_t);
extern void dtrace_proc_fork(proc_t, proc_t, int);
/*
* Since dtrace_proc_waitfor_exec_ptr can be added/removed in dtrace_subr.c,
* we will store its value before actually calling it.
*/
static void (*dtrace_proc_waitfor_hook)(proc_t) = NULL;
#include <sys/dtrace_ptss.h>
#endif
#include <security/audit/audit.h>
#include <mach/mach_types.h>
#include <kern/coalition.h>
#include <kern/kern_types.h>
#include <kern/kalloc.h>
#include <kern/mach_param.h>
#include <kern/task.h>
#include <kern/thread.h>
#include <kern/thread_call.h>
#include <kern/zalloc.h>
#if CONFIG_MACF
#include <security/mac_framework.h>
#include <security/mac_mach_internal.h>
#endif
#include <vm/vm_map.h>
#include <vm/vm_protos.h>
#include <vm/vm_shared_region.h>
#include <sys/shm_internal.h> /* for shmfork() */
#include <mach/task.h> /* for thread_create() */
#include <mach/thread_act.h> /* for thread_resume() */
#include <sys/sdt.h>
#if CONFIG_MEMORYSTATUS
#include <sys/kern_memorystatus.h>
#endif
static const uint64_t startup_serial_num_procs = 300;
bool startup_serial_logging_active = true;
/* XXX routines which should have Mach prototypes, but don't */
extern void act_thread_catt(void *ctx);
void thread_set_child(thread_t child, int pid);
boolean_t thread_is_active(thread_t thread);
void *act_thread_csave(void);
extern boolean_t task_is_exec_copy(task_t);
int nextpidversion = 0;
void ipc_task_enable(task_t task);
proc_t forkproc(proc_t, cloneproc_flags_t);
void forkproc_free(proc_t);
thread_t fork_create_child(task_t parent_task,
coalition_t *parent_coalitions,
proc_t child,
int is_64bit_addr,
int is_64bit_data,
cloneproc_flags_t clone_flags);
__private_extern__ const size_t uthread_size = sizeof(struct uthread);
static LCK_GRP_DECLARE(rethrottle_lock_grp, "rethrottle");
os_refgrp_decl(, p_refgrp, "proc", NULL);
extern const size_t task_alignment;
const size_t proc_alignment = _Alignof(struct proc);
extern size_t task_struct_size;
size_t proc_struct_size = sizeof(struct proc);
size_t proc_and_task_size;
ZONE_DECLARE_ID(ZONE_ID_PROC_TASK, struct proc);
SECURITY_READ_ONLY_LATE(zone_t) proc_task_zone;
KALLOC_TYPE_DEFINE(proc_stats_zone, struct pstats, KT_DEFAULT);
/*
* fork1
*
* Description: common code used by all new process creation other than the
* bootstrap of the initial process on the system
*
* Parameters: parent_proc parent process of the process being
* child_threadp pointer to location to receive the
* Mach thread_t of the child process
* created
* kind kind of creation being requested
* coalitions if spawn, the set of coalitions the
* child process should join, or NULL to
* inherit the parent's. On non-spawns,
* this param is ignored and the child
* always inherits the parent's
* coalitions.
*
* Notes: Permissable values for 'kind':
*
* PROC_CREATE_FORK Create a complete process which will
* return actively running in both the
* parent and the child; the child copies
* the parent address space.
* PROC_CREATE_SPAWN Create a complete process which will
* return actively running in the parent
* only after returning actively running
* in the child; the child address space
* is newly created by an image activator,
* after which the child is run.
*
* At first it may seem strange that we return the child thread
* address rather than process structure, since the process is
* the only part guaranteed to be "new"; however, since we do
* not actualy adjust other references between Mach and BSD, this
* is the only method which guarantees us the ability to get
* back to the other information.
*/
int
fork1(proc_t parent_proc, thread_t *child_threadp, int kind, coalition_t *coalitions)
{
proc_t child_proc = NULL; /* set in switch, but compiler... */
thread_t child_thread = NULL;
uid_t uid;
size_t count;
int err = 0;
int spawn = 0;
rlim_t rlimit_nproc_cur;
/*
* Although process entries are dynamically created, we still keep
* a global limit on the maximum number we will create. Don't allow
* a nonprivileged user to use the last process; don't let root
* exceed the limit. The variable nprocs is the current number of
* processes, maxproc is the limit.
*/
uid = kauth_getruid();
proc_list_lock();
if ((nprocs >= maxproc - 1 && uid != 0) || nprocs >= maxproc) {
#if (DEVELOPMENT || DEBUG) && !defined(XNU_TARGET_OS_OSX)
/*
* On the development kernel, panic so that the fact that we hit
* the process limit is obvious, as this may very well wedge the
* system.
*/
panic("The process table is full; parent pid=%d", proc_getpid(parent_proc));
#endif
proc_list_unlock();
tablefull("proc");
return EAGAIN;
}
proc_list_unlock();
/*
* Increment the count of procs running with this uid. Don't allow
* a nonprivileged user to exceed their current limit, which is
* always less than what an rlim_t can hold.
* (locking protection is provided by list lock held in chgproccnt)
*/
count = chgproccnt(uid, 1);
rlimit_nproc_cur = proc_limitgetcur(parent_proc, RLIMIT_NPROC);
if (uid != 0 &&
(rlim_t)count > rlimit_nproc_cur) {
#if (DEVELOPMENT || DEBUG) && !defined(XNU_TARGET_OS_OSX)
/*
* On the development kernel, panic so that the fact that we hit
* the per user process limit is obvious. This may be less dire
* than hitting the global process limit, but we cannot rely on
* that.
*/
panic("The per-user process limit has been hit; parent pid=%d, uid=%d", proc_getpid(parent_proc), uid);
#endif
err = EAGAIN;
goto bad;
}
#if CONFIG_MACF
/*
* Determine if MAC policies applied to the process will allow
* it to fork. This is an advisory-only check.
*/
err = mac_proc_check_fork(parent_proc);
if (err != 0) {
goto bad;
}
#endif
switch (kind) {
case PROC_CREATE_SPAWN:
/*
* A spawned process differs from a forked process in that
* the spawned process does not carry around the parents
* baggage with regard to address space copying, dtrace,
* and so on.
*/
spawn = 1;
OS_FALLTHROUGH;
case PROC_CREATE_FORK:
/*
* When we clone the parent process, we are going to inherit
* its task attributes and memory, since when we fork, we
* will, in effect, create a duplicate of it, with only minor
* differences. Contrarily, spawned processes do not inherit.
*/
if ((child_thread = cloneproc(proc_task(parent_proc),
spawn ? coalitions : NULL,
parent_proc,
spawn ? CLONEPROC_SPAWN : CLONEPROC_FORK)) == NULL) {
/* Failed to create thread */
err = EAGAIN;
goto bad;
}
/* child_proc = child_thread->task->proc; */
child_proc = (proc_t)(get_bsdtask_info(get_threadtask(child_thread)));
if (!spawn) {
/* Copy current thread state into the child thread (only for fork) */
thread_dup(child_thread);
}
// XXX BEGIN: wants to move to be common code (and safe)
#if CONFIG_MACF
/*
* allow policies to associate the credential/label that
* we referenced from the parent ... with the child
* JMM - this really isn't safe, as we can drop that
* association without informing the policy in other
* situations (keep long enough to get policies changed)
*/
mac_cred_label_associate_fork(proc_ucred_unsafe(child_proc),
child_proc);
#endif
/*
* Propogate change of PID - may get new cred if auditing.
*/
set_security_token(child_proc, proc_ucred_unsafe(child_proc));
AUDIT_ARG(pid, proc_getpid(child_proc));
// XXX END: wants to move to be common code (and safe)
/*
* Blow thread state information; this is what gives the child
* process its "return" value from a fork() call.
*
* Note: this should probably move to fork() proper, since it
* is not relevent to spawn, and the value won't matter
* until we resume the child there. If you are in here
* refactoring code, consider doing this at the same time.
*/
thread_set_child(child_thread, proc_getpid(child_proc));
child_proc->p_acflag = AFORK; /* forked but not exec'ed */
#if CONFIG_DTRACE
dtrace_proc_fork(parent_proc, child_proc, spawn);
#endif /* CONFIG_DTRACE */
if (!spawn) {
/*
* Of note, we need to initialize the bank context behind
* the protection of the proc_trans lock to prevent a race with exit.
*/
task_bank_init(get_threadtask(child_thread));
}
break;
default:
panic("fork1 called with unknown kind %d", kind);
break;
}
/* return the thread pointer to the caller */
*child_threadp = child_thread;
bad:
/*
* In the error case, we return a 0 value for the returned pid (but
* it is ignored in the trampoline due to the error return); this
* is probably not necessary.
*/
if (err) {
(void)chgproccnt(uid, -1);
}
return err;
}
/*
* fork_create_child
*
* Description: Common operations associated with the creation of a child
* process. Return with new task and first thread's control port movable
* and not pinned.
*
* Parameters: parent_task parent task
* parent_coalitions parent's set of coalitions
* child_proc child process
* inherit_memory TRUE, if the parents address space is
* to be inherited by the child
* is_64bit_addr TRUE, if the child being created will
* be associated with a 64 bit address space
* is_64bit_data TRUE if the child being created will use a
* 64-bit register state
* in_exec TRUE, if called from execve or posix spawn set exec
* FALSE, if called from fork or vfexec
*
* Note: This code is called in the fork() case, from the execve() call
* graph, from the posix_spawn() call graph (which implicitly
* includes a vfork() equivalent call, and in the system
* bootstrap case.
*
* It creates a new task and thread (and as a side effect of the
* thread creation, a uthread) in the parent coalition set, which is
* then associated with the process 'child'. If the parent
* process address space is to be inherited, then a flag
* indicates that the newly created task should inherit this from
* the child task.
*
* As a special concession to bootstrapping the initial process
* in the system, it's possible for 'parent_task' to be TASK_NULL;
* in this case, 'inherit_memory' MUST be FALSE.
*/
thread_t
fork_create_child(task_t parent_task,
coalition_t *parent_coalitions,
proc_t child_proc,
int is_64bit_addr,
int is_64bit_data,
cloneproc_flags_t clone_flags)
{
thread_t child_thread = NULL;
task_t child_task;
kern_return_t result;
proc_ro_t proc_ro;
bool inherit_memory = !!(clone_flags & CLONEPROC_FORK);
bool in_exec = !!(clone_flags & CLONEPROC_EXEC);
/*
* Exec complete hook should be called for spawn and exec, but not for fork.
*/
uint8_t returnwaitflags = (!inherit_memory ? TRW_LEXEC_COMPLETE : 0) |
(TRW_LRETURNWAIT | TRW_LRETURNWAITER);
proc_ro = proc_get_ro(child_proc);
if (proc_ro_task(proc_ro) != NULL) {
panic("Proc_ro_task for newly created proc %p is not NULL", child_proc);
}
child_task = proc_get_task_raw(child_proc);
/*
* Create a new task for the child process, IPC access to the new task will
* be set up after task has been fully initialized.
*/
result = task_create_internal(parent_task,
proc_ro,
parent_coalitions,
inherit_memory,
is_64bit_addr,
is_64bit_data,
TF_NONE,
TF_NONE,
in_exec ? TPF_EXEC_COPY : TPF_NONE, /* Mark the task exec copy if in execve */
returnwaitflags, /* All created threads will wait in task_wait_to_return */
child_task);
if (result != KERN_SUCCESS) {
printf("%s: task_create_internal failed. Code: %d\n",
__func__, result);
goto bad;
}
/* Set the child proc process to child task */
proc_set_task(child_proc, child_task);
/* Set child task process to child proc */
set_bsdtask_info(child_task, child_proc);
/* Propagate CPU limit timer from parent */
if (timerisset(&child_proc->p_rlim_cpu)) {
task_vtimer_set(child_task, TASK_VTIMER_RLIM);
}
/*
* Set child process BSD visible scheduler priority if nice value
* inherited from parent
*/
if (child_proc->p_nice != 0) {
resetpriority(child_proc);
}
/*
* Create main thread for the child process. Its control port is not immovable/pinned
* until main_thread_set_immovable_pinned().
*
* The new thread is waiting on the event triggered by 'task_clear_return_wait'
*/
result = main_thread_create_waiting(child_task,
(thread_continue_t)task_wait_to_return,
task_get_return_wait_event(child_task),
&child_thread);
if (result != KERN_SUCCESS) {
printf("%s: thread_create failed. Code: %d\n",
__func__, result);
task_deallocate(child_task);
child_task = NULL;
}
/*
* Tag thread as being the first thread in its task.
*/
thread_set_tag(child_thread, THREAD_TAG_MAINTHREAD);
bad:
thread_yield_internal(1);
return child_thread;
}
/*
* fork
*
* Description: fork system call.
*
* Parameters: parent Parent process to fork
* uap (void) [unused]
* retval Return value
*
* Returns: 0 Success
* EAGAIN Resource unavailable, try again
*
* Notes: Attempts to create a new child process which inherits state
* from the parent process. If successful, the call returns
* having created an initially suspended child process with an
* extra Mach task and thread reference, for which the thread
* is initially suspended. Until we resume the child process,
* it is not yet running.
*
* The return information to the child is contained in the
* thread state structure of the new child, and does not
* become visible to the child through a normal return process,
* since it never made the call into the kernel itself in the
* first place.
*
* After resuming the thread, this function returns directly to
* the parent process which invoked the fork() system call.
*
* Important: The child thread_resume occurs before the parent returns;
* depending on scheduling latency, this means that it is not
* deterministic as to whether the parent or child is scheduled
* to run first. It is entirely possible that the child could
* run to completion prior to the parent running.
*/
int
fork(proc_t parent_proc, __unused struct fork_args *uap, int32_t *retval)
{
thread_t child_thread;
int err;
retval[1] = 0; /* flag parent return for user space */
if ((err = fork1(parent_proc, &child_thread, PROC_CREATE_FORK, NULL)) == 0) {
task_t child_task;
proc_t child_proc;
/* Return to the parent */
child_proc = (proc_t)get_bsdthreadtask_info(child_thread);
retval[0] = proc_getpid(child_proc);
child_task = (task_t)get_threadtask(child_thread);
assert(child_task != TASK_NULL);
/* task_control_port_options has been inherited from parent, apply it */
task_set_immovable_pinned(child_task);
main_thread_set_immovable_pinned(child_thread);
/*
* Since the task ports for this new task are now set to be immovable,
* we can enable them.
*/
ipc_task_enable(get_threadtask(child_thread));
/*
* Drop the signal lock on the child which was taken on our
* behalf by forkproc()/cloneproc() to prevent signals being
* received by the child in a partially constructed state.
*/
proc_signalend(child_proc, 0);
proc_transend(child_proc, 0);
/* flag the fork has occurred */
proc_knote(parent_proc, NOTE_FORK | proc_getpid(child_proc));
DTRACE_PROC1(create, proc_t, child_proc);
#if CONFIG_DTRACE
if ((dtrace_proc_waitfor_hook = dtrace_proc_waitfor_exec_ptr) != NULL) {
(*dtrace_proc_waitfor_hook)(child_proc);
}
#endif
/*
* If current process died during the fork, the child would contain
* non consistent vmmap, kill the child and reap it internally.
*/
if (parent_proc->p_lflag & P_LEXIT || !thread_is_active(current_thread())) {
task_terminate_internal(child_task);
proc_list_lock();
child_proc->p_listflag |= P_LIST_DEADPARENT;
proc_list_unlock();
}
/* "Return" to the child */
task_clear_return_wait(get_threadtask(child_thread), TCRW_CLEAR_ALL_WAIT);
/* drop the extra references we got during the creation */
task_deallocate(child_task);
thread_deallocate(child_thread);
}
return err;
}
/*
* cloneproc
*
* Description: Create a new process from a specified process.
*
* Parameters: parent_task The parent task to be cloned, or
* TASK_NULL is task characteristics
* are not to be inherited
* be cloned, or TASK_NULL if the new
* task is not to inherit the VM
* characteristics of the parent
* parent_proc The parent process to be cloned
* clone_flags Clone flags to specify if the cloned
* process should inherit memory,
* marked as memory stat internal,
* or if the cloneproc is called for exec.
*
* Returns: !NULL pointer to new child thread
* NULL Failure (unspecified)
*
* Note: On return newly created child process has signal lock held
* to block delivery of signal to it if called with lock set.
* fork() code needs to explicity remove this lock before
* signals can be delivered
*
* In the case of bootstrap, this function can be called from
* bsd_utaskbootstrap() in order to bootstrap the first process;
* the net effect is to provide a uthread structure for the
* kernel process associated with the kernel task.
*
* XXX: Tristating using the value parent_task as the major key
* and inherit_memory as the minor key is something we should
* refactor later; we owe the current semantics, ultimately,
* to the semantics of task_create_internal. For now, we will
* live with this being somewhat awkward.
*/
thread_t
cloneproc(task_t parent_task, coalition_t *parent_coalitions, proc_t parent_proc, cloneproc_flags_t clone_flags)
{
#if !CONFIG_MEMORYSTATUS
#pragma unused(cloning_initproc)
#endif
task_t child_task;
proc_t child_proc;
thread_t child_thread = NULL;
bool cloning_initproc = !!(clone_flags & CLONEPROC_INITPROC);
bool in_exec = !!(clone_flags & CLONEPROC_EXEC);
if ((child_proc = forkproc(parent_proc, clone_flags)) == NULL) {
/* Failed to allocate new process */
goto bad;
}
/*
* In the case where the parent_task is TASK_NULL (during the init path)
* we make the assumption that the register size will be the same as the
* address space size since there's no way to determine the possible
* register size until an image is exec'd.
*
* The only architecture that has different address space and register sizes
* (arm64_32) isn't being used within kernel-space, so the above assumption
* always holds true for the init path.
*/
const int parent_64bit_addr = parent_proc->p_flag & P_LP64;
const int parent_64bit_data = (parent_task == TASK_NULL) ? parent_64bit_addr : task_get_64bit_data(parent_task);
child_thread = fork_create_child(parent_task,
parent_coalitions,
child_proc,
parent_64bit_addr,
parent_64bit_data,
clone_flags);
if (child_thread == NULL) {
/*
* Failed to create thread; now we must deconstruct the new
* process previously obtained from forkproc().
*/
forkproc_free(child_proc);
goto bad;
}
child_task = get_threadtask(child_thread);
if (parent_64bit_addr) {
OSBitOrAtomic(P_LP64, (UInt32 *)&child_proc->p_flag);
get_bsdthread_info(child_thread)->uu_flag |= UT_LP64;
} else {
OSBitAndAtomic(~((uint32_t)P_LP64), (UInt32 *)&child_proc->p_flag);
get_bsdthread_info(child_thread)->uu_flag &= ~UT_LP64;
}
#if CONFIG_MEMORYSTATUS
if (cloning_initproc ||
(in_exec && (parent_proc->p_memstat_state & P_MEMSTAT_INTERNAL))) {
proc_list_lock();
child_proc->p_memstat_state |= P_MEMSTAT_INTERNAL;
child_proc->p_memstat_effectivepriority = JETSAM_PRIORITY_INTERNAL;
child_proc->p_memstat_requestedpriority = JETSAM_PRIORITY_INTERNAL;
proc_list_unlock();
}
if (in_exec && parent_proc->p_memstat_relaunch_flags != P_MEMSTAT_RELAUNCH_UNKNOWN) {
memorystatus_relaunch_flags_update(child_proc, parent_proc->p_memstat_relaunch_flags);
}
#endif
/* make child visible */
pinsertchild(parent_proc, child_proc, in_exec);
/*
* Make child runnable, set start time.
*/
child_proc->p_stat = SRUN;
bad:
return child_thread;
}
void
proc_set_sigact(proc_t p, int sig, user_addr_t sigact)
{
assert((sig > 0) && (sig < NSIG));
p->p_sigacts.ps_sigact[sig] = sigact;
}
void
proc_set_trampact(proc_t p, int sig, user_addr_t trampact)
{
assert((sig > 0) && (sig < NSIG));
p->p_sigacts.ps_trampact[sig] = trampact;
}
void
proc_set_sigact_trampact(proc_t p, int sig, user_addr_t sigact, user_addr_t trampact)
{
assert((sig > 0) && (sig < NSIG));
p->p_sigacts.ps_sigact[sig] = sigact;
p->p_sigacts.ps_trampact[sig] = trampact;
}
void
proc_reset_sigact(proc_t p, sigset_t sigs)
{
user_addr_t *sigacts = p->p_sigacts.ps_sigact;
int nc;
while (sigs) {
nc = ffs((unsigned int)sigs);
if (sigacts[nc] != SIG_DFL) {
sigacts[nc] = SIG_DFL;
}
sigs &= ~sigmask(nc);
}
}
/*
* Destroy a process structure that resulted from a call to forkproc(), but
* which must be returned to the system because of a subsequent failure
* preventing it from becoming active.
*
* Parameters: p The incomplete process from forkproc()
*
* Returns: (void)
*
* Note: This function should only be used in an error handler following
* a call to forkproc().
*
* Operations occur in reverse order of those in forkproc().
*/
void
forkproc_free(proc_t p)
{
struct pgrp *pg;
#if CONFIG_PERSONAS
persona_proc_drop(p);
#endif /* CONFIG_PERSONAS */
#if PSYNCH
pth_proc_hashdelete(p);
#endif /* PSYNCH */
/* We held signal and a transition locks; drop them */
proc_signalend(p, 0);
proc_transend(p, 0);
/*
* If we have our own copy of the resource limits structure, we
* need to free it. If it's a shared copy, we need to drop our
* reference on it.
*/
proc_limitdrop(p);
#if SYSV_SHM
/* Need to drop references to the shared memory segment(s), if any */
if (p->vm_shm) {
/*
* Use shmexec(): we have no address space, so no mappings
*
* XXX Yes, the routine is badly named.
*/
shmexec(p);
}
#endif
/* Need to undo the effects of the fdt_fork(), if any */
fdt_invalidate(p);
fdt_destroy(p);
/*
* Drop the reference on a text vnode pointer, if any
* XXX This code is broken in forkproc(); see <rdar://4256419>;
* XXX if anyone ever uses this field, we will be extremely unhappy.
*/
if (p->p_textvp) {
vnode_rele(p->p_textvp);
p->p_textvp = NULL;
}
/* Update the audit session proc count */
AUDIT_SESSION_PROCEXIT(p);
lck_mtx_destroy(&p->p_mlock, &proc_mlock_grp);
lck_mtx_destroy(&p->p_ucred_mlock, &proc_ucred_mlock_grp);
#if CONFIG_AUDIT
lck_mtx_destroy(&p->p_audit_mlock, &proc_ucred_mlock_grp);
#endif /* CONFIG_AUDIT */
#if CONFIG_DTRACE
lck_mtx_destroy(&p->p_dtrace_sprlock, &proc_lck_grp);
#endif
lck_spin_destroy(&p->p_slock, &proc_slock_grp);
proc_list_lock();
/* Decrement the count of processes in the system */
nprocs--;
/* quit the group */
pg = pgrp_leave_locked(p);
/* Take it out of process hash */
assert((os_ref_get_raw_mask(&p->p_refcount) >> P_REF_BITS) == 1);
assert((os_ref_get_raw_mask(&p->p_refcount) & P_REF_NEW) == P_REF_NEW);
os_atomic_xor(&p->p_refcount, P_REF_NEW | P_REF_DEAD, relaxed);
/* Remove from hash if not a shadow proc */
if (!proc_is_shadow(p)) {
phash_remove_locked(p);
}
proc_list_unlock();
pgrp_rele(pg);
thread_call_free(p->p_rcall);
/* Free allocated memory */
zfree(proc_stats_zone, p->p_stats);
p->p_stats = NULL;
if (p->p_subsystem_root_path) {
zfree(ZV_NAMEI, p->p_subsystem_root_path);
p->p_subsystem_root_path = NULL;
}
proc_checkdeadrefs(p);
proc_wait_release(p);
}
/*
* forkproc
*
* Description: Create a new process structure, given a parent process
* structure.
*
* Parameters: parent_proc The parent process
*
* Returns: !NULL The new process structure
* NULL Error (insufficient free memory)
*
* Note: When successful, the newly created process structure is
* partially initialized; if a caller needs to deconstruct the
* returned structure, they must call forkproc_free() to do so.
*/
proc_t
forkproc(proc_t parent_proc, cloneproc_flags_t clone_flags)
{
static uint64_t nextuniqueid = 0;
static pid_t lastpid = 0;
proc_t child_proc; /* Our new process */
int error = 0;
struct pgrp *pg;
uthread_t parent_uthread = current_uthread();
rlim_t rlimit_cpu_cur;
pid_t pid;
struct proc_ro_data proc_ro_data = {};
bool in_exec = !!(clone_flags & CLONEPROC_EXEC);
bool in_fork = !!(clone_flags & CLONEPROC_FORK);
child_proc = zalloc_flags(proc_task_zone, Z_WAITOK | Z_ZERO);
child_proc->p_stats = zalloc_flags(proc_stats_zone, Z_WAITOK | Z_ZERO);
child_proc->p_sigacts = parent_proc->p_sigacts;
os_ref_init_mask(&child_proc->p_refcount, P_REF_BITS, &p_refgrp, P_REF_NEW);
os_ref_init_raw(&child_proc->p_waitref, &p_refgrp);
proc_ref_hold_proc_task_struct(child_proc);
/* allocate a callout for use by interval timers */
child_proc->p_rcall = thread_call_allocate((thread_call_func_t)realitexpire, child_proc);
/*
* Find an unused PID.
*/
fdt_init(child_proc);
proc_list_lock();
if (!in_exec) {
pid = lastpid;
do {
/*
* If the process ID prototype has wrapped around,
* restart somewhat above 0, as the low-numbered procs
* tend to include daemons that don't exit.
*/
if (++pid >= PID_MAX) {
pid = 100;
}
if (pid == lastpid) {
panic("Unable to allocate a new pid");
}
/* if the pid stays in hash both for zombie and runniing state */
} while (phash_find_locked(pid) != PROC_NULL ||
pghash_exists_locked(pid) ||
session_find_locked(pid) != SESSION_NULL);
lastpid = pid;
nprocs++;
child_proc->p_pid = pid;
proc_ro_data.p_idversion = OSIncrementAtomic(&nextpidversion);
/* kernel process is handcrafted and not from fork, so start from 1 */
proc_ro_data.p_uniqueid = ++nextuniqueid;
/* Insert in the hash, and inherit our group (and session) */
phash_insert_locked(child_proc);
/* Check if the proc is from App Cryptex */
if (parent_proc->p_ladvflag & P_RSR) {
os_atomic_or(&child_proc->p_ladvflag, P_RSR, relaxed);
}
} else {
/* For exec copy of the proc, copy the pid, pidversion and uniqueid of original proc */
pid = parent_proc->p_pid;
child_proc->p_pid = pid;
proc_ro_data.p_idversion = parent_proc->p_proc_ro->p_idversion;
proc_ro_data.p_uniqueid = parent_proc->p_proc_ro->p_uniqueid;
nprocs++;
os_atomic_or(&child_proc->p_refcount, P_REF_SHADOW, relaxed);
}
pg = pgrp_enter_locked(parent_proc, child_proc);
proc_list_unlock();
if (proc_ro_data.p_uniqueid == startup_serial_num_procs) {
/*
* Turn off startup serial logging now that we have reached
* the defined number of startup processes.
*/
startup_serial_logging_active = false;
}
/*
* We've identified the PID we are going to use;
* initialize the new process structure.
*/
child_proc->p_stat = SIDL;
/*
* The zero'ing of the proc was at the allocation time due to need
* for insertion to hash. Copy the section that is to be copied
* directly from the parent.
*/
child_proc->p_forkcopy = parent_proc->p_forkcopy;
proc_ro_data.syscall_filter_mask = proc_syscall_filter_mask(parent_proc);
proc_ro_data.p_platform_data = proc_get_ro(parent_proc)->p_platform_data;
/*
* Some flags are inherited from the parent.
* Duplicate sub-structures as needed.
* Increase reference counts on shared objects.
* The p_stats substruct is set in vm_fork.
*/
#if CONFIG_DELAY_IDLE_SLEEP
child_proc->p_flag = (parent_proc->p_flag & (P_LP64 | P_TRANSLATED | P_DISABLE_ASLR | P_DELAYIDLESLEEP | P_SUGID | P_AFFINITY));
#else /* CONFIG_DELAY_IDLE_SLEEP */
child_proc->p_flag = (parent_proc->p_flag & (P_LP64 | P_TRANSLATED | P_DISABLE_ASLR | P_SUGID | P_AFFINITY));
#endif /* CONFIG_DELAY_IDLE_SLEEP */
child_proc->p_vfs_iopolicy = (parent_proc->p_vfs_iopolicy & (P_VFS_IOPOLICY_INHERITED_MASK));
proc_set_responsible_pid(child_proc, parent_proc->p_responsible_pid);
/*
* Note that if the current thread has an assumed identity, this
* credential will be granted to the new process.
* This is OK to do in exec, because it will be over-written during image activation
* before the proc is visible.
*/
kauth_cred_set(&proc_ro_data.p_ucred.__smr_ptr, kauth_cred_get());
lck_mtx_init(&child_proc->p_mlock, &proc_mlock_grp, &proc_lck_attr);
lck_mtx_init(&child_proc->p_ucred_mlock, &proc_ucred_mlock_grp, &proc_lck_attr);
#if CONFIG_AUDIT
lck_mtx_init(&child_proc->p_audit_mlock, &proc_ucred_mlock_grp, &proc_lck_attr);
#endif /* CONFIG_AUDIT */
#if CONFIG_DTRACE
lck_mtx_init(&child_proc->p_dtrace_sprlock, &proc_lck_grp, &proc_lck_attr);
#endif
lck_spin_init(&child_proc->p_slock, &proc_slock_grp, &proc_lck_attr);
klist_init(&child_proc->p_klist);
if (child_proc->p_textvp != NULLVP) {
/* bump references to the text vnode */
/* Need to hold iocount across the ref call */
if ((error = vnode_getwithref(child_proc->p_textvp)) == 0) {
error = vnode_ref(child_proc->p_textvp);
vnode_put(child_proc->p_textvp);
}
if (error != 0) {
child_proc->p_textvp = NULLVP;
}
}
uint64_t csflag_inherit_mask = ~CS_KILLED;
if (!in_fork) {
/* All non-fork paths should not inherit GTA flag */
csflag_inherit_mask &= ~CS_GET_TASK_ALLOW;
}
proc_ro_data.p_csflags = ((uint32_t)proc_getcsflags(parent_proc) & csflag_inherit_mask);
child_proc->p_proc_ro = proc_ro_alloc(child_proc, &proc_ro_data, NULL, NULL);
/* update cred on proc */
proc_update_creds_onproc(child_proc, proc_ucred_unsafe(child_proc));
/* update audit session proc count */
AUDIT_SESSION_PROCNEW(child_proc);
/*
* Copy the parents per process open file table to the child; if
* there is a per-thread current working directory, set the childs
* per-process current working directory to that instead of the
* parents.
*/
if (fdt_fork(&child_proc->p_fd, parent_proc, parent_uthread->uu_cdir, in_exec) != 0) {
forkproc_free(child_proc);
child_proc = NULL;
goto bad;
}
#if SYSV_SHM
if (parent_proc->vm_shm && !in_exec) {
/* XXX may fail to attach shm to child */
(void)shmfork(parent_proc, child_proc);
}
#endif
/*
* Child inherits the parent's plimit
*/
proc_limitfork(parent_proc, child_proc);
rlimit_cpu_cur = proc_limitgetcur(child_proc, RLIMIT_CPU);
if (rlimit_cpu_cur != RLIM_INFINITY) {
child_proc->p_rlim_cpu.tv_sec = (rlimit_cpu_cur > __INT_MAX__) ? __INT_MAX__ : rlimit_cpu_cur;
}
if (in_exec) {
/* Keep the original start time for exec'ed proc */
child_proc->p_stats->ps_start = parent_proc->p_stats->ps_start;
child_proc->p_start.tv_sec = parent_proc->p_start.tv_sec;
child_proc->p_start.tv_usec = parent_proc->p_start.tv_usec;
} else {
/* Intialize new process stats, including start time */
/* <rdar://6640543> non-zeroed portion contains garbage AFAICT */
microtime_with_abstime(&child_proc->p_start, &child_proc->p_stats->ps_start);
}
if (pg->pg_session->s_ttyvp != NULL && parent_proc->p_flag & P_CONTROLT) {
os_atomic_or(&child_proc->p_flag, P_CONTROLT, relaxed);
}
/*
* block all signals to reach the process.
* no transition race should be occuring with the child yet,
* but indicate that the process is in (the creation) transition.
*/
proc_signalstart(child_proc, 0);
proc_transstart(child_proc, 0, 0);
child_proc->p_pcaction = 0;
TAILQ_INIT(&child_proc->p_uthlist);
TAILQ_INIT(&child_proc->p_aio_activeq);
TAILQ_INIT(&child_proc->p_aio_doneq);
/*
* Copy work queue information
*
* Note: This should probably only happen in the case where we are
* creating a child that is a copy of the parent; since this
* routine is called in the non-duplication case of vfork()
* or posix_spawn(), then this information should likely not
* be duplicated.
*
* <rdar://6640553> Work queue pointers that no longer point to code
*/
child_proc->p_wqthread = parent_proc->p_wqthread;
child_proc->p_threadstart = parent_proc->p_threadstart;
child_proc->p_pthsize = parent_proc->p_pthsize;
if ((parent_proc->p_lflag & P_LREGISTER) != 0) {
child_proc->p_lflag |= P_LREGISTER;
}
child_proc->p_dispatchqueue_offset = parent_proc->p_dispatchqueue_offset;
child_proc->p_dispatchqueue_serialno_offset = parent_proc->p_dispatchqueue_serialno_offset;
child_proc->p_dispatchqueue_label_offset = parent_proc->p_dispatchqueue_label_offset;
child_proc->p_return_to_kernel_offset = parent_proc->p_return_to_kernel_offset;
child_proc->p_mach_thread_self_offset = parent_proc->p_mach_thread_self_offset;
child_proc->p_pth_tsd_offset = parent_proc->p_pth_tsd_offset;
child_proc->p_pthread_wq_quantum_offset = parent_proc->p_pthread_wq_quantum_offset;
#if PSYNCH
pth_proc_hashinit(child_proc);
#endif /* PSYNCH */
#if CONFIG_PERSONAS
child_proc->p_persona = NULL;
if (parent_proc->p_persona) {
struct persona *persona = proc_persona_get(parent_proc);
if (persona) {
error = persona_proc_adopt(child_proc, persona, NULL);
if (error != 0) {
printf("forkproc: persona_proc_inherit failed (persona %d being destroyed?)\n",
persona_get_id(persona));
forkproc_free(child_proc);
child_proc = NULL;
goto bad;
}
}
}
#endif
#if CONFIG_MEMORYSTATUS
/* Memorystatus init */
child_proc->p_memstat_state = 0;
child_proc->p_memstat_effectivepriority = JETSAM_PRIORITY_DEFAULT;
child_proc->p_memstat_requestedpriority = JETSAM_PRIORITY_DEFAULT;
child_proc->p_memstat_assertionpriority = 0;
child_proc->p_memstat_userdata = 0;
child_proc->p_memstat_idle_start = 0;
child_proc->p_memstat_idle_delta = 0;
child_proc->p_memstat_memlimit = 0;
child_proc->p_memstat_memlimit_active = 0;
child_proc->p_memstat_memlimit_inactive = 0;
child_proc->p_memstat_relaunch_flags = P_MEMSTAT_RELAUNCH_UNKNOWN;
#if CONFIG_FREEZE
child_proc->p_memstat_freeze_sharedanon_pages = 0;
#endif
child_proc->p_memstat_dirty = 0;
child_proc->p_memstat_idledeadline = 0;
#endif /* CONFIG_MEMORYSTATUS */
if (parent_proc->p_subsystem_root_path) {
size_t parent_length = strlen(parent_proc->p_subsystem_root_path) + 1;
assert(parent_length <= MAXPATHLEN);
child_proc->p_subsystem_root_path = zalloc_flags(ZV_NAMEI,
Z_WAITOK | Z_ZERO);
memcpy(child_proc->p_subsystem_root_path, parent_proc->p_subsystem_root_path, parent_length);
}
bad:
return child_proc;
}
void
proc_lock(proc_t p)
{
LCK_MTX_ASSERT(&proc_list_mlock, LCK_MTX_ASSERT_NOTOWNED);
lck_mtx_lock(&p->p_mlock);
}
void
proc_unlock(proc_t p)
{
lck_mtx_unlock(&p->p_mlock);
}
void
proc_spinlock(proc_t p)
{
lck_spin_lock_grp(&p->p_slock, &proc_slock_grp);
}
void
proc_spinunlock(proc_t p)
{
lck_spin_unlock(&p->p_slock);
}
void
proc_list_lock(void)
{
lck_mtx_lock(&proc_list_mlock);
}
void
proc_list_unlock(void)
{
lck_mtx_unlock(&proc_list_mlock);
}
void
proc_ucred_lock(proc_t p)
{
lck_mtx_lock(&p->p_ucred_mlock);
}
void
proc_ucred_unlock(proc_t p)
{
lck_mtx_unlock(&p->p_ucred_mlock);
}
void
proc_update_creds_onproc(proc_t p, kauth_cred_t cred)
{
p->p_uid = kauth_cred_getuid(cred);
p->p_gid = kauth_cred_getgid(cred);
p->p_ruid = kauth_cred_getruid(cred);
p->p_rgid = kauth_cred_getrgid(cred);
p->p_svuid = kauth_cred_getsvuid(cred);
p->p_svgid = kauth_cred_getsvgid(cred);
}
bool
uthread_is64bit(struct uthread *uth)
{
return uth->uu_flag & UT_LP64;
}
void
uthread_init(task_t task, uthread_t uth, thread_ro_t tro_tpl, int workq_thread)
{
uthread_t uth_parent = current_uthread();
lck_spin_init(&uth->uu_rethrottle_lock, &rethrottle_lock_grp,
LCK_ATTR_NULL);
/*
* Lazily set the thread on the kernel VFS context
* to the first thread made which will be vm_pageout_scan_thread.
*/
if (__improbable(vfs_context0.vc_thread == NULL)) {
extern thread_t vm_pageout_scan_thread;
assert(task == kernel_task);
assert(get_machthread(uth) == vm_pageout_scan_thread);
vfs_context0.vc_thread = get_machthread(uth);
}
if (task_get_64bit_addr(task)) {
uth->uu_flag |= UT_LP64;
}
/*
* Thread inherits credential from the creating thread, if both
* are in the same task.
*
* If the creating thread has no credential or is from another
* task we can leave the new thread credential NULL. If it needs
* one later, it will be lazily assigned from the task's process.
*/
if (task == kernel_task) {
kauth_cred_set(&tro_tpl->tro_cred, vfs_context0.vc_ucred);
kauth_cred_set(&tro_tpl->tro_realcred, vfs_context0.vc_ucred);
tro_tpl->tro_proc = kernproc;
tro_tpl->tro_proc_ro = kernproc->p_proc_ro;
} else if (!task_is_a_corpse(task)) {
thread_ro_t curtro = current_thread_ro();
proc_t p = get_bsdtask_info(task);
if (task == curtro->tro_task) {
kauth_cred_set(&tro_tpl->tro_realcred,
curtro->tro_realcred);
if (workq_thread) {
kauth_cred_set(&tro_tpl->tro_cred,
curtro->tro_realcred);
} else {
kauth_cred_set(&tro_tpl->tro_cred,
curtro->tro_cred);
}
tro_tpl->tro_proc_ro = curtro->tro_proc_ro;
} else {
kauth_cred_t cred = kauth_cred_proc_ref(p);
kauth_cred_set(&tro_tpl->tro_realcred, cred);
kauth_cred_set(&tro_tpl->tro_cred, cred);
kauth_cred_unref(&cred);
tro_tpl->tro_proc_ro = task_get_ro(task);
}
tro_tpl->tro_proc = p;
proc_lock(p);
if (workq_thread) {
/* workq_thread threads will not inherit masks */
uth->uu_sigmask = ~workq_threadmask;
} else if (uth_parent->uu_flag & UT_SAS_OLDMASK) {
uth->uu_sigmask = uth_parent->uu_oldmask;
} else {
uth->uu_sigmask = uth_parent->uu_sigmask;
}
TAILQ_INSERT_TAIL(&p->p_uthlist, uth, uu_list);
proc_unlock(p);
#if CONFIG_DTRACE
if (p->p_dtrace_ptss_pages != NULL) {
uth->t_dtrace_scratch = dtrace_ptss_claim_entry(p);
}
#endif
} else {
tro_tpl->tro_proc_ro = task_get_ro(task);
}
uth->uu_pending_sigreturn = 0;
uthread_init_proc_refcount(uth);
}
mach_port_name_t
uthread_joiner_port(struct uthread *uth)
{
return uth->uu_save.uus_bsdthread_terminate.kport;
}
user_addr_t
uthread_joiner_address(uthread_t uth)
{
return uth->uu_save.uus_bsdthread_terminate.ulock_addr;
}
void
uthread_joiner_wake(task_t task, uthread_t uth)
{
struct _bsdthread_terminate bts = uth->uu_save.uus_bsdthread_terminate;
assert(bts.ulock_addr);
bzero(&uth->uu_save.uus_bsdthread_terminate, sizeof(bts));
int flags = UL_UNFAIR_LOCK | ULF_WAKE_ALL | ULF_WAKE_ALLOW_NON_OWNER;
(void)ulock_wake(task, flags, bts.ulock_addr, 0);
mach_port_deallocate(get_task_ipcspace(task), bts.kport);
}
/*
* This routine frees the thread name field of the uthread_t structure. Split out of
* uthread_cleanup() so thread name does not get deallocated while generating a corpse fork.
*/
void
uthread_cleanup_name(uthread_t uth)
{
/*
* <rdar://17834538>
* Set pth_name to NULL before calling free().
* Previously there was a race condition in the
* case this code was executing during a stackshot
* where the stackshot could try and copy pth_name
* after it had been freed and before if was marked
* as null.
*/
if (uth->pth_name != NULL) {
void *pth_name = uth->pth_name;
uth->pth_name = NULL;
kfree_data(pth_name, MAXTHREADNAMESIZE);
}
return;
}
/*
* This routine frees all the BSD context in uthread except the credential.
* It does not free the uthread structure as well
*/
void
uthread_cleanup(uthread_t uth, thread_ro_t tro)
{
task_t task = tro->tro_task;
proc_t p = tro->tro_proc;
uthread_assert_zero_proc_refcount(uth);
if (uth->uu_lowpri_window || uth->uu_throttle_info) {
/*
* task is marked as a low priority I/O type
* and we've somehow managed to not dismiss the throttle
* through the normal exit paths back to user space...
* no need to throttle this thread since its going away
* but we do need to update our bookeeping w/r to throttled threads
*
* Calling this routine will clean up any throttle info reference
* still inuse by the thread.
*/
throttle_lowpri_io(0);
}
#if CONFIG_AUDIT
/*
* Per-thread audit state should never last beyond system
* call return. Since we don't audit the thread creation/
* removal, the thread state pointer should never be
* non-NULL when we get here.
*/
assert(uth->uu_ar == NULL);
#endif
if (uth->uu_select.nbytes) {
select_cleanup_uthread(&uth->uu_select);
}
if (uth->uu_cdir) {
vnode_rele(uth->uu_cdir);
uth->uu_cdir = NULLVP;
}
if (uth->uu_selset) {
select_set_free(uth->uu_selset);
uth->uu_selset = NULL;
}
os_reason_free(uth->uu_exit_reason);
if ((task != kernel_task) && p) {
/*
* Remove the thread from the process list and
* transfer [appropriate] pending signals to the process.
* Do not remove the uthread from proc uthlist for exec
* copy task, since they does not have a ref on proc and
* would not have been added to the list.
*/
if (uth->uu_kqr_bound) {
kqueue_threadreq_unbind(p, uth->uu_kqr_bound);
}
if (get_bsdtask_info(task) == p) {
proc_lock(p);
TAILQ_REMOVE(&p->p_uthlist, uth, uu_list);
p->p_siglist |= (uth->uu_siglist & execmask & (~p->p_sigignore | sigcantmask));
proc_unlock(p);
}
#if CONFIG_DTRACE
struct dtrace_ptss_page_entry *tmpptr = uth->t_dtrace_scratch;
uth->t_dtrace_scratch = NULL;
if (tmpptr != NULL) {
dtrace_ptss_release_entry(p, tmpptr);
}
#endif
} else {
assert(!uth->uu_kqr_bound);
}
}
/* This routine releases the credential stored in uthread */
void
uthread_cred_ref(struct ucred *ucred)
{
kauth_cred_ref(ucred);
}
void
uthread_cred_free(struct ucred *ucred)
{
kauth_cred_set(&ucred, NOCRED);
}
/* This routine frees the uthread structure held in thread structure */
void
uthread_destroy(uthread_t uth)
{
uthread_destroy_proc_refcount(uth);
if (uth->t_tombstone) {
kfree_type(struct doc_tombstone, uth->t_tombstone);
uth->t_tombstone = NULL;
}
#if CONFIG_DEBUG_SYSCALL_REJECTION
size_t const bitstr_len = BITMAP_SIZE(mach_trap_count + nsysent);
if (uth->syscall_rejection_mask) {
kfree_data(uth->syscall_rejection_mask, bitstr_len);
uth->syscall_rejection_mask = NULL;
}
if (uth->syscall_rejection_once_mask) {
kfree_data(uth->syscall_rejection_once_mask, bitstr_len);
uth->syscall_rejection_once_mask = NULL;
}
#endif /* CONFIG_DEBUG_SYSCALL_REJECTION */
lck_spin_destroy(&uth->uu_rethrottle_lock, &rethrottle_lock_grp);
uthread_cleanup_name(uth);
}
user_addr_t
thread_get_sigreturn_token(thread_t thread)
{
uthread_t ut = (struct uthread *) get_bsdthread_info(thread);
return ut->uu_sigreturn_token;
}
uint32_t
thread_get_sigreturn_diversifier(thread_t thread)
{
uthread_t ut = (struct uthread *) get_bsdthread_info(thread);
return ut->uu_sigreturn_diversifier;
}
Reference in a new issue Copy permalink