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

static voiddr_start_user_threads(void){	kthread_id_t tp;	mutex_enter(&pidlock);	/* walk all threads and release them */	for (tp = curthread->t_next; tp != curthread; tp = tp->t_next) {		proc_t *p = ttoproc(tp);		/* skip kernel threads */		if (ttoproc(tp)->p_as == &kas)			continue;		mutex_enter(&p->p_lock);		tp->t_proc_flag &= ~TP_CHKPT;		mutex_exit(&p->p_lock);		thread_lock(tp);		if (CPR_ISTOPPED(tp)) {			/* back on the runq */			tp->t_schedflag |= TS_RESUME;			setrun_locked(tp);		}		thread_unlock(tp);	}	mutex_exit(&pidlock);}

/* * Close a mounted file descriptor. * Remove any locks and apply the VOP_CLOSE operation to the vnode for * the file descriptor. */static intnm_close(vnode_t *vp, int flag, int count, offset_t offset, cred_t *crp,	caller_context_t *ct){	struct namenode *nodep = VTONM(vp);	int error = 0;	(void) cleanlocks(vp, ttoproc(curthread)->p_pid, 0);	cleanshares(vp, ttoproc(curthread)->p_pid);	error = VOP_CLOSE(nodep->nm_filevp, flag, count, offset, crp, ct);	if (count == 1) {		(void) VOP_FSYNC(nodep->nm_filevp, FSYNC, crp, ct);		/*		 * Before VN_RELE() we need to remove the vnode from		 * the hash table.  We should only do so in the  NMNMNT case.		 * In other cases, nodep->nm_filep keeps a reference		 * to nm_filevp and the entry in the hash table doesn't		 * hurt.		 */		if ((nodep->nm_flag & NMNMNT) != 0) {			mutex_enter(&ntable_lock);			nameremove(nodep);			mutex_exit(&ntable_lock);		}		VN_RELE(nodep->nm_filevp);	}	return (error);}

/*ARGSUSED*/static intsocket_vop_close(struct vnode *vp, int flag, int count, offset_t offset,    struct cred *cr, caller_context_t *ct){	struct sonode *so;	int error = 0;	so = VTOSO(vp);	ASSERT(vp->v_type == VSOCK);	cleanlocks(vp, ttoproc(curthread)->p_pid, 0);	cleanshares(vp, ttoproc(curthread)->p_pid);	if (vp->v_stream)		strclean(vp);	if (count > 1) {		dprint(2, ("socket_vop_close: count %d/n", count));		return (0);	}	mutex_enter(&so->so_lock);	if (--so->so_count == 0) {		/*		 * Initiate connection shutdown.		 */		mutex_exit(&so->so_lock);		error = socket_close_internal(so, flag, cr);	} else {		mutex_exit(&so->so_lock);	}	return (error);}

/* ARGSUSED1 */static intxmem_close(struct vnode *vp, int flag, int count, offset_t offset,	struct cred *cred){	cleanlocks(vp, ttoproc(curthread)->p_pid, 0);	cleanshares(vp, ttoproc(curthread)->p_pid);	return (0);}

/*ARGSUSED1*/static intdevfs_close(struct vnode *vp, int flag, int count,    offset_t offset, struct cred *cred){	struct dv_node	*dv = VTODV(vp);	dcmn_err2(("devfs_close %s/n", dv->dv_name));	ASSERT(vp->v_type == VDIR);	cleanlocks(vp, ttoproc(curthread)->p_pid, 0);	cleanshares(vp, ttoproc(curthread)->p_pid);	return (0);}

