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

/* * Get the time accounting information for the calling LWP. */intlwp_info(timestruc_t *tvp){	timestruc_t tv[2];	hrtime_t hrutime, hrstime;	klwp_t *lwp = ttolwp(curthread);	hrutime = lwp->lwp_mstate.ms_acct[LMS_USER];	hrstime = lwp->lwp_mstate.ms_acct[LMS_SYSTEM] +	    lwp->lwp_mstate.ms_acct[LMS_TRAP];	scalehrtime(&hrutime);	scalehrtime(&hrstime);	hrt2ts(hrutime, &tv[0]);	hrt2ts(hrstime, &tv[1]);	if (get_udatamodel() == DATAMODEL_NATIVE) {		if (copyout(tv, tvp, sizeof (tv)))			return (set_errno(EFAULT));	} else {		timestruc32_t tv32[2];		if (TIMESPEC_OVERFLOW(&tv[0]) ||		    TIMESPEC_OVERFLOW(&tv[1]))			return (set_errno(EOVERFLOW));	/* unlikely */		TIMESPEC_TO_TIMESPEC32(&tv32[0], &tv[0]);		TIMESPEC_TO_TIMESPEC32(&tv32[1], &tv[1]);		if (copyout(tv32, tvp, sizeof (tv32)))			return (set_errno(EFAULT));	}	return (0);}

/* * Initialize the microstate level and the * associated accounting information for an LWP. */voidinit_mstate(	kthread_t	*t,	int		init_state){	struct mstate *ms;	klwp_t *lwp;	hrtime_t curtime;	ASSERT(init_state != LMS_WAIT_CPU);	ASSERT((unsigned)init_state < NMSTATES);	if ((lwp = ttolwp(t)) != NULL) {		ms = &lwp->lwp_mstate;		curtime = gethrtime_unscaled();		ms->ms_prev = LMS_SYSTEM;		ms->ms_start = curtime;		ms->ms_term = 0;		ms->ms_state_start = curtime;		t->t_mstate = init_state;		t->t_waitrq = 0;		t->t_hrtime = curtime;		if ((t->t_proc_flag & TP_MSACCT) == 0)			t->t_proc_flag |= TP_MSACCT;		bzero((caddr_t)&ms->ms_acct[0], sizeof (ms->ms_acct));	}}

/* * Call a system call which takes a pointer to the user args struct and * a pointer to the return values.  This is a bit slower than the standard * C arg-passing method in some cases. */int64_tsyscall_ap(void){	uint_t	error;	struct sysent *callp;	rval_t	rval;	kthread_t *t = curthread;	klwp_t	*lwp = ttolwp(t);	struct regs *rp = lwptoregs(lwp);	callp = LWP_GETSYSENT(lwp) + t->t_sysnum;#if defined(__amd64)	/*	 * If the arguments don't fit in registers %rdi-%r9, make sure they	 * have been copied to the lwp_arg array.	 */	if (callp->sy_narg > 6 && save_syscall_args())		return ((int64_t)set_errno(EFAULT));#endif	rval.r_val1 = 0;	rval.r_val2 = rp->r_r1;	lwp->lwp_error = 0;	/* for old drivers */	error = (*(callp->sy_call))(lwp->lwp_ap, &rval);	if (error)		return ((longlong_t)set_errno(error));	return (rval.r_vals);}

voiddtrace_safe_synchronous_signal(void){#if 0    kthread_t *t = curthread;    struct regs *rp = lwptoregs(ttolwp(t));    size_t isz = t->t_dtrace_npc - t->t_dtrace_pc;    ASSERT(t->t_dtrace_on);    /*     * If we're not in the range of scratch addresses, we're not actually     * tracing user instructions so turn off the flags. If the instruction     * we copied out caused a synchonous trap, reset the pc back to its     * original value and turn off the flags.     */    if (rp->r_pc < t->t_dtrace_scrpc ||            rp->r_pc > t->t_dtrace_astpc + isz) {        t->t_dtrace_ft = 0;    } else if (rp->r_pc == t->t_dtrace_scrpc ||               rp->r_pc == t->t_dtrace_astpc) {        rp->r_pc = t->t_dtrace_pc;        t->t_dtrace_ft = 0;    }#endif /* 0 */}

/* * Copy the floating point context of the forked thread. */voidfp_fork(klwp_t *lwp, klwp_t *clwp){	kfpu_t *cfp, *pfp;	int i;	cfp = lwptofpu(clwp);	pfp = lwptofpu(lwp);	/*	 * copy the parents fpq	 */	cfp->fpu_qcnt = pfp->fpu_qcnt;	for (i = 0; i < pfp->fpu_qcnt; i++)		cfp->fpu_q[i] = pfp->fpu_q[i];	/*	 * save the context of the parent into the childs fpu structure	 */	cfp->fpu_fprs = pfp->fpu_fprs;	if (ttolwp(curthread) == lwp && fpu_exists) {		fp_fksave(cfp);	} else {		for (i = 0; i < 32; i++)			cfp->fpu_fr.fpu_regs[i] = pfp->fpu_fr.fpu_regs[i];		for (i = 16; i < 32; i++)			cfp->fpu_fr.fpu_dregs[i] = pfp->fpu_fr.fpu_dregs[i];	}	cfp->fpu_en = 1;}

/* * Call a system call which takes a pointer to the user args struct and * a pointer to the return values.  This is a bit slower than the standard * C arg-passing method in some cases. */int64_tsyscall_ap(){	uint_t	error;	struct sysent *callp;	rval_t	rval;	klwp_t	*lwp = ttolwp(curthread);	struct regs *rp = lwptoregs(lwp);	callp = LWP_GETSYSENT(lwp) + curthread->t_sysnum;	/*	 * If the arguments don't fit in registers %o0 - o5, make sure they	 * have been copied to the lwp_arg array.	 */	if (callp->sy_narg > 6 && save_syscall_args())		return ((int64_t)set_errno(EFAULT));	rval.r_val1 = 0;	rval.r_val2 = (int)rp->r_o1;	lwp->lwp_error = 0;	/* for old drivers */	error = (*(callp->sy_call))(lwp->lwp_ap, &rval);	if (error)		return ((int64_t)set_errno(error));	return (rval.r_vals);}

intdtrace_safe_defer_signal(void){	kthread_t *t = curthread;	struct regs *rp = lwptoregs(ttolwp(t));	ASSERT(t->t_dtrace_on);	/*	 * If we're not actively tracing an instruction, turn off tracing	 * flags.	 */	if (rp->r_pc != t->t_dtrace_scrpc && rp->r_pc != t->t_dtrace_astpc &&	    rp->r_npc != t->t_dtrace_astpc) {		t->t_dtrace_ft = 0;		return (0);	}	/*	 * Otherwise, make sure we'll return to the kernel after executing	 * the instruction we copied out.	 */	if (!t->t_dtrace_step) {		ASSERT(rp->r_pc == t->t_dtrace_scrpc);		rp->r_npc = t->t_dtrace_astpc;		t->t_dtrace_step = 1;	}	t->t_dtrace_ast = 1;	return (1);}

/* * Mark the current thread as sleeping on a shuttle object, and * switch to a new thread. * No locks other than 'l' should be held at this point. */voidshuttle_swtch(kmutex_t *l){	klwp_t	*lwp = ttolwp(curthread);	thread_lock(curthread);	disp_lock_enter_high(&shuttle_lock);	lwp->lwp_asleep = 1;			/* /proc */	lwp->lwp_sysabort = 0;			/* /proc */	lwp->lwp_ru.nvcsw++;	curthread->t_flag |= T_WAKEABLE;	curthread->t_sobj_ops = &shuttle_sobj_ops;	curthread->t_wchan0 = (caddr_t)1;	CL_INACTIVE(curthread);	DTRACE_SCHED(sleep);	THREAD_SLEEP(curthread, &shuttle_lock);	(void) new_mstate(curthread, LMS_SLEEP);	disp_lock_exit_high(&shuttle_lock);	mutex_exit(l);	if (ISSIG(curthread, JUSTLOOKING) || MUSTRETURN(curproc, curthread))		setrun(curthread);	swtch();	/*	 * Caller must check for ISSIG/lwp_sysabort conditions	 * and clear lwp->lwp_asleep/lwp->lwp_sysabort	 */}

/* * Handle indirect system calls. *	This interface should be deprecated.  The library can handle *	this more efficiently, but keep this implementation for old binaries. * * XX64	Needs some work. */int64_tindir(int code, long a0, long a1, long a2, long a3, long a4){	klwp_t		*lwp = ttolwp(curthread);	struct sysent	*callp;	if (code <= 0 || code >= NSYSCALL)		return (nosys());	ASSERT(lwp->lwp_ap != NULL);	curthread->t_sysnum = code;	callp = LWP_GETSYSENT(lwp) + code;	/*	 * Handle argument setup, unless already done in pre_syscall().	 */	if (callp->sy_narg > 5) {		if (save_syscall_args()) 	/* move args to LWP array */			return ((int64_t)set_errno(EFAULT));	} else if (!lwp->lwp_argsaved) {		long *ap;		ap = lwp->lwp_ap;		/* args haven't been saved */		lwp->lwp_ap = ap + 1;		/* advance arg pointer */		curthread->t_post_sys = 1;	/* so lwp_ap will be reset */	}	return ((*callp->sy_callc)(a0, a1, a2, a3, a4, lwp->lwp_arg[5]));}

/* * Common code for reading a buffer with various options * * Read in (if necessary) the block and return a buffer pointer. */struct buf *bread_common(void *arg, dev_t dev, daddr_t blkno, long bsize){	struct ufsvfs *ufsvfsp = (struct ufsvfs *)arg;	struct buf *bp;	klwp_t *lwp = ttolwp(curthread);	CPU_STATS_ADD_K(sys, lread, 1);	bp = getblk_common(ufsvfsp, dev, blkno, bsize, /* errflg */ 1);	if (bp->b_flags & B_DONE)		return (bp);	bp->b_flags |= B_READ;	ASSERT(bp->b_bcount == bsize);	if (ufsvfsp == NULL) {					/* !ufs */		(void) bdev_strategy(bp);	} else if (ufsvfsp->vfs_log && bio_lufs_strategy != NULL) {							/* ufs && logging */		(*bio_lufs_strategy)(ufsvfsp->vfs_log, bp);	} else if (ufsvfsp->vfs_snapshot && bio_snapshot_strategy != NULL) {							/* ufs && snapshots */		(*bio_snapshot_strategy)(&ufsvfsp->vfs_snapshot, bp);	} else {		ufsvfsp->vfs_iotstamp = ddi_get_lbolt();		ub.ub_breads.value.ul++;		/* ufs && !logging */		(void) bdev_strategy(bp);	}	if (lwp != NULL)		lwp->lwp_ru.inblock++;	CPU_STATS_ADD_K(sys, bread, 1);	(void) biowait(bp);	return (bp);}

voidreset_syscall_args(void){	klwp_t *lwp = ttolwp(curthread);	lwp->lwp_ap = (long *)&lwptoregs(lwp)->r_o0;	lwp->lwp_argsaved = 0;}

/* * set_errno - set an error return from the current system call. *	This could be a macro. *	This returns the value it is passed, so that the caller can *	use tail-recursion-elimination and do return (set_errno(ERRNO)); */uint_tset_errno(uint_t error){	ASSERT(error != 0);		/* must not be used to clear errno */	curthread->t_post_sys = 1;	/* have post_syscall do error return */	return (ttolwp(curthread)->lwp_errno = error);}

/* * Return the amount of onproc and runnable time this thread has experienced. * * Because the fields we read are not protected by locks when updated * by the thread itself, this is an inherently racey interface.  In * particular, the ASSERT(THREAD_LOCK_HELD(t)) doesn't guarantee as much * as it might appear to. * * The implication for users of this interface is that onproc and runnable * are *NOT* monotonically increasing; they may temporarily be larger than * they should be. */voidmstate_systhread_times(kthread_t *t, hrtime_t *onproc, hrtime_t *runnable){	struct mstate	*const	ms = &ttolwp(t)->lwp_mstate;	int		mstate;	hrtime_t	now;	hrtime_t	state_start;	hrtime_t	waitrq;	hrtime_t	aggr_onp;	hrtime_t	aggr_run;	ASSERT(THREAD_LOCK_HELD(t));	ASSERT(t->t_procp->p_flag & SSYS);	ASSERT(ttolwp(t) != NULL);	/* shouldn't be any non-SYSTEM on-CPU time */	ASSERT(ms->ms_acct[LMS_USER] == 0);	ASSERT(ms->ms_acct[LMS_TRAP] == 0);	mstate = t->t_mstate;	waitrq = t->t_waitrq;	state_start = ms->ms_state_start;	aggr_onp = ms->ms_acct[LMS_SYSTEM];	aggr_run = ms->ms_acct[LMS_WAIT_CPU];	now = gethrtime_unscaled();	/* if waitrq == 0, then there is no time to account to TS_RUN */	if (waitrq == 0)		waitrq = now;	/* If there is system time to accumulate, do so */	if (mstate == LMS_SYSTEM && state_start < waitrq)		aggr_onp += waitrq - state_start;	if (waitrq < now)		aggr_run += now - waitrq;	scalehrtime(&aggr_onp);	scalehrtime(&aggr_run);	*onproc = aggr_onp;	*runnable = aggr_run;}

/* * 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);}

/*ARGSUSED*/int64_tloadable_syscall(    long a0, long a1, long a2, long a3,    long a4, long a5, long a6, long a7){	klwp_t *lwp = ttolwp(curthread);	int64_t	rval;	struct sysent *callp;	struct sysent *se = LWP_GETSYSENT(lwp);	krwlock_t *module_lock;	int code, error = 0;	int64_t (*sy_call)();	code = curthread->t_sysnum;	callp = se + code;	/*	 * Try to autoload the system call if necessary	 */	module_lock = lock_syscall(se, code);	THREAD_KPRI_RELEASE();	/* drop priority given by rw_enter */	/*	 * we've locked either the loaded syscall or nosys	 */	if (lwp_getdatamodel(lwp) == DATAMODEL_NATIVE) {#if defined(_LP64)		if (callp->sy_flags & SE_ARGC) {			sy_call = (int64_t (*)())callp->sy_call;			rval = (*sy_call)(a0, a1, a2, a3, a4, a5);		} else			rval = syscall_ap();	} else {#endif		/*		 * Now that it's loaded, make sure enough args were copied.		 */		if (COPYIN_ARGS32(lwptoregs(lwp), lwp->lwp_ap, callp->sy_narg))			error = EFAULT;		if (error) {			rval = set_errno(error);		} else if (callp->sy_flags & SE_ARGC) {			sy_call = (int64_t (*)())callp->sy_call;			rval = (*sy_call)(lwp->lwp_ap[0], lwp->lwp_ap[1],			    lwp->lwp_ap[2], lwp->lwp_ap[3], lwp->lwp_ap[4],			    lwp->lwp_ap[5]);		} else			rval = syscall_ap();	}	THREAD_KPRI_REQUEST();	/* regain priority from read lock */	rw_exit(module_lock);	return (rval);}

intsigresend(int sig, siginfo_t *siginfo, sigset_t *mask){	kthread_t *t = curthread;	klwp_t *lwp = ttolwp(t);	sigqueue_t *sqp = kmem_zalloc(sizeof (*sqp), KM_SLEEP);	sigset_t set;	k_sigset_t kset;	int error;	if (sig <= 0 || sig >= NSIG || sigismember(&cantmask, sig)) {		error = EINVAL;		goto bad;	}	if (siginfo == NULL) {		sqp->sq_info.si_signo = sig;		sqp->sq_info.si_code = SI_NOINFO;	} else {		if (copyin_siginfo(get_udatamodel(), siginfo, &sqp->sq_info)) {			error = EFAULT;			goto bad;		}		if (sqp->sq_info.si_signo != sig) {			error = EINVAL;			goto bad;		}	}	if (copyin(mask, &set, sizeof (set))) {		error = EFAULT;		goto bad;	}	sigutok(&set, &kset);	/*	 * We don't need to acquire p->p_lock here;	 * we are manipulating thread-private data.	 */	if (lwp->lwp_cursig || lwp->lwp_curinfo) {		t->t_sig_check = 1;		error = EAGAIN;		goto bad;	}	lwp->lwp_cursig = sig;	lwp->lwp_curinfo = sqp;	schedctl_finish_sigblock(t);	t->t_hold = kset;	t->t_sig_check = 1;	return (0);bad:	kmem_free(sqp, sizeof (*sqp));	return (set_errno(error));}

/* * Poll for an input event. * * timo is measured in ticks */intt_kspoll(TIUSER *tiptr, int timo, int waitflg, int *events){	file_t		*fp;	vnode_t		*vp;	klwp_t		*lwp = ttolwp(curthread);	clock_t		timout;	/* milliseconds */	int		error;	u_char 		pri;	int 		pflag;	rval_t		rval;	fp = tiptr->fp;	vp = fp->f_vnode;	if (events == NULL || ((waitflg & READWAIT) == 0))		return (EINVAL);	/* Convert from ticks to milliseconds */	if (timo < 0)		timout = -1;	else		timout = TICK_TO_MSEC(timo);	/*	 * Indicate that the lwp is not to be stopped while doing	 * this network traffic.  This is to avoid deadlock while	 * debugging a process via /proc.	 */	if (lwp != NULL)		lwp->lwp_nostop++;	if (waitflg & NOINTR)		pflag = MSG_ANY | MSG_HOLDSIG;	else		pflag = MSG_ANY;	pri = 0;	error = kstrgetmsg(vp, NULL, NULL, &pri, &pflag, timout, &rval);	if (lwp != NULL)		lwp->lwp_nostop--;	/* Set the return *events. */	if (error != 0) {		if (error == ETIME) {			*events = 0;			error = 0;		}		return (error);	}	*events = 1;	return (0);}

/* * 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);}

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);}

voidfp_enable(void){	klwp_id_t lwp;	kfpu_t *fp;	lwp = ttolwp(curthread);	ASSERT(lwp != NULL);	fp = lwptofpu(lwp);	if (fpu_exists) {		if (fp->fpu_en) {#ifdef DEBUG			if (fpdispr)				cmn_err(CE_NOTE,				    "fpu disabled, but already enabled/n");#endif			if ((fp->fpu_fprs & FPRS_FEF) != FPRS_FEF) {				fp->fpu_fprs = FPRS_FEF;#ifdef DEBUG				if (fpdispr)					cmn_err(CE_NOTE,					"fpu disabled, saved fprs disabled/n");#endif			}			_fp_write_fprs(FPRS_FEF);			fp_restore(fp);		} else {			fp->fpu_en = 1;			fp->fpu_fsr = 0;			fp->fpu_fprs = FPRS_FEF;			_fp_write_fprs(FPRS_FEF);			fp_clearregs(fp);		}	} else {		int i;		if (!fp->fpu_en) {			fp->fpu_en = 1;			fp->fpu_fsr = 0;			for (i = 0; i < 32; i++)				fp->fpu_fr.fpu_regs[i] = (uint_t)-1; /* NaN */			for (i = 16; i < 32; i++)		/* NaN */				fp->fpu_fr.fpu_dregs[i] = (uint64_t)-1;		}	}}

/* * libc-private syscall for managing per-lwp %gs and %fs segment base values. */intsyslwp_private(int cmd, int which, uintptr_t base){	klwp_t *lwp = ttolwp(curthread);	int res, error;	switch (cmd) {	case _LWP_SETPRIVATE:		res = lwp_setprivate(lwp, which, base);		return (res < 0 ? set_errno(ENOTSUP) : res);	case _LWP_GETPRIVATE:		error = lwp_getprivate(lwp, which, base);		return (error != 0 ? set_errno(error) : error);	default:		return (set_errno(ENOTSUP));	}}

voidsyscall_mstate(int fromms, int toms){	kthread_t *t = curthread;	zone_t *z = ttozone(t);	struct mstate *ms;	hrtime_t *mstimep;	hrtime_t curtime;	klwp_t *lwp;	hrtime_t newtime;	cpu_t *cpu;	uint16_t gen;	if ((lwp = ttolwp(t)) == NULL)		return;	ASSERT(fromms < NMSTATES);	ASSERT(toms < NMSTATES);	ms = &lwp->lwp_mstate;	mstimep = &ms->ms_acct[fromms];	curtime = gethrtime_unscaled();	newtime = curtime - ms->ms_state_start;	while (newtime < 0) {		curtime = gethrtime_unscaled();		newtime = curtime - ms->ms_state_start;	}	*mstimep += newtime;	if (fromms == LMS_USER)		atomic_add_64(&z->zone_utime, newtime);	else if (fromms == LMS_SYSTEM)		atomic_add_64(&z->zone_stime, newtime);	t->t_mstate = toms;	ms->ms_state_start = curtime;	ms->ms_prev = fromms;	kpreempt_disable(); /* don't change CPU while changing CPU's state */	cpu = CPU;	ASSERT(cpu == t->t_cpu);	if ((toms != LMS_USER) && (cpu->cpu_mstate != CMS_SYSTEM)) {		NEW_CPU_MSTATE(CMS_SYSTEM);	} else if ((toms == LMS_USER) && (cpu->cpu_mstate != CMS_USER)) {		NEW_CPU_MSTATE(CMS_USER);	}	kpreempt_enable();}

/* * Return an aggregation of user and system CPU time consumed by * the specified thread in scaled nanoseconds. */hrtime_tmstate_thread_onproc_time(kthread_t *t){	hrtime_t aggr_time;	hrtime_t now;	hrtime_t waitrq;	hrtime_t state_start;	struct mstate *ms;	klwp_t *lwp;	int	mstate;	ASSERT(THREAD_LOCK_HELD(t));	if ((lwp = ttolwp(t)) == NULL)		return (0);	mstate = t->t_mstate;	waitrq = t->t_waitrq;	ms = &lwp->lwp_mstate;	state_start = ms->ms_state_start;	aggr_time = ms->ms_acct[LMS_USER] +	    ms->ms_acct[LMS_SYSTEM] + ms->ms_acct[LMS_TRAP];	now = gethrtime_unscaled();	/*	 * NOTE: gethrtime_unscaled on X86 taken on different CPUs is	 * inconsistent, so it is possible that now < state_start.	 */	if (mstate == LMS_USER || mstate == LMS_SYSTEM || mstate == LMS_TRAP) {		/* if waitrq is zero, count all of the time. */		if (waitrq == 0) {			waitrq = now;		}		if (waitrq > state_start) {			aggr_time += waitrq - state_start;		}	}	scalehrtime(&aggr_time);	return (aggr_time);}

/* * Common code for writing a buffer with various options. * * force_wait  - wait for write completion regardless of B_ASYNC flag * do_relse    - release the buffer when we are done * clear_flags - flags to clear from the buffer */voidbwrite_common(void *arg, struct buf *bp, int force_wait,				int do_relse, int clear_flags){	register int do_wait;	struct ufsvfs *ufsvfsp = (struct ufsvfs *)arg;	int flag;	klwp_t *lwp = ttolwp(curthread);	struct cpu *cpup;	ASSERT(SEMA_HELD(&bp->b_sem));	flag = bp->b_flags;	bp->b_flags &= ~clear_flags;	if (lwp != NULL)		lwp->lwp_ru.oublock++;	CPU_STATS_ENTER_K();	cpup = CPU;		/* get pointer AFTER preemption is disabled */	CPU_STATS_ADDQ(cpup, sys, lwrite, 1);	CPU_STATS_ADDQ(cpup, sys, bwrite, 1);	do_wait = ((flag & B_ASYNC) == 0 || force_wait);	if (do_wait == 0)		CPU_STATS_ADDQ(cpup, sys, bawrite, 1);	CPU_STATS_EXIT_K();	if (ufsvfsp == NULL) {		(void) bdev_strategy(bp);	} else if (ufsvfsp->vfs_log && bio_lufs_strategy != NULL) {							/* ufs && logging */		(*bio_lufs_strategy)(ufsvfsp->vfs_log, bp);	} else if (ufsvfsp->vfs_snapshot && bio_snapshot_strategy != NULL) {							/* ufs && snapshots */		(*bio_snapshot_strategy)(&ufsvfsp->vfs_snapshot, bp);	} else {		ub.ub_bwrites.value.ul++;		/* ufs && !logging */		(void) bdev_strategy(bp);	}	if (do_wait) {		(void) biowait(bp);		if (do_relse) {			brelse(bp);		}	}}

/* * The cv_block() function blocks a thread on a condition variable * by putting it in a hashed sleep queue associated with the * synchronization object. * * Threads are taken off the hashed sleep queues via calls to * cv_signal(), cv_broadcast(), or cv_unsleep(). */static voidcv_block(condvar_impl_t *cvp){	kthread_t *t = curthread;	klwp_t *lwp = ttolwp(t);	sleepq_head_t *sqh;	ASSERT(THREAD_LOCK_HELD(t));	ASSERT(t != CPU->cpu_idle_thread);	ASSERT(CPU_ON_INTR(CPU) == 0);	ASSERT(t->t_wchan0 == NULL && t->t_wchan == NULL);	ASSERT(t->t_state == TS_ONPROC);	t->t_schedflag &= ~TS_SIGNALLED;	CL_SLEEP(t);			/* assign kernel priority */	t->t_wchan = (caddr_t)cvp;	t->t_sobj_ops = &cv_sobj_ops;	DTRACE_SCHED(sleep);	/*	 * The check for t_intr is to avoid doing the	 * account for an interrupt thread on the still-pinned	 * lwp's statistics.	 */	if (lwp != NULL && t->t_intr == NULL) {		lwp->lwp_ru.nvcsw++;		(void) new_mstate(t, LMS_SLEEP);	}	sqh = SQHASH(cvp);	disp_lock_enter_high(&sqh->sq_lock);	if (cvp->cv_waiters < CV_MAX_WAITERS)		cvp->cv_waiters++;	ASSERT(cvp->cv_waiters <= CV_MAX_WAITERS);	THREAD_SLEEP(t, &sqh->sq_lock);	sleepq_insert(&sqh->sq_queue, t);	/*	 * THREAD_SLEEP() moves curthread->t_lockp to point to the	 * lock sqh->sq_lock. This lock is later released by the caller	 * when it calls thread_unlock() on curthread.	 */}

static intwatch_suword64(void *addr, uint64_t value){	klwp_t *lwp = ttolwp(curthread);	int watchcode;	caddr_t vaddr;	int mapped;	int rv = 0;	int ta;	label_t ljb;	for (;;) {		vaddr = (caddr_t)addr;		watchcode = pr_is_watchpoint(&vaddr, &ta, sizeof (value), NULL,		    S_WRITE);		if (watchcode == 0 || ta != 0) {			mapped = pr_mappage((caddr_t)addr, sizeof (value),			    S_WRITE, 1);			if (on_fault(&ljb))				rv = -1;			else				suword64_noerr(addr, value);			no_fault();			if (mapped)				pr_unmappage((caddr_t)addr, sizeof (value),				    S_WRITE, 1);		}		if (watchcode &&		    (!sys_watchpoint(vaddr, watchcode, ta) ||		    lwp->lwp_sysabort)) {			lwp->lwp_sysabort = 0;			rv = -1;			break;		}		if (watchcode == 0 || ta != 0)			break;	}	return (rv);}