自学教程：C++ FIRST_THREAD_IN_PROC函数代码示例

intkproc_kthread_add(void (*func)(void *), void *arg,            struct proc **procptr, struct thread **tdptr,            int flags, int pages, const char *procname, const char *fmt, ...) {	int error;	va_list ap;	char buf[100];	struct thread *td;	if (*procptr == 0) {		error = kproc_create(func, arg,		    	procptr, flags, pages, "%s", procname);		if (error)			return (error);		td = FIRST_THREAD_IN_PROC(*procptr);		if (tdptr)			*tdptr = td;		va_start(ap, fmt);		vsnprintf(td->td_name, sizeof(td->td_name), fmt, ap);		va_end(ap);#ifdef KTR		sched_clear_tdname(td);#endif		return (0); 	}	va_start(ap, fmt);	vsnprintf(buf, sizeof(buf), fmt, ap);	va_end(ap);	error = kthread_add(func, arg, *procptr,		    tdptr, flags, pages, "%s", buf);	return (error);}

intlinux_fork(struct thread *td, struct linux_fork_args *args){	struct fork_req fr;	int error;	struct proc *p2;	struct thread *td2;#ifdef DEBUG	if (ldebug(fork))		printf(ARGS(fork, ""));#endif	bzero(&fr, sizeof(fr));	fr.fr_flags = RFFDG | RFPROC | RFSTOPPED;	fr.fr_procp = &p2;	if ((error = fork1(td, &fr)) != 0)		return (error);	td2 = FIRST_THREAD_IN_PROC(p2);	linux_proc_init(td, td2, 0);	td->td_retval[0] = p2->p_pid;	/*	 * Make this runnable after we are finished with it.	 */	thread_lock(td2);	TD_SET_CAN_RUN(td2);	sched_add(td2, SRQ_BORING);	thread_unlock(td2);	return (0);}

static voidald_daemon(void){	int needwakeup;	struct alq *alq;	ald_thread = FIRST_THREAD_IN_PROC(ald_proc);	EVENTHANDLER_REGISTER(shutdown_pre_sync, ald_shutdown, NULL,	    SHUTDOWN_PRI_FIRST);	ALD_LOCK();	for (;;) {		while ((alq = LIST_FIRST(&ald_active)) == NULL)			msleep(&ald_active, &ald_mtx, PWAIT, "aldslp", 0);		ALQ_LOCK(alq);		ald_deactivate(alq);		ALD_UNLOCK();		needwakeup = alq_doio(alq);		ALQ_UNLOCK(alq);		if (needwakeup)			wakeup(alq);		ALD_LOCK();	}}

static intexec_linux_imgact_try(struct image_params *imgp){	const char *head = (const char *)imgp->image_header;	char *rpath;	int error = -1, len;	/*	 * The interpreter for shell scripts run from a linux binary needs	 * to be located in /compat/linux if possible in order to recursively	 * maintain linux path emulation.	 */	if (((const short *)head)[0] == SHELLMAGIC) {		/*		 * Run our normal shell image activator.  If it succeeds		 * attempt to use the alternate path for the interpreter.		 * If an alternate path is found, use our stringspace		 * to store it.		 */		if ((error = exec_shell_imgact(imgp)) == 0) {			linux_emul_convpath(FIRST_THREAD_IN_PROC(imgp->proc),			    imgp->interpreter_name, UIO_SYSSPACE,			    &rpath, 0, AT_FDCWD);			if (rpath != NULL) {				len = strlen(rpath) + 1;				if (len <= MAXSHELLCMDLEN)					memcpy(imgp->interpreter_name,					    rpath, len);				free(rpath, M_TEMP);			}		}	}	return(error);}

intlinux_fork(struct thread *td, struct linux_fork_args *args){	int error;	struct proc *p2;	struct thread *td2;#ifdef DEBUG	if (ldebug(fork))		printf(ARGS(fork, ""));#endif	if ((error = fork1(td, RFFDG | RFPROC | RFSTOPPED, 0, &p2, NULL, 0))	    != 0)		return (error);	td->td_retval[0] = p2->p_pid;	td->td_retval[1] = 0;	error = linux_proc_init(td, td->td_retval[0], 0);	if (error)		return (error);	td2 = FIRST_THREAD_IN_PROC(p2);	/*	 * Make this runnable after we are finished with it.	 */	thread_lock(td2);	TD_SET_CAN_RUN(td2);	sched_add(td2, SRQ_BORING);	thread_unlock(td2);	return (0);}

static voidtesla_perthread_process_dtor(__unused void *arg, struct proc *p){	struct thread *td;	td = FIRST_THREAD_IN_PROC(p);	if (td != NULL && td->td_tesla != NULL)		tesla_store_reset(td->td_tesla);}

intprocfs_doprocfpregs(PFS_FILL_ARGS){	int error;	struct fpreg r;	struct thread *td2;#ifdef COMPAT_FREEBSD32	struct fpreg32 r32;	int wrap32 = 0;#endif	if (uio->uio_offset != 0)		return (0);	PROC_LOCK(p);	PROC_ASSERT_HELD(p);	if (p_candebug(td, p)) {		PROC_UNLOCK(p);		return (EPERM);	}	if (!P_SHOULDSTOP(p)) {		PROC_UNLOCK(p);		return (EBUSY);	}	td2 = FIRST_THREAD_IN_PROC(p);#ifdef COMPAT_FREEBSD32	if (SV_CURPROC_FLAG(SV_ILP32)) {		if (SV_PROC_FLAG(td2->td_proc, SV_ILP32) == 0) {			PROC_UNLOCK(p);			return (EINVAL);		}		wrap32 = 1;		memset(&r32, 0, sizeof(r32));	} else#endif		memset(&r, 0, sizeof(r));	error = PROC(read, fpregs, td2, &r);	if (error == 0) {		PROC_UNLOCK(p);		error = UIOMOVE_FROMBUF(r, uio);		PROC_LOCK(p);	}	if (error == 0 && uio->uio_rw == UIO_WRITE) {		if (!P_SHOULDSTOP(p))			error = EBUSY;		else			/* XXXKSE: */			error = PROC(write, fpregs, td2, &r);	}	PROC_UNLOCK(p);	return (error);}

intprocfs_doprocdbregs(PFS_FILL_ARGS){	int error;	struct dbreg r;	struct thread *td2;#ifdef COMPAT_FREEBSD32	struct dbreg32 r32;	int wrap32 = 0;#endif	if (uio->uio_offset != 0)		return (0);	PROC_LOCK(p);	KASSERT(p->p_lock > 0, ("proc not held"));	if (p_candebug(td, p) != 0) {		PROC_UNLOCK(p);		return (EPERM);	}	td2 = FIRST_THREAD_IN_PROC(p);#ifdef COMPAT_FREEBSD32	if (SV_CURPROC_FLAG(SV_ILP32)) {		if (SV_PROC_FLAG(td2->td_proc, SV_ILP32) == 0) {			PROC_UNLOCK(p);			return (EINVAL);		}		wrap32 = 1;	}#endif	error = PROC(read, dbregs, td2, &r);	if (error == 0) {		PROC_UNLOCK(p);		error = UIOMOVE_FROMBUF(r, uio);		PROC_LOCK(p);	}	if (error == 0 && uio->uio_rw == UIO_WRITE) {		if (!P_SHOULDSTOP(p)) /* XXXKSE should be P_TRACED? */			error = EBUSY;		else			/* XXXKSE: */			error = PROC(write, dbregs, td2, &r);	}	PROC_UNLOCK(p);	return (error);}

/* * UMA should ensure that this function is never called. * Freeing a proc structure would violate type stability. */static voidproc_fini(void *mem, int size){#ifdef notnow	struct proc *p;	p = (struct proc *)mem;	EVENTHANDLER_INVOKE(process_fini, p);	pstats_free(p->p_stats);	thread_free(FIRST_THREAD_IN_PROC(p));	mtx_destroy(&p->p_mtx);	if (p->p_ksi != NULL)		ksiginfo_free(p->p_ksi);#else	panic("proc reclaimed");#endif}

intlinux_vfork(struct thread *td, struct linux_vfork_args *args){	int error;	struct proc *p2;	struct thread *td2;#ifdef DEBUG	if (ldebug(vfork))		printf(ARGS(vfork, ""));#endif	/* Exclude RFPPWAIT */	if ((error = fork1(td, RFFDG | RFPROC | RFMEM | RFSTOPPED, 0, &p2,	    NULL, 0)) != 0)		return (error);   	td->td_retval[0] = p2->p_pid;	error = linux_proc_init(td, td->td_retval[0], 0);	if (error)		return (error);	PROC_LOCK(p2);	p2->p_flag |= P_PPWAIT;	PROC_UNLOCK(p2);	td2 = FIRST_THREAD_IN_PROC(p2);	/*	 * Make this runnable after we are finished with it.	 */	thread_lock(td2);	TD_SET_CAN_RUN(td2);	sched_add(td2, SRQ_BORING);	thread_unlock(td2);	/* wait for the children to exit, ie. emulate vfork */	PROC_LOCK(p2);	while (p2->p_flag & P_PPWAIT)		cv_wait(&p2->p_pwait, &p2->p_mtx);	PROC_UNLOCK(p2);	return (0);}

DECLHIDDEN(int) rtThreadNativeCreate(PRTTHREADINT pThreadInt, PRTNATIVETHREAD pNativeThread){    int rc;    struct proc *pProc;#if __FreeBSD_version >= 800002    rc = kproc_create(rtThreadNativeMain, pThreadInt, &pProc, RFHIGHPID, 0, "%s", pThreadInt->szName);#else    rc = kthread_create(rtThreadNativeMain, pThreadInt, &pProc, RFHIGHPID, 0, "%s", pThreadInt->szName);#endif    if (!rc)    {        *pNativeThread = (RTNATIVETHREAD)FIRST_THREAD_IN_PROC(pProc);        rc = VINF_SUCCESS;    }    else        rc = RTErrConvertFromErrno(rc);    return rc;}

static voidpagezero_start(void __unused *arg){	int error;	error = kthread_create(vm_pagezero, NULL, &pagezero_proc, RFSTOPPED, 0,	    "pagezero");	if (error)		panic("pagezero_start: error %d/n", error);	/*	 * We're an idle task, don't count us in the load.	 */	PROC_LOCK(pagezero_proc);	pagezero_proc->p_flag |= P_NOLOAD;	PROC_UNLOCK(pagezero_proc);	mtx_lock_spin(&sched_lock);	setrunqueue(FIRST_THREAD_IN_PROC(pagezero_proc), SRQ_BORING);	mtx_unlock_spin(&sched_lock);}

static voidpagezero_start(void __unused *arg){	int error;	struct proc *p;	struct thread *td;	error = kproc_create(vm_pagezero, NULL, &p, RFSTOPPED, 0, "pagezero");	if (error)		panic("pagezero_start: error %d/n", error);	td = FIRST_THREAD_IN_PROC(p);	thread_lock(td);	/* We're an idle task, don't count us in the load. */	td->td_flags |= TDF_NOLOAD;	sched_class(td, PRI_IDLE);	sched_prio(td, PRI_MAX_IDLE);	sched_add(td, SRQ_BORING);	thread_unlock(td);}

/* * Reclaim a proc after use. */static voidproc_dtor(void *mem, int size, void *arg){	struct proc *p;	struct thread *td;	/* INVARIANTS checks go here */	p = (struct proc *)mem;	td = FIRST_THREAD_IN_PROC(p);	SDT_PROBE(proc, kernel, dtor, entry, p, size, arg, td, 0);	if (td != NULL) {#ifdef INVARIANTS		KASSERT((p->p_numthreads == 1),		    ("bad number of threads in exiting process"));		KASSERT(STAILQ_EMPTY(&p->p_ktr), ("proc_dtor: non-empty p_ktr"));#endif		/* Free all OSD associated to this thread. */		osd_thread_exit(td);	}	EVENTHANDLER_INVOKE(process_dtor, p);	if (p->p_ksi != NULL)		KASSERT(! KSI_ONQ(p->p_ksi), ("SIGCHLD queue"));	SDT_PROBE(proc, kernel, dtor, return, p, size, arg, 0, 0);}

static voidald_daemon(void){    int needwakeup;    struct alq *alq;    ald_thread = FIRST_THREAD_IN_PROC(ald_proc);    alq_eventhandler_tag = EVENTHANDLER_REGISTER(shutdown_pre_sync,                           ald_shutdown, NULL, SHUTDOWN_PRI_FIRST);    ALD_LOCK();    for (;;) {        while ((alq = BSD_LIST_FIRST(&ald_active)) == NULL &&                !ald_shutingdown)            mtx_sleep(&ald_active, &ald_mtx, PWAIT, "aldslp", 0);        /* Don't shutdown until all active ALQs are flushed. */        if (ald_shutingdown && alq == NULL) {            ALD_UNLOCK();            break;        }        ALQ_LOCK(alq);        ald_deactivate(alq);        ALD_UNLOCK();        needwakeup = alq_doio(alq);        ALQ_UNLOCK(alq);        if (needwakeup)            wakeup_one(alq);        ALD_LOCK();    }    kproc_exit(0);}

intprocfs_doprocstatus(PFS_FILL_ARGS){	struct session *sess;	struct thread *tdfirst;	struct tty *tp;	struct ucred *cr;	const char *wmesg;	char *pc;	char *sep;	int pid, ppid, pgid, sid;	int i;	pid = p->p_pid;	PROC_LOCK(p);	ppid = p->p_pptr ? p->p_pptr->p_pid : 0;	pgid = p->p_pgrp->pg_id;	sess = p->p_pgrp->pg_session;	SESS_LOCK(sess);	sid = sess->s_leader ? sess->s_leader->p_pid : 0;/* comm pid ppid pgid sid tty ctty,sldr start ut st wmsg				euid ruid rgid,egid,groups[1 .. ngroups]*/	pc = p->p_comm;	do {		if (*pc < 33 || *pc > 126 || *pc == '//')			sbuf_printf(sb, "//%03o", *pc);		else			sbuf_putc(sb, *pc);	} while (*++pc);	sbuf_printf(sb, " %d %d %d %d ", pid, ppid, pgid, sid);	if ((p->p_flag & P_CONTROLT) && (tp = sess->s_ttyp))		sbuf_printf(sb, "%s ", devtoname(tp->t_dev));	else		sbuf_printf(sb, "- ");	sep = "";	if (sess->s_ttyvp) {		sbuf_printf(sb, "%sctty", sep);		sep = ",";	}	if (SESS_LEADER(p)) {		sbuf_printf(sb, "%ssldr", sep);		sep = ",";	}	SESS_UNLOCK(sess);	if (*sep != ',') {		sbuf_printf(sb, "noflags");	}	tdfirst = FIRST_THREAD_IN_PROC(p);	thread_lock(tdfirst);	if (tdfirst->td_wchan != NULL) {		KASSERT(tdfirst->td_wmesg != NULL,		    ("wchan %p has no wmesg", tdfirst->td_wchan));		wmesg = tdfirst->td_wmesg;	} else		wmesg = "nochan";	thread_unlock(tdfirst);	if (p->p_flag & P_INMEM) {		struct timeval start, ut, st;		PROC_SLOCK(p);		calcru(p, &ut, &st);		PROC_SUNLOCK(p);		start = p->p_stats->p_start;		timevaladd(&start, &boottime);		sbuf_printf(sb, " %jd,%ld %jd,%ld %jd,%ld",		    (intmax_t)start.tv_sec, start.tv_usec,		    (intmax_t)ut.tv_sec, ut.tv_usec,		    (intmax_t)st.tv_sec, st.tv_usec);	} else		sbuf_printf(sb, " -1,-1 -1,-1 -1,-1");	sbuf_printf(sb, " %s", wmesg);	cr = p->p_ucred;	sbuf_printf(sb, " %lu %lu %lu",		(u_long)cr->cr_uid,		(u_long)cr->cr_ruid,		(u_long)cr->cr_rgid);	/* egid (cr->cr_svgid) is equal to cr_ngroups[0]	   see also getegid(2) in /sys/kern/kern_prot.c */	for (i = 0; i < cr->cr_ngroups; i++) {		sbuf_printf(sb, ",%lu", (u_long)cr->cr_groups[i]);	}	if (jailed(cr)) {		mtx_lock(&cr->cr_prison->pr_mtx);		sbuf_printf(sb, " %s",		    prison_name(td->td_ucred->cr_prison, cr->cr_prison));		mtx_unlock(&cr->cr_prison->pr_mtx);	} else {		sbuf_printf(sb, " -");//.........这里部分代码省略.........

		KASSERT(p != NULL, ("process not found in proc_init/n"));		p->p_emuldata = em;		PROC_UNLOCK(p);	} else		EMUL_UNLOCK(&emul_lock);	LIN_SDT_PROBE0(emul, proc_init, return);	return (0);}voidlinux_proc_exit(void *arg __unused, struct proc *p){	struct linux_emuldata *em;	int error, shared_flags, shared_xstat;	struct thread *td = FIRST_THREAD_IN_PROC(p);	int *child_clear_tid;	struct proc *q, *nq;	if (__predict_true(p->p_sysent != &elf_linux_sysvec))		return;	LIN_SDT_PROBE1(emul, proc_exit, entry, p);	release_futexes(p);	/* find the emuldata */	em = em_find(p, EMUL_DOLOCK);	KASSERT(em != NULL, ("proc_exit: emuldata not found./n"));

//.........这里部分代码省略.........			error = ESRCH;			goto fail;		}		if ((error = p_candebug(td, p)) != 0)			goto fail;		/* System processes can't be debugged. */		if ((p->p_flag & P_SYSTEM) != 0) {			error = EINVAL;			goto fail;		}		/* not being traced... */		if ((p->p_flag & P_TRACED) == 0) {			error = EPERM;			goto fail;		}		/* not being traced by YOU */		if (p->p_pptr != td->td_proc) {			error = EBUSY;			goto fail;		}		/* not currently stopped */		if (!P_SHOULDSTOP(p) || (p->p_flag & P_WAITED) == 0) {			error = EBUSY;			goto fail;		}		if (req == PTRACE_GETFPXREGS) {			_PHOLD(p);	/* may block */			td2 = FIRST_THREAD_IN_PROC(p);			error = linux_proc_read_fpxregs(td2, &r.fpxreg);			_PRELE(p);			PROC_UNLOCK(p);			if (error == 0)				error = copyout(&r.fpxreg, (void *)uap->data,				    sizeof(r.fpxreg));		} else {			/* clear dangerous bits exactly as Linux does*/			r.fpxreg.mxcsr &= 0xffbf;			_PHOLD(p);	/* may block */			td2 = FIRST_THREAD_IN_PROC(p);			error = linux_proc_write_fpxregs(td2, &r.fpxreg);			_PRELE(p);			PROC_UNLOCK(p);		}		break;	fail:		PROC_UNLOCK(p);#else		error = EIO;#endif		break;	}	case PTRACE_PEEKUSR:	case PTRACE_POKEUSR: {		error = EIO;		/* check addr for alignment */		if (uap->addr < 0 || uap->addr & (sizeof(l_int) - 1))			break;		/*

//.........这里部分代码省略.........	 * processes; don't let root exceed the limit.	 */	nprocs_new = atomic_fetchadd_int(&nprocs, 1) + 1;	if ((nprocs_new >= maxproc - 10 && priv_check_cred(td->td_ucred,	    PRIV_MAXPROC, 0) != 0) || nprocs_new >= maxproc) {		error = EAGAIN;		sx_xlock(&allproc_lock);		if (ppsratecheck(&lastfail, &curfail, 1)) {			printf("maxproc limit exceeded by uid %u (pid %d); "			    "see tuning(7) and login.conf(5)/n",			    td->td_ucred->cr_ruid, p1->p_pid);		}		sx_xunlock(&allproc_lock);		goto fail2;	}	/*	 * If required, create a process descriptor in the parent first; we	 * will abandon it if something goes wrong. We don't finit() until	 * later.	 */	if (flags & RFPROCDESC) {		error = procdesc_falloc(td, &fp_procdesc, fr->fr_pd_fd,		    fr->fr_pd_flags, fr->fr_pd_fcaps);		if (error != 0)			goto fail2;	}	mem_charged = 0;	if (pages == 0)		pages = kstack_pages;	/* Allocate new proc. */	newproc = uma_zalloc(proc_zone, M_WAITOK);	td2 = FIRST_THREAD_IN_PROC(newproc);	if (td2 == NULL) {		td2 = thread_alloc(pages);		if (td2 == NULL) {			error = ENOMEM;			goto fail2;		}		proc_linkup(newproc, td2);	} else {		if (td2->td_kstack == 0 || td2->td_kstack_pages != pages) {			if (td2->td_kstack != 0)				vm_thread_dispose(td2);			if (!thread_alloc_stack(td2, pages)) {				error = ENOMEM;				goto fail2;			}		}	}	if ((flags & RFMEM) == 0) {		vm2 = vmspace_fork(p1->p_vmspace, &mem_charged);		if (vm2 == NULL) {			error = ENOMEM;			goto fail2;		}		if (!swap_reserve(mem_charged)) {			/*			 * The swap reservation failed. The accounting			 * from the entries of the copied vm2 will be			 * subtracted in vmspace_free(), so force the			 * reservation there.			 */			swap_reserve_force(mem_charged);

static intlinux_clone_proc(struct thread *td, struct linux_clone_args *args){	struct fork_req fr;	int error, ff = RFPROC | RFSTOPPED;	struct proc *p2;	struct thread *td2;	int exit_signal;	struct linux_emuldata *em;#ifdef DEBUG	if (ldebug(clone)) {		printf(ARGS(clone, "flags %x, stack %p, parent tid: %p, "		    "child tid: %p"), (unsigned)args->flags,		    args->stack, args->parent_tidptr, args->child_tidptr);	}#endif	exit_signal = args->flags & 0x000000ff;	if (LINUX_SIG_VALID(exit_signal)) {		exit_signal = linux_to_bsd_signal(exit_signal);	} else if (exit_signal != 0)		return (EINVAL);	if (args->flags & LINUX_CLONE_VM)		ff |= RFMEM;	if (args->flags & LINUX_CLONE_SIGHAND)		ff |= RFSIGSHARE;	/*	 * XXX: In Linux, sharing of fs info (chroot/cwd/umask)	 * and open files is independent.  In FreeBSD, its in one	 * structure but in reality it does not cause any problems	 * because both of these flags are usually set together.	 */	if (!(args->flags & (LINUX_CLONE_FILES | LINUX_CLONE_FS)))		ff |= RFFDG;	if (args->flags & LINUX_CLONE_PARENT_SETTID)		if (args->parent_tidptr == NULL)			return (EINVAL);	if (args->flags & LINUX_CLONE_VFORK)		ff |= RFPPWAIT;	bzero(&fr, sizeof(fr));	fr.fr_flags = ff;	fr.fr_procp = &p2;	error = fork1(td, &fr);	if (error)		return (error);	td2 = FIRST_THREAD_IN_PROC(p2);	/* create the emuldata */	linux_proc_init(td, td2, args->flags);	em = em_find(td2);	KASSERT(em != NULL, ("clone_proc: emuldata not found./n"));	if (args->flags & LINUX_CLONE_CHILD_SETTID)		em->child_set_tid = args->child_tidptr;	else	   	em->child_set_tid = NULL;	if (args->flags & LINUX_CLONE_CHILD_CLEARTID)		em->child_clear_tid = args->child_tidptr;	else	   	em->child_clear_tid = NULL;	if (args->flags & LINUX_CLONE_PARENT_SETTID) {		error = copyout(&p2->p_pid, args->parent_tidptr,		    sizeof(p2->p_pid));		if (error)			printf(LMSG("copyout failed!"));	}	PROC_LOCK(p2);	p2->p_sigparent = exit_signal;	PROC_UNLOCK(p2);	/*	 * In a case of stack = NULL, we are supposed to COW calling process	 * stack. This is what normal fork() does, so we just keep tf_rsp arg	 * intact.	 */	linux_set_upcall_kse(td2, PTROUT(args->stack));	if (args->flags & LINUX_CLONE_SETTLS)		linux_set_cloned_tls(td2, args->tls);	/*	 * If CLONE_PARENT is set, then the parent of the new process will be 	 * the same as that of the calling process.	 */	if (args->flags & LINUX_CLONE_PARENT) {		sx_xlock(&proctree_lock);		PROC_LOCK(p2);		proc_reparent(p2, td->td_proc->p_pptr);		PROC_UNLOCK(p2);		sx_xunlock(&proctree_lock);	}//.........这里部分代码省略.........

//.........这里部分代码省略.........	if (args->flags & LINUX_CLONE_PARENT_SETTID)		if (args->parent_tidptr == NULL)			return (EINVAL);	error = fork1(td, ff, 0, &p2, NULL, 0);	if (error)		return (error);	if (args->flags & (LINUX_CLONE_PARENT | LINUX_CLONE_THREAD)) {	   	sx_xlock(&proctree_lock);		PROC_LOCK(p2);		proc_reparent(p2, td->td_proc->p_pptr);		PROC_UNLOCK(p2);		sx_xunlock(&proctree_lock);	}	/* create the emuldata */	error = linux_proc_init(td, p2->p_pid, args->flags);	/* reference it - no need to check this */	em = em_find(p2, EMUL_DOLOCK);	KASSERT(em != NULL, ("clone: emuldata not found."));	/* and adjust it */	if (args->flags & LINUX_CLONE_THREAD) {#ifdef notyet	   	PROC_LOCK(p2);	   	p2->p_pgrp = td->td_proc->p_pgrp;	   	PROC_UNLOCK(p2);#endif		exit_signal = 0;	}	if (args->flags & LINUX_CLONE_CHILD_SETTID)		em->child_set_tid = args->child_tidptr;	else	   	em->child_set_tid = NULL;	if (args->flags & LINUX_CLONE_CHILD_CLEARTID)		em->child_clear_tid = args->child_tidptr;	else	   	em->child_clear_tid = NULL;	EMUL_UNLOCK(&emul_lock);	if (args->flags & LINUX_CLONE_PARENT_SETTID) {		error = copyout(&p2->p_pid, args->parent_tidptr,		    sizeof(p2->p_pid));		if (error)			printf(LMSG("copyout failed!"));	}	PROC_LOCK(p2);	p2->p_sigparent = exit_signal;	PROC_UNLOCK(p2);	td2 = FIRST_THREAD_IN_PROC(p2);	/*	 * In a case of stack = NULL, we are supposed to COW calling process	 * stack. This is what normal fork() does, so we just keep tf_rsp arg	 * intact.	 */	if (args->stack)		linux_set_upcall_kse(td2, PTROUT(args->stack));	if (args->flags & LINUX_CLONE_SETTLS)		linux_set_cloned_tls(td2, args->tls);#ifdef DEBUG	if (ldebug(clone))		printf(LMSG("clone: successful rfork to %d, "		    "stack %p sig = %d"), (int)p2->p_pid, args->stack,		    exit_signal);#endif	if (args->flags & LINUX_CLONE_VFORK) {	   	PROC_LOCK(p2);	   	p2->p_flag |= P_PPWAIT;	   	PROC_UNLOCK(p2);	}	/*	 * Make this runnable after we are finished with it.	 */	thread_lock(td2);	TD_SET_CAN_RUN(td2);	sched_add(td2, SRQ_BORING);	thread_unlock(td2);	td->td_retval[0] = p2->p_pid;	td->td_retval[1] = 0;	if (args->flags & LINUX_CLONE_VFORK) {		/* wait for the children to exit, ie. emulate vfork */		PROC_LOCK(p2);		while (p2->p_flag & P_PPWAIT)			cv_wait(&p2->p_pwait, &p2->p_mtx);		PROC_UNLOCK(p2);	}	return (0);}