/* * Clean up scheduler activations state associated with an exiting * (or execing) lwp.  t is always the current thread. */voidschedctl_lwp_cleanup(kthread_t *t){	sc_shared_t	*ssp = t->t_schedctl;	proc_t		*p = ttoproc(t);	sc_page_ctl_t	*pagep;	index_t		index;	ASSERT(MUTEX_NOT_HELD(&p->p_lock));	thread_lock(t);		/* protect against ts_tick and ts_update */	t->t_schedctl = NULL;	t->t_sc_uaddr = 0;	thread_unlock(t);	/*	 * Remove the context op to avoid the final call to	 * schedctl_save when switching away from this lwp.	 */	(void) removectx(t, ssp, schedctl_save, schedctl_restore,	    schedctl_fork, NULL, NULL, NULL);	/*	 * Do not unmap the shared page until the process exits.	 * User-level library code relies on this for adaptive mutex locking.	 */	mutex_enter(&p->p_sc_lock);	ssp->sc_state = SC_FREE;	pagep = schedctl_page_lookup(ssp);	index = (index_t)(ssp - pagep->spc_base);	BT_CLEAR(pagep->spc_map, index);	pagep->spc_space += sizeof (sc_shared_t);	mutex_exit(&p->p_sc_lock);}

/* * CPR user thread related support routines */voidcpr_signal_user(int sig){/* * The signal SIGTHAW and SIGFREEZE cannot be sent to every thread yet * since openwin is catching every signal and default action is to exit. * We also need to implement the true SIGFREEZE and SIGTHAW to stop threads. */	struct proc *p;	mutex_enter(&pidlock);	for (p = practive; p; p = p->p_next) {		/* only user threads */		if (p->p_exec == NULL || p->p_stat == SZOMB ||			p == proc_init || p == ttoproc(curthread))			continue;		mutex_enter(&p->p_lock);		sigtoproc(p, NULL, sig);		mutex_exit(&p->p_lock);	}	mutex_exit(&pidlock);	DELAY(MICROSEC);}

/* * Call to check if can have access after a cache miss has occurred. * Only read access is allowed, do not call this routine if want * to write. * Returns 1 if yes, 0 if no. */intcachefs_cd_access_miss(fscache_t *fscp){	cachefscache_t *cachep;	pid_t pid;#ifdef CFS_CD_DEBUG	ASSERT(curthread->t_flag & T_CD_HELD);#endif	/* should not get called if connected */	ASSERT(fscp->fs_cdconnected != CFS_CD_CONNECTED);	/* if no back file system, then no */	if (fscp->fs_backvfsp == NULL)		return (0);	/* if daemon is not running, then yes */	if (fscp->fs_cddaemonid == 0) {		return (1);	}	pid = ttoproc(curthread)->p_pid;	cachep = fscp->fs_cache;	/* if daemon is running, only daemon is allowed to have access */	if ((fscp->fs_cddaemonid != pid) &&	    (cachep->c_rootdaemonid != pid)) {		return (0);	}	return (1);}

static kthread_t *getlwpptr(id_t id){	proc_t		*p;	kthread_t	*t;	ASSERT(MUTEX_HELD(&(ttoproc(curthread)->p_lock)));	if (id == P_MYID)		t = curthread;	else {		p = ttoproc(curthread);		t = idtot(p, id);	}	return (t);}

/* * Exit the calling lwp */voidsyslwp_exit(){	proc_t *p = ttoproc(curthread);	mutex_enter(&p->p_lock);	lwp_exit();	/* NOTREACHED */}

/* * Like cv_wait_sig_swap but allows the caller to indicate (with a * non-NULL sigret) that they will take care of signalling the cv * after wakeup, if necessary.  This is a vile hack that should only * be used when no other option is available; almost all callers * should just use cv_wait_sig_swap (which takes care of the cv_signal * stuff automatically) instead. */intcv_wait_sig_swap_core(kcondvar_t *cvp, kmutex_t *mp, int *sigret){	kthread_t *t = curthread;	proc_t *p = ttoproc(t);	klwp_t *lwp = ttolwp(t);	int rval = 1;	int signalled = 0;	if (panicstr)		return (rval);	/*	 * The check for t_intr is to catch an interrupt thread	 * that has not yet unpinned the thread underneath.	 */	if (lwp == NULL || t->t_intr) {		cv_wait(cvp, mp);		return (rval);	}	lwp->lwp_asleep = 1;	lwp->lwp_sysabort = 0;	thread_lock(t);	t->t_kpri_req = 0;	/* don't need kernel priority */	cv_block_sig(t, (condvar_impl_t *)cvp);	/* I can be swapped now */	curthread->t_schedflag &= ~TS_DONT_SWAP;	thread_unlock_nopreempt(t);	mutex_exit(mp);	if (ISSIG(t, JUSTLOOKING) || MUSTRETURN(p, t))		setrun(t);	/* ASSERT(no locks are held) */	swtch();	signalled = (t->t_schedflag & TS_SIGNALLED);	t->t_flag &= ~T_WAKEABLE;	/* TS_DONT_SWAP set by disp() */	ASSERT(curthread->t_schedflag & TS_DONT_SWAP);	mutex_enter(mp);	if (ISSIG_PENDING(t, lwp, p)) {		mutex_exit(mp);		if (issig(FORREAL))			rval = 0;		mutex_enter(mp);	}	if (lwp->lwp_sysabort || MUSTRETURN(p, t))		rval = 0;	lwp->lwp_asleep = 0;	lwp->lwp_sysabort = 0;	if (rval == 0) {		if (sigret != NULL)			*sigret = signalled;	/* just tell the caller */		else if (signalled)			cv_signal(cvp);	/* avoid consuming the cv_signal() */	}	return (rval);}

static intpset_bind_thread(kthread_t *tp, psetid_t pset, psetid_t *oldpset, void *projbuf,    void *zonebuf){	int error = 0;	ASSERT(pool_lock_held());	ASSERT(MUTEX_HELD(&cpu_lock));	ASSERT(MUTEX_HELD(&ttoproc(tp)->p_lock));	*oldpset = tp->t_bind_pset;	switch (pset) {	case PS_SOFT:		TB_PSET_SOFT_SET(tp);		break;	case PS_HARD:		TB_PSET_HARD_SET(tp);		break;	case PS_QUERY:		break;	case PS_QUERY_TYPE:		*oldpset = TB_PSET_IS_SOFT(tp) ? PS_SOFT : PS_HARD;		break;	default:		/*		 * Must have the same UID as the target process or		 * have PRIV_PROC_OWNER privilege.		 */		if (!hasprocperm(tp->t_cred, CRED()))			return (EPERM);		/*		 * Unbinding of an unbound thread should always succeed.		 */		if (*oldpset == PS_NONE && pset == PS_NONE)			return (0);		/*		 * Only privileged processes can move threads from psets with		 * PSET_NOESCAPE attribute.		 */		if ((tp->t_cpupart->cp_attr & PSET_NOESCAPE) &&		    secpolicy_pset(CRED()) != 0)			return (EPERM);		if ((error = cpupart_bind_thread(tp, pset, 0,		    projbuf, zonebuf)) == 0)			tp->t_bind_pset = pset;		break;	}	return (error);}

static intxmem_freesp(struct vnode *vp, struct flock64 *lp, int flag){	register int i;	register struct xmemnode *xp = VTOXN(vp);	int error;	ASSERT(vp->v_type == VREG);	ASSERT(lp->l_start >= 0);	if (lp->l_len != 0)		return (EINVAL);	rw_enter(&xp->xn_rwlock, RW_WRITER);	if (xp->xn_size == lp->l_start) {		rw_exit(&xp->xn_rwlock);		return (0);	}	/*	 * Check for any mandatory locks on the range	 */	if (MANDLOCK(vp, xp->xn_mode)) {		long save_start;		save_start = lp->l_start;		if (xp->xn_size < lp->l_start) {			/*			 * "Truncate up" case: need to make sure there			 * is no lock beyond current end-of-file. To			 * do so, we need to set l_start to the size			 * of the file temporarily.			 */			lp->l_start = xp->xn_size;		}		lp->l_type = F_WRLCK;		lp->l_sysid = 0;		lp->l_pid = ttoproc(curthread)->p_pid;		i = (flag & (FNDELAY|FNONBLOCK)) ? 0 : SLPFLCK;		if ((i = reclock(vp, lp, i, 0, lp->l_start, NULL)) != 0 ||		    lp->l_type != F_UNLCK) {			rw_exit(&xp->xn_rwlock);			return (i ? i : EAGAIN);		}		lp->l_start = save_start;	}	rw_enter(&xp->xn_contents, RW_WRITER);	error = xmemnode_trunc((struct xmount *)VFSTOXM(vp->v_vfsp),						xp, lp->l_start);	rw_exit(&xp->xn_contents);	rw_exit(&xp->xn_rwlock);	return (error);}

static intlockIdcmp2(struct AFS_FLOCK *flock1, struct vcache *vp,	   struct SimpleLocks *alp, int onlymine, int clid){    struct SimpleLocks *slp;#if	defined(AFS_SUN5_ENV)    proc_t *procp = ttoproc(curthread);#else#if !defined(AFS_AIX41_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_SGI65_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_XBSD_ENV)#ifdef AFS_SGI64_ENV    afs_proc_t *procp = curprocp;#elif defined(UKERNEL)    afs_proc_t *procp = get_user_struct()->u_procp;#else    afs_proc_t *procp = u.u_procp;#endif /* AFS_SGI64_ENV */#endif#endif    if (alp) {#if	defined(AFS_AIX_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_SGI_ENV)	if (flock1->l_sysid != alp->sysid) {	    return 1;	}#endif	if ((flock1->l_pid == alp->pid) ||#if defined(AFS_AIX41_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_HPUX_ENV)	    (!onlymine && (flock1->l_pid == getppid()))#else#if defined(AFS_SGI65_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)	    /* XXX check this. used to be *only* irix for some reason. */	    (!onlymine && (flock1->l_pid == clid))#else	    (!onlymine && (flock1->l_pid == procp->p_ppid))#endif#endif	    ) {	    return 0;	}	return 1;    }    for (slp = vp->slocks; slp; slp = slp->next) {#if defined(AFS_HAVE_FLOCK_SYSID)	if (flock1->l_sysid != slp->sysid) {	    continue;	}#endif	if (flock1->l_pid == slp->pid) {	    return 0;	}    }    return (1);			/* failure */}

voidtnf_thread_create(kthread_t *t){	/* If the allocation fails, this thread doesn't trace */	t->t_tnf_tpdp = kmem_zalloc(sizeof (tnf_ops_t), KM_NOSLEEP);	TNF_PROBE_3(thread_create, "thread", /* CSTYLED */,		tnf_kthread_id,	tid,		t,		tnf_pid,	pid,		ttoproc(t)->p_pid,		tnf_symbol,	start_pc,	t->t_startpc);}

/* * projid_t tasksys_getprojid(void); * * Overview *   Return the current project ID for this process. * * Return value *   The ID for the project to which the current process belongs. */static longtasksys_getprojid(){	long ret;	proc_t *p = ttoproc(curthread);	mutex_enter(&pidlock);	ret = p->p_task->tk_proj->kpj_id;	mutex_exit(&pidlock);	return (ret);}

/* * Return the (held) credentials for the current running process. */cred_t *crgetcred(void){	cred_t *cr;	proc_t *p;	p = ttoproc(curthread);	mutex_enter(&p->p_crlock);	crhold(cr = p->p_cred);	mutex_exit(&p->p_crlock);	return (cr);}

/* * If the sc_sigblock field is set for the specified thread, set * its signal mask to block all maskable signals, then clear the * sc_sigblock field.  This finishes what user-level code requested * to be done when it set tdp->sc_shared->sc_sigblock non-zero. * Called by signal-related code that holds the process's p_lock. */voidschedctl_finish_sigblock(kthread_t *t){	sc_shared_t *tdp = t->t_schedctl;	ASSERT(MUTEX_HELD(&ttoproc(t)->p_lock));	if (tdp && tdp->sc_sigblock) {		t->t_hold.__sigbits[0] = FILLSET0 & ~CANTMASK0;		t->t_hold.__sigbits[1] = FILLSET1 & ~CANTMASK1;		tdp->sc_sigblock = 0;	}}

/* * On fork, remove inherited mappings from the child's address space. * The child's threads must call schedctl() to get new shared mappings. */static voidschedctl_fork(kthread_t *pt, kthread_t *ct){	proc_t *pp = ttoproc(pt);	proc_t *cp = ttoproc(ct);	sc_page_ctl_t *pagep;	ASSERT(ct->t_schedctl == NULL);	/*	 * Do this only once, whether we are doing fork1() or forkall().	 * Don't do it at all if the child process is a child of vfork()	 * because a child of vfork() borrows the parent's address space.	 */	if (pt != curthread || (cp->p_flag & SVFORK))		return;	mutex_enter(&pp->p_sc_lock);	for (pagep = pp->p_pagep; pagep != NULL; pagep = pagep->spc_next)		(void) as_unmap(cp->p_as, pagep->spc_uaddr, PAGESIZE);	mutex_exit(&pp->p_sc_lock);}

voidlockIdSet(struct AFS_FLOCK *flock, struct SimpleLocks *slp, int clid){    proc_t *procp = ttoproc(curthread);    if (slp) {	slp->sysid = 0;	slp->pid = procp->p_pid;    } else {	flock->l_sysid = 0;	flock->l_pid = procp->p_pid;    }}

/* * start all threads that were stopped for checkpoint. */voidcpr_start_user_threads(){	kthread_id_t tp;	proc_t *p;	mutex_enter(&pidlock);	tp = curthread->t_next;	do {		p = ttoproc(tp);		/*		 * kernel threads are callback'ed rather than setrun.		 */		if (ttoproc(tp)->p_as == &kas) continue;		/*		 * t_proc_flag should have been cleared. Just to make sure here		 */		mutex_enter(&p->p_lock);		tp->t_proc_flag &= ~TP_CHKPT;		mutex_exit(&p->p_lock);		thread_lock(tp);		if (CPR_ISTOPPED(tp)) {			/*			 * put it back on the runq			 */			tp->t_schedflag |= TS_RESUME;			setrun_locked(tp);		}		thread_unlock(tp);		/*		 * DEBUG - Keep track of current and next thread pointer.		 */	} while ((tp = tp->t_next) != curthread);	mutex_exit(&pidlock);}

/* * Called from post_syscall() when a deferred singlestep is to be taken. */voiddeferred_singlestep_trap(caddr_t pc){	proc_t *p = ttoproc(curthread);	klwp_t *lwp = ttolwp(curthread);	pcb_t *pcb = &lwp->lwp_pcb;	uint_t fault = 0;	k_siginfo_t siginfo;	bzero(&siginfo, sizeof (siginfo));	/*	 * If both NORMAL_STEP and WATCH_STEP are in	 * effect, give precedence to NORMAL_STEP.	 * If neither is set, user must have set the	 * PS_T bit in %efl; treat this as NORMAL_STEP.	 */	if ((pcb->pcb_flags & NORMAL_STEP) ||	    !(pcb->pcb_flags & WATCH_STEP)) {		siginfo.si_signo = SIGTRAP;		siginfo.si_code = TRAP_TRACE;		siginfo.si_addr  = pc;		fault = FLTTRACE;		if (pcb->pcb_flags & WATCH_STEP)			(void) undo_watch_step(NULL);	} else {		fault = undo_watch_step(&siginfo);	}	pcb->pcb_flags &= ~(DEBUG_PENDING|NORMAL_STEP|WATCH_STEP);	if (fault) {		/*		 * Remember the fault and fault adddress		 * for real-time (SIGPROF) profiling.		 */		lwp->lwp_lastfault = fault;		lwp->lwp_lastfaddr = siginfo.si_addr;		/*		 * If a debugger has declared this fault to be an		 * event of interest, stop the lwp.  Otherwise just		 * deliver the associated signal.		 */		if (prismember(&p->p_fltmask, fault) &&		    stop_on_fault(fault, &siginfo) == 0)			siginfo.si_signo = 0;	}	if (siginfo.si_signo)		trapsig(&siginfo, 1);}

static intsigqkill(pid_t pid, sigsend_t *sigsend){	proc_t *p;	int error;	if ((uint_t)sigsend->sig >= NSIG)		return (EINVAL);	if (pid == -1) {		procset_t set;		setprocset(&set, POP_AND, P_ALL, P_MYID, P_ALL, P_MYID);		error = sigsendset(&set, sigsend);	} else if (pid > 0) {		mutex_enter(&pidlock);		if ((p = prfind(pid)) == NULL || p->p_stat == SIDL)			error = ESRCH;		else {			error = sigsendproc(p, sigsend);			if (error == 0 && sigsend->perm == 0)				error = EPERM;		}		mutex_exit(&pidlock);	} else {		int nfound = 0;		pid_t pgid;		if (pid == 0)			pgid = ttoproc(curthread)->p_pgrp;		else			pgid = -pid;		error = 0;		mutex_enter(&pidlock);		for (p = pgfind(pgid); p && !error; p = p->p_pglink) {			if (p->p_stat != SIDL) {				nfound++;				error = sigsendproc(p, sigsend);			}		}		mutex_exit(&pidlock);		if (nfound == 0)			error = ESRCH;		else if (error == 0 && sigsend->perm == 0)			error = EPERM;	}	return (error);}

/* * Check for common cases of procsets which specify only the * current process.  cur_inset_only() returns B_TRUE when * the current process is the only one in the set.  B_FALSE * is returned to indicate that this may not be the case. */boolean_tcur_inset_only(procset_t *psp){	if (((psp->p_lidtype == P_PID &&	    (psp->p_lid == P_MYID ||	    psp->p_lid == ttoproc(curthread)->p_pid)) ||	    ((psp->p_lidtype == P_LWPID) &&	    (psp->p_lid == P_MYID ||	    psp->p_lid == curthread->t_tid))) &&	    psp->p_op == POP_AND && psp->p_ridtype == P_ALL)		return (B_TRUE);	if (((psp->p_ridtype == P_PID &&	    (psp->p_rid == P_MYID ||	    psp->p_rid == ttoproc(curthread)->p_pid)) ||	    ((psp->p_ridtype == P_LWPID) &&	    (psp->p_rid == P_MYID ||	    psp->p_rid == curthread->t_tid))) &&	    psp->p_op == POP_AND && psp->p_lidtype == P_ALL)		return (B_TRUE);	return (B_FALSE);}

intcv_wait_sig(kcondvar_t *cvp, kmutex_t *mp){	kthread_t *t = curthread;	proc_t *p = ttoproc(t);	klwp_t *lwp = ttolwp(t);	int rval = 1;	int signalled = 0;	if (panicstr)		return (rval);	/*	 * The check for t_intr is to catch an interrupt thread	 * that has not yet unpinned the thread underneath.	 */	if (lwp == NULL || t->t_intr) {		cv_wait(cvp, mp);		return (rval);	}	ASSERT(curthread->t_schedflag & TS_DONT_SWAP);	lwp->lwp_asleep = 1;	lwp->lwp_sysabort = 0;	thread_lock(t);	cv_block_sig(t, (condvar_impl_t *)cvp);	thread_unlock_nopreempt(t);	mutex_exit(mp);	if (ISSIG(t, JUSTLOOKING) || MUSTRETURN(p, t))		setrun(t);	/* ASSERT(no locks are held) */	swtch();	signalled = (t->t_schedflag & TS_SIGNALLED);	t->t_flag &= ~T_WAKEABLE;	mutex_enter(mp);	if (ISSIG_PENDING(t, lwp, p)) {		mutex_exit(mp);		if (issig(FORREAL))			rval = 0;		mutex_enter(mp);	}	if (lwp->lwp_sysabort || MUSTRETURN(p, t))		rval = 0;	lwp->lwp_asleep = 0;	lwp->lwp_sysabort = 0;	if (rval == 0 && signalled)	/* avoid consuming the cv_signal() */		cv_signal(cvp);	return (rval);}

/* * Stop kernel threads by using the callback mechanism.  If any thread * cannot be stopped, return failure. */intcpr_stop_kernel_threads(void){	caddr_t	name;	kthread_id_t tp;	proc_t *p;	callb_lock_table();	/* Note: we unlock the table in resume. */	DEBUG1(errp("stopping kernel daemons..."));	if ((name = callb_execute_class(CB_CL_CPR_DAEMON,	    CB_CODE_CPR_CHKPT)) != (caddr_t)NULL) {		cpr_err(CE_WARN,		    "Could not stop /"%s/" kernel thread.  "		    "Please try again later.", name);		return (EBUSY);	}	/*	 * We think we stopped all the kernel threads.  Just in case	 * someone is not playing by the rules, take a spin through	 * the threadlist and see if we can account for everybody.	 */	mutex_enter(&pidlock);	tp = curthread->t_next;	do {		p = ttoproc(tp);		if (p->p_as != &kas)			continue;		if (tp->t_flag & T_INTR_THREAD)			continue;		if (! callb_is_stopped(tp, &name)) {			mutex_exit(&pidlock);			cpr_err(CE_WARN,			    "/"%s/" kernel thread not stopped.", name);			return (EBUSY);		}	} while ((tp = tp->t_next) != curthread);	mutex_exit(&pidlock);	DEBUG1(errp("done/n"));	return (0);}

/* * This function binds a thread to a partition.  Must be called with the * p_lock of the containing process held (to keep the thread from going * away), and thus also with cpu_lock held (since cpu_lock must be * acquired before p_lock).  If ignore is non-zero, then CPU bindings * should be ignored (this is used when destroying a partition). */intcpupart_bind_thread(kthread_id_t tp, psetid_t psid, int ignore, void *projbuf,    void *zonebuf){	cpupart_t	*newpp;	ASSERT(pool_lock_held());	ASSERT(MUTEX_HELD(&cpu_lock));	ASSERT(MUTEX_HELD(&pidlock));	ASSERT(MUTEX_HELD(&ttoproc(tp)->p_lock));	if (psid == PS_NONE)		newpp = &cp_default;	else {		newpp = cpupart_find(psid);		if (newpp == NULL) {			return (EINVAL);		}	}	return (cpupart_move_thread(tp, newpp, ignore, projbuf, zonebuf));}

tnf_record_ptnf_kernel_schedule(tnf_ops_t *ops, tnf_schedule_t *sched){	tnf_tag_data_t *metatag_data;	tnf_record_p metatag_index;	tnf_schedule_prototype_t *buffer;	kthread_t *t;	t = curthread;	/* Cannot be called when writing into tag space */	ASSERT(ops->mode == TNF_ALLOC_REUSABLE);	ALLOC(ops, sizeof (*buffer), buffer, sched->record_p,	    TNF_ALLOC_REUSABLE); /* XXX see comment above */	metatag_data = TAG_DATA(tnf_kernel_schedule);	metatag_index = metatag_data->tag_index ?		metatag_data->tag_index :		metatag_data->tag_desc(ops, metatag_data);	ASSIGN(buffer,	tag, 		metatag_index);	ASSIGN2(buffer, tid, 		t,		kthread_id);	ASSIGN(buffer,	lwpid, 		t->t_tid);	ASSIGN(buffer,	pid, 		ttoproc(t)->p_pid);	ASSIGN(buffer,	time_base, 	sched->time_base);	ASSIGN(buffer,	cpuid, 		sched->cpuid);	/*	 * Remember schedule record generation number so the distance	 * in virtual space can be calculated from an event record	 */	sched->record_gen = ((tnf_block_header_t *)	    ((uintptr_t)buffer & TNF_BLOCK_MASK))->generation;	/* Cannot have been written into tag space */	ASSERT(sched->record_gen != TNF_TAG_GENERATION_NUM);	return ((tnf_record_p)buffer);}

/* * Checks and makes sure all user threads are stopped */static intcpr_check_user_threads(){	kthread_id_t tp;	int rc = 0;	mutex_enter(&pidlock);	tp = curthread->t_next;	do {		if (ttoproc(tp)->p_as == &kas || ttoproc(tp)->p_stat == SZOMB)			continue;		thread_lock(tp);		/*		 * make sure that we are off all the queues and in a stopped		 * state.		 */		if (!CPR_ISTOPPED(tp)) {			thread_unlock(tp);			mutex_exit(&pidlock);			if (count == CPR_UTSTOP_RETRY) {			DEBUG1(errp("Suspend failed: cannt stop "				"uthread/n"));			cpr_err(CE_WARN, "Suspend cannot stop "				"process %s (%p:%x).",				ttoproc(tp)->p_user.u_psargs, (void *)tp,				tp->t_state);			cpr_err(CE_WARN, "Process may be waiting for"				" network request, please try again.");			}			DEBUG2(errp("cant stop t=%p state=%x pfg=%x sched=%x/n",			tp, tp->t_state, tp->t_proc_flag, tp->t_schedflag));			DEBUG2(errp("proc %p state=%x pid=%d/n",				ttoproc(tp), ttoproc(tp)->p_stat,				ttoproc(tp)->p_pidp->pid_id));			return (1);		}		thread_unlock(tp);	} while ((tp = tp->t_next) != curthread && rc == 0);	mutex_exit(&pidlock);	return (0);}

/* * Arrange for the real time profiling signal to be dispatched. */voidrealsigprof(int sysnum, int error){	proc_t *p;	klwp_t *lwp;	if (curthread->t_rprof->rp_anystate == 0)		return;	p = ttoproc(curthread);	lwp = ttolwp(curthread);	mutex_enter(&p->p_lock);	if (sigismember(&p->p_ignore, SIGPROF) ||	    signal_is_blocked(curthread, SIGPROF)) {		mutex_exit(&p->p_lock);		return;	}	lwp->lwp_siginfo.si_signo = SIGPROF;	lwp->lwp_siginfo.si_code = PROF_SIG;	lwp->lwp_siginfo.si_errno = error;	hrt2ts(gethrtime(), &lwp->lwp_siginfo.si_tstamp);	lwp->lwp_siginfo.si_syscall = sysnum;	lwp->lwp_siginfo.si_nsysarg = (sysnum > 0 && sysnum < NSYSCALL) ?		LWP_GETSYSENT(lwp)[sysnum].sy_narg : 0;	lwp->lwp_siginfo.si_fault = lwp->lwp_lastfault;	lwp->lwp_siginfo.si_faddr = lwp->lwp_lastfaddr;	lwp->lwp_lastfault = 0;	lwp->lwp_lastfaddr = NULL;	sigtoproc(p, curthread, SIGPROF);	mutex_exit(&p->p_lock);	ASSERT(lwp->lwp_cursig == 0);	if (issig(FORREAL)) {		psig();	}	mutex_enter(&p->p_lock);	lwp->lwp_siginfo.si_signo = 0;	bzero(curthread->t_rprof, sizeof (*curthread->t_rprof));	mutex_exit(&p->p_lock);}