X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/1c79356b52d46aa6b508fb032f5ae709b1f2897b..cf03f5cdc65293b4cb5eba3ed23fed26dad903c9:/bsd/kern/kern_fork.c diff --git a/bsd/kern/kern_fork.c b/bsd/kern/kern_fork.c index a11175f7b..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,15 +74,18 @@ #include #include #include +#if KTRACE #include +#endif #include #include #include -thread_t cloneproc(struct proc *, int); -thread_t procdup(); +thread_act_t cloneproc(struct proc *, int); +struct proc * forkproc(struct proc *, int); +thread_act_t procdup(); #define DOFORK 0x1 /* fork() system call */ #define DOVFORK 0x2 /* vfork() system call */ @@ -106,9 +112,162 @@ vfork(p, uap, retval) void *uap; register_t *retval; { - return (fork1(p, (long)DOVFORK, retval)); + register struct proc * newproc; + register uid_t uid; + thread_act_t cur_act = (thread_act_t)current_act(); + int count; + task_t t; + uthread_t ut; + + /* + * 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 = p->p_cred->p_ruid; + if ((nprocs >= maxproc - 1 && uid != 0) || nprocs >= maxproc) { + tablefull("proc"); + retval[1] = 0; + return (EAGAIN); + } + + /* + * Increment the count of procs running with this uid. Don't allow + * a nonprivileged user to exceed their current limit. + */ + count = chgproccnt(uid, 1); + if (uid != 0 && count > p->p_rlimit[RLIMIT_NPROC].rlim_cur) { + (void)chgproccnt(uid, -1); + return (EAGAIN); + } + + ut = (struct uthread *)get_bsdthread_info(cur_act); + if (ut->uu_flag & P_VFORK) { + printf("vfork called recursively by %s\n", p->p_comm); + return (EINVAL); + } + p->p_flag |= P_VFORK; + p->p_vforkcnt++; + + /* The newly created process comes with signal lock held */ + newproc = (struct proc *)forkproc(p,1); + + LIST_INSERT_AFTER(p, newproc, p_pglist); + newproc->p_pptr = p; + newproc->task = p->task; + LIST_INSERT_HEAD(&p->p_children, newproc, p_sibling); + LIST_INIT(&newproc->p_children); + LIST_INSERT_HEAD(&allproc, newproc, p_list); + LIST_INSERT_HEAD(PIDHASH(newproc->p_pid), newproc, p_hash); + TAILQ_INIT(& newproc->p_evlist); + newproc->p_stat = SRUN; + newproc->p_flag |= P_INVFORK; + newproc->p_vforkact = cur_act; + + 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); + + newproc->p_stats->p_start = time; + newproc->p_acflag = AFORK; + + /* + * Preserve synchronization semantics of vfork. If waiting for + * child to exec or exit, set P_PPWAIT on child, and sleep on our + * proc (in case of exit). + */ + newproc->p_flag |= P_PPWAIT; + + /* drop the signal lock on the child */ + signal_unlock(newproc); + + retval[0] = newproc->p_pid; + retval[1] = 1; /* mark child */ + + return (0); +} + +/* + * Return to parent vfork ehread() + */ +void +vfork_return(th_act, p, p2, retval) + thread_act_t th_act; + struct proc * p; + struct proc *p2; + register_t *retval; +{ + long flags; + register uid_t uid; + thread_t newth, self = current_thread(); + thread_act_t cur_act = (thread_act_t)current_act(); + int s, count; + task_t t; + uthread_t ut; + + ut = (struct uthread *)get_bsdthread_info(cur_act); + + act_thread_catt(ut->uu_userstate); + + /* Make sure only one at this time */ + p->p_vforkcnt--; + if (p->p_vforkcnt <0) + panic("vfork cnt is -ve"); + if (p->p_vforkcnt <=0) + p->p_flag &= ~P_VFORK; + 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; + + thread_set_parent(cur_act, p2->p_pid); + + if (retval) { + retval[0] = p2->p_pid; + retval[1] = 0; /* mark parent */ + } + + return; +} + +thread_act_t +procdup( + struct proc *child, + struct proc *parent) +{ + thread_act_t thread; + task_t task; + kern_return_t result; + pmap_t pmap; + extern task_t kernel_task; + + if (parent->task == kernel_task) + result = task_create_local(TASK_NULL, FALSE, FALSE, &task); + else + result = task_create_local(parent->task, TRUE, FALSE, &task); + if (result != KERN_SUCCESS) + printf("fork/procdup: task_create failed. Code: 0x%x\n", result); + child->task = task; + /* task->proc = child; */ + 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); + + return(thread); } + static int fork1(p1, flags, retval) struct proc *p1; @@ -117,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; @@ -147,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))); @@ -171,7 +330,7 @@ fork1(p1, flags, retval) (void) thread_resume(newth); /* drop the extra references we got during the creation */ - if (t = get_threadtask(newth)) { + if (t = (task_t)get_threadtask(newth)) { task_deallocate(t); } act_deallocate(newth); @@ -194,10 +353,38 @@ 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_act_t th; + + p2 = (struct proc *)forkproc(p1,lock); + + + th = procdup(p2, p1); /* child, parent */ + + LIST_INSERT_AFTER(p1, p2, p_pglist); + p2->p_pptr = p1; + LIST_INSERT_HEAD(&p1->p_children, p2, p_sibling); + LIST_INIT(&p2->p_children); + LIST_INSERT_HEAD(&allproc, p2, p_list); + LIST_INSERT_HEAD(PIDHASH(p2->p_pid), p2, p_hash); + TAILQ_INIT(&p2->p_evlist); + /* + * Make child runnable, set start time. + */ + p2->p_stat = SRUN; + + return(th); +} + +struct proc * +forkproc(p1, lock) + register struct proc *p1; + register int lock; { register struct proc *p2, *newproc; static int nextpid = 0, pidchecked = 0; @@ -241,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; @@ -251,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; @@ -288,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); @@ -338,7 +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 /* @@ -351,21 +545,8 @@ again: VREF(p2->p_tracep); } #endif + return(p2); - th = procdup(p2, p1); /* child, parent */ - LIST_INSERT_AFTER(p1, p2, p_pglist); - p2->p_pptr = p1; - LIST_INSERT_HEAD(&p1->p_children, p2, p_sibling); - LIST_INIT(&p2->p_children); - LIST_INSERT_HEAD(&allproc, p2, p_list); - LIST_INSERT_HEAD(PIDHASH(p2->p_pid), p2, p_hash); - TAILQ_INIT(&p2->p_evlist); - /* - * Make child runnable, set start time. - */ - p2->p_stat = SRUN; - - return(th); } #include @@ -386,23 +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 */ @@ -411,6 +622,21 @@ uthread_free(void *uthread) FREE(sel->obits, M_TEMP); } + if (sel->allocsize && uth->uu_wqsub){ + kfree(uth->uu_wqsub, sel->allocsize); + sel->count = sel->nfcount = 0; + sel->allocsize = 0; + uth->uu_wqsub = 0; + 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); }