X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/0b4e3aa066abc0728aacb4bbeb86f53f9737156e..cf03f5cdc65293b4cb5eba3ed23fed26dad903c9:/bsd/kern/kern_fork.c diff --git a/bsd/kern/kern_fork.c b/bsd/kern/kern_fork.c index 58aa6ecf4..da5fec8f8 100644 --- a/bsd/kern/kern_fork.c +++ b/bsd/kern/kern_fork.c @@ -1,21 +1,24 @@ /* - * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. + * Copyright (c) 2000-2002 Apple Computer, Inc. All rights reserved. * * @APPLE_LICENSE_HEADER_START@ * - * The contents of this file constitute Original Code as defined in and - * are subject to the Apple Public Source License Version 1.1 (the - * "License"). You may not use this file except in compliance with the - * License. Please obtain a copy of the License at - * http://www.apple.com/publicsource and read it before using this file. + * Copyright (c) 1999-2003 Apple Computer, Inc. All Rights Reserved. * - * This Original Code and all software distributed under the License are - * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * 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. 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 OR NON-INFRINGEMENT. Please see the - * License for the specific language governing rights and limitations - * under the License. + * 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_LICENSE_HEADER_END@ */ @@ -71,16 +74,18 @@ #include #include #include +#if KTRACE #include +#endif #include #include #include -thread_t cloneproc(struct proc *, int); +thread_act_t cloneproc(struct proc *, int); struct proc * forkproc(struct proc *, int); -thread_t procdup(); +thread_act_t procdup(); #define DOFORK 0x1 /* fork() system call */ #define DOVFORK 0x2 /* vfork() system call */ @@ -164,6 +169,7 @@ vfork(p, uap, retval) ut->uu_flag |= P_VFORK; ut->uu_proc = newproc; ut->uu_userstate = (void *)act_thread_csave(); + ut->uu_vforkmask = ut->uu_sigmask; thread_set_child(cur_act, newproc->p_pid); @@ -217,6 +223,7 @@ vfork_return(th_act, p, p2, retval) ut->uu_userstate = 0; ut->uu_flag &= ~P_VFORK; ut->uu_proc = 0; + ut->uu_sigmask = ut->uu_vforkmask; p2->p_flag &= ~P_INVFORK; p2->p_vforkact = (void *)0; @@ -230,14 +237,15 @@ vfork_return(th_act, p, p2, retval) return; } -thread_t +thread_act_t procdup( struct proc *child, struct proc *parent) { - thread_t thread; + thread_act_t thread; task_t task; kern_return_t result; + pmap_t pmap; extern task_t kernel_task; if (parent->task == kernel_task) @@ -251,6 +259,7 @@ procdup( set_bsdtask_info(task, child); if (child->p_nice != 0) resetpriority(child); + result = thread_create(task, &thread); if (result != KERN_SUCCESS) printf("fork/procdup: thread_create failed. Code: 0x%x\n", result); @@ -267,7 +276,7 @@ fork1(p1, flags, retval) { register struct proc *p2; register uid_t uid; - thread_t newth, self = current_thread(); + thread_act_t newth; int s, count; task_t t; @@ -297,7 +306,7 @@ fork1(p1, flags, retval) /* The newly created process comes with signal lock held */ newth = cloneproc(p1, 1); - thread_dup(current_act(), newth); + thread_dup(newth); /* p2 = newth->task->proc; */ p2 = (struct proc *)(get_bsdtask_info(get_threadtask(newth))); @@ -344,15 +353,17 @@ fork1(p1, flags, retval) * lock set. fork() code needs to explicity remove this lock * before signals can be delivered */ -thread_t +thread_act_t cloneproc(p1, lock) register struct proc *p1; register int lock; { register struct proc *p2; - thread_t th; + thread_act_t th; p2 = (struct proc *)forkproc(p1,lock); + + th = procdup(p2, p1); /* child, parent */ LIST_INSERT_AFTER(p1, p2, p_pglist); @@ -417,7 +428,8 @@ retry: again: for (; p2 != 0; p2 = p2->p_list.le_next) { while (p2->p_pid == nextpid || - p2->p_pgrp->pg_id == nextpid) { + p2->p_pgrp->pg_id == nextpid || + p2->p_session->s_sid == nextpid) { nextpid++; if (nextpid >= pidchecked) goto retry; @@ -427,6 +439,9 @@ again: if (p2->p_pgrp && p2->p_pgrp->pg_id > nextpid && pidchecked > p2->p_pgrp->pg_id) pidchecked = p2->p_pgrp->pg_id; + if (p2->p_session->s_sid > nextpid && + pidchecked > p2->p_session->s_sid) + pidchecked = p2->p_session->s_sid; } if (!doingzomb) { doingzomb = 1; @@ -464,7 +479,7 @@ again: crhold(p1->p_ucred); lockinit(&p2->p_cred->pc_lock, PLOCK, "proc cred", 0, 0); - /* bump references to the text vnode (for procfs) */ + /* bump references to the text vnode */ p2->p_textvp = p1->p_textvp; if (p2->p_textvp) VREF(p2->p_textvp); @@ -514,9 +529,10 @@ again: p2->sigwait_thread = NULL; p2->exit_thread = NULL; p2->user_stack = p1->user_stack; - p2->p_sigpending = 0; + p2->p_xxxsigpending = 0; p2->p_vforkcnt = 0; p2->p_vforkact = 0; + TAILQ_INIT(&p2->p_uthlist); #if KTRACE /* @@ -551,25 +567,53 @@ uthread_zone_init() } void * -uthread_alloc(void) +uthread_alloc(task_t task, thread_act_t thr_act ) { + struct proc *p; + struct uthread *uth, *uth_parent; void *ut; + extern task_t kernel_task; + boolean_t funnel_state; if (!uthread_zone_inited) uthread_zone_init(); ut = (void *)zalloc(uthread_zone); bzero(ut, sizeof(struct uthread)); + + if (task != kernel_task) { + uth = (struct uthread *)ut; + p = get_bsdtask_info(task); + + funnel_state = thread_funnel_set(kernel_flock, TRUE); + uth_parent = (struct uthread *)get_bsdthread_info(current_act()); + if (uth_parent) { + if (uth_parent->uu_flag & USAS_OLDMASK) + uth->uu_sigmask = uth_parent->uu_oldmask; + else + uth->uu_sigmask = uth_parent->uu_sigmask; + } + uth->uu_act = thr_act; + //signal_lock(p); + if (p) + TAILQ_INSERT_TAIL(&p->p_uthlist, uth, uu_list); + //signal_unlock(p); + (void)thread_funnel_set(kernel_flock, funnel_state); + } + return (ut); } void -uthread_free(void *uthread) +uthread_free(task_t task, void *uthread, void * bsd_info) { struct _select *sel; struct uthread *uth = (struct uthread *)uthread; + struct proc * p = (struct proc *)bsd_info; + extern task_t kernel_task; int size; + boolean_t funnel_state; sel = &uth->uu_state.ss_select; /* cleanup the select bit space */ @@ -586,6 +630,13 @@ uthread_free(void *uthread) sel->wql = 0; } + if ((task != kernel_task) && p) { + funnel_state = thread_funnel_set(kernel_flock, TRUE); + //signal_lock(p); + TAILQ_REMOVE(&p->p_uthlist, uth, uu_list); + //signal_unlock(p); + (void)thread_funnel_set(kernel_flock, funnel_state); + } /* and free the uthread itself */ zfree(uthread_zone, (vm_offset_t)uthread); }