KSE Milestone 2

Note ALL MODULES MUST BE RECOMPILED
make the kernel aware that there are smaller units of scheduling than the
process. (but only allow one thread per process at this time).
This is functionally equivalent to teh previousl -current except
that there is a thread associated with each process.

Sorry john! (your next MFC will be a doosie!)

Reviewed by: peter@freebsd.org, dillon@freebsd.org

X-MFC after:    ha ha ha ha

1 files changed, 220 insertions, 167 deletions

diff --git a/sys/kern/kern_synch.c b/sys/kern/kern_synch.c
index 24da6e9..5278d17 100644
--- a/sys/kern/kern_synch.c
+++ b/sys/kern/kern_synch.c
@@ -107,13 +107,13 @@ SYSCTL_PROC(_kern, OID_AUTO, quantum, CTLTYPE_INT|CTLFLAG_RW,
  * schedulers into account.
  */
 void
-maybe_resched(p)
-	struct proc *p;
+maybe_resched(kg)
+	struct ksegrp *kg;
 {
 
 	mtx_assert(&sched_lock, MA_OWNED);
-	if (p->p_pri.pri_level < curproc->p_pri.pri_level)
-		curproc->p_sflag |= PS_NEEDRESCHED;
+	if (kg->kg_pri.pri_level < curthread->td_ksegrp->kg_pri.pri_level)
+		curthread->td_kse->ke_flags |= KEF_NEEDRESCHED;
 }
 
 int 
@@ -245,59 +245,88 @@ schedcpu(arg)
 {
 	register fixpt_t loadfac = loadfactor(averunnable.ldavg[0]);
 	register struct proc *p;
+	register struct kse *ke;
+	register struct ksegrp *kg;
 	register int realstathz;
+	int awake;
 
 	realstathz = stathz ? stathz : hz;
 	sx_slock(&allproc_lock);
-	LIST_FOREACH(p, &allproc, p_list) {
-		/*
-		 * Increment time in/out of memory and sleep time
-		 * (if sleeping).  We ignore overflow; with 16-bit int's
-		 * (remember them?) overflow takes 45 days.
-		 */
+	FOREACH_PROC_IN_SYSTEM(p) {
 		mtx_lock_spin(&sched_lock);
 		p->p_swtime++;
-		if (p->p_stat == SSLEEP || p->p_stat == SSTOP)
-			p->p_slptime++;
-		p->p_pctcpu = (p->p_pctcpu * ccpu) >> FSHIFT;
-		/*
-		 * If the process has slept the entire second,
-		 * stop recalculating its priority until it wakes up.
-		 */
-		if (p->p_slptime > 1) {
-			mtx_unlock_spin(&sched_lock);
-			continue;
-		}
+		FOREACH_KSEGRP_IN_PROC(p, kg) { 
+			awake = 0;
+			FOREACH_KSE_IN_GROUP(kg, ke) {
+				/*
+				 * Increment time in/out of memory and sleep
+				 * time (if sleeping).  We ignore overflow;
+				 * with 16-bit int's (remember them?)
+				 * overflow takes 45 days.
+				 */
+				/* XXXKSE */
+			/*	if ((ke->ke_flags & KEF_ONRUNQ) == 0) */
+				if (p->p_stat == SSLEEP || p->p_stat == SSTOP) {
+					ke->ke_slptime++;
+				} else {
+					ke->ke_slptime = 0;
+					awake = 1;
+				}
+
+				/*
+				 * pctcpu is only for ps?
+				 * Do it per kse.. and add them up at the end?
+				 * XXXKSE
+				 */
+				ke->ke_pctcpu = (ke->ke_pctcpu * ccpu) >> FSHIFT;
+				/*
+				 * If the kse has been idle the entire second,
+				 * stop recalculating its priority until
+				 * it wakes up.
+				 */
+				if (ke->ke_slptime > 1) {
+					continue;
+				}
 
-		/*
-		 * p_pctcpu is only for ps.
-		 */
 #if	(FSHIFT >= CCPU_SHIFT)
-		p->p_pctcpu += (realstathz == 100)?
-			((fixpt_t) p->p_cpticks) << (FSHIFT - CCPU_SHIFT):
-                	100 * (((fixpt_t) p->p_cpticks)
-				<< (FSHIFT - CCPU_SHIFT)) / realstathz;
+				ke->ke_pctcpu += (realstathz == 100) ?
+				    ((fixpt_t) ke->ke_cpticks) <<
+				    (FSHIFT - CCPU_SHIFT) :
+				    100 * (((fixpt_t) ke->ke_cpticks) <<
+				    (FSHIFT - CCPU_SHIFT)) / realstathz;
 #else
-		p->p_pctcpu += ((FSCALE - ccpu) *
-			(p->p_cpticks * FSCALE / realstathz)) >> FSHIFT;
+				ke->ke_pctcpu += ((FSCALE - ccpu) *
+				    (ke->ke_cpticks * FSCALE / realstathz)) >>
+				    FSHIFT;
 #endif
-		p->p_cpticks = 0;
-		p->p_estcpu = decay_cpu(loadfac, p->p_estcpu);
-		resetpriority(p);
-		if (p->p_pri.pri_level >= PUSER) {
-			if (p->p_oncpu == NOCPU && 	/* idle */
-			    p->p_stat == SRUN &&
-			    (p->p_sflag & PS_INMEM) &&
-			    (p->p_pri.pri_level / RQ_PPQ) !=
-			    (p->p_pri.pri_user / RQ_PPQ)) {
-				remrunqueue(p);
-				p->p_pri.pri_level = p->p_pri.pri_user;
-				setrunqueue(p);
-			} else
-				p->p_pri.pri_level = p->p_pri.pri_user;
-		}
+				ke->ke_cpticks = 0;
+			} /* end of kse loop */
+			if (awake == 0) {
+				kg->kg_slptime++;
+			} else {
+				kg->kg_slptime = 0;
+			}
+			kg->kg_estcpu = decay_cpu(loadfac, kg->kg_estcpu);
+		      	resetpriority(kg);
+		      	if (kg->kg_pri.pri_level >= PUSER &&
+			    (p->p_sflag & PS_INMEM)) {
+				int changedqueue =
+				    ((kg->kg_pri.pri_level / RQ_PPQ) !=
+				     (kg->kg_pri.pri_user / RQ_PPQ));
+
+				kg->kg_pri.pri_level = kg->kg_pri.pri_user;
+				FOREACH_KSE_IN_GROUP(kg, ke) {
+					if ((ke->ke_oncpu == NOCPU) && 	/* idle */
+					    (p->p_stat == SRUN) && /* XXXKSE */
+					    changedqueue) {
+						remrunqueue(ke->ke_thread);
+						setrunqueue(ke->ke_thread);
+					}
+				}
+			}
+		} /* end of ksegrp loop */
 		mtx_unlock_spin(&sched_lock);
-	}
+	} /* end of process loop */
 	sx_sunlock(&allproc_lock);
 	vmmeter();
 	wakeup((caddr_t)&lbolt);
@@ -310,21 +339,26 @@ schedcpu(arg)
  * least six times the loadfactor will decay p_estcpu to zero.
  */
 void
-updatepri(p)
-	register struct proc *p;
+updatepri(td)
+	register struct thread *td;
 {
-	register unsigned int newcpu = p->p_estcpu;
+	register struct ksegrp *kg;
+	register unsigned int newcpu;
 	register fixpt_t loadfac = loadfactor(averunnable.ldavg[0]);
 
-	if (p->p_slptime > 5 * loadfac)
-		p->p_estcpu = 0;
+	if (td == NULL)
+		return;
+	kg = td->td_ksegrp;
+	newcpu = kg->kg_estcpu;
+	if (kg->kg_slptime > 5 * loadfac)
+		kg->kg_estcpu = 0;
 	else {
-		p->p_slptime--;	/* the first time was done in schedcpu */
-		while (newcpu && --p->p_slptime)
+		kg->kg_slptime--;	/* the first time was done in schedcpu */
+		while (newcpu && --kg->kg_slptime)
 			newcpu = decay_cpu(loadfac, newcpu);
-		p->p_estcpu = newcpu;
+		kg->kg_estcpu = newcpu;
 	}
-	resetpriority(p);
+	resetpriority(td->td_ksegrp);
 }
 
 /*
@@ -333,7 +367,7 @@ updatepri(p)
  * of 2.  Shift right by 8, i.e. drop the bottom 256 worth.
  */
 #define TABLESIZE	128
-static TAILQ_HEAD(slpquehead, proc) slpque[TABLESIZE];
+static TAILQ_HEAD(slpquehead, thread) slpque[TABLESIZE];
 #define LOOKUP(x)	(((intptr_t)(x) >> 8) & (TABLESIZE - 1))
 
 void
@@ -370,6 +404,7 @@ msleep(ident, mtx, priority, wmesg, timo)
 	const char *wmesg;
 {
 	struct proc *p = curproc;
+	struct thread *td = curthread;
 	int sig, catch = priority & PCATCH;
 	int rval = 0;
 	WITNESS_SAVE_DECL(mtx);
@@ -406,17 +441,18 @@ msleep(ident, mtx, priority, wmesg, timo)
 	}
 
 	KASSERT(p != NULL, ("msleep1"));
-	KASSERT(ident != NULL && p->p_stat == SRUN, ("msleep"));
-
-	p->p_wchan = ident;
-	p->p_wmesg = wmesg;
-	p->p_slptime = 0;
-	p->p_pri.pri_level = priority & PRIMASK;
-	CTR5(KTR_PROC, "msleep: proc %p (pid %d, %s) on %s (%p)", p, p->p_pid,
-	    p->p_comm, wmesg, ident);
-	TAILQ_INSERT_TAIL(&slpque[LOOKUP(ident)], p, p_slpq);
+	KASSERT(ident != NULL && td->td_proc->p_stat == SRUN, ("msleep"));
+
+	td->td_wchan = ident;
+	td->td_wmesg = wmesg;
+	td->td_kse->ke_slptime = 0;	/* XXXKSE */
+	td->td_ksegrp->kg_slptime = 0;
+	td->td_ksegrp->kg_pri.pri_level = priority & PRIMASK;
+	CTR5(KTR_PROC, "msleep: thread %p (pid %d, %s) on %s (%p)",
+	    td, p->p_pid, p->p_comm, wmesg, ident);
+	TAILQ_INSERT_TAIL(&slpque[LOOKUP(ident)], td, td_slpq);
 	if (timo)
-		callout_reset(&p->p_slpcallout, timo, endtsleep, p);
+		callout_reset(&td->td_slpcallout, timo, endtsleep, td);
 	/*
 	 * We put ourselves on the sleep queue and start our timeout
 	 * before calling CURSIG, as we could stop there, and a wakeup
@@ -424,40 +460,40 @@ msleep(ident, mtx, priority, wmesg, timo)
 	 * A SIGCONT would cause us to be marked as SSLEEP
 	 * without resuming us, thus we must be ready for sleep
 	 * when CURSIG is called.  If the wakeup happens while we're
-	 * stopped, p->p_wchan will be 0 upon return from CURSIG.
+	 * stopped, td->td_wchan will be 0 upon return from CURSIG.
 	 */
 	if (catch) {
 		CTR3(KTR_PROC, "msleep caught: proc %p (pid %d, %s)", p,
 		    p->p_pid, p->p_comm);
-		p->p_sflag |= PS_SINTR;
+		td->td_flags |= TDF_SINTR;
 		mtx_unlock_spin(&sched_lock);
 		PROC_LOCK(p);
 		sig = CURSIG(p);
 		mtx_lock_spin(&sched_lock);
 		PROC_UNLOCK_NOSWITCH(p);
 		if (sig != 0) {
-			if (p->p_wchan != NULL)
-				unsleep(p);
-		} else if (p->p_wchan == NULL)
+			if (td->td_wchan != NULL)
+				unsleep(td);
+		} else if (td->td_wchan == NULL)
 			catch = 0;
 	} else
 		sig = 0;
-	if (p->p_wchan != NULL) {
-		p->p_stat = SSLEEP;
+	if (td->td_wchan != NULL) {
+		td->td_proc->p_stat = SSLEEP;
 		p->p_stats->p_ru.ru_nvcsw++;
 		mi_switch();
 	}
-	CTR3(KTR_PROC, "msleep resume: proc %p (pid %d, %s)", p, p->p_pid,
+	CTR3(KTR_PROC, "msleep resume: proc %p (pid %d, %s)", td, p->p_pid,
 	    p->p_comm);
-	KASSERT(p->p_stat == SRUN, ("running but not SRUN"));
-	p->p_sflag &= ~PS_SINTR;
-	if (p->p_sflag & PS_TIMEOUT) {
-		p->p_sflag &= ~PS_TIMEOUT;
+	KASSERT(td->td_proc->p_stat == SRUN, ("running but not SRUN"));
+	td->td_flags &= ~TDF_SINTR;
+	if (td->td_flags & TDF_TIMEOUT) {
+		td->td_flags &= ~TDF_TIMEOUT;
 		if (sig == 0)
 			rval = EWOULDBLOCK;
-	} else if (p->p_sflag & PS_TIMOFAIL)
-		p->p_sflag &= ~PS_TIMOFAIL;
-	else if (timo && callout_stop(&p->p_slpcallout) == 0) {
+	} else if (td->td_flags & TDF_TIMOFAIL)
+		td->td_flags &= ~TDF_TIMOFAIL;
+	else if (timo && callout_stop(&td->td_slpcallout) == 0) {
 		/*
 		 * This isn't supposed to be pretty.  If we are here, then
 		 * the endtsleep() callout is currently executing on another
@@ -467,7 +503,7 @@ msleep(ident, mtx, priority, wmesg, timo)
 		 * has a chance to run and the callout may end up waking up
 		 * the wrong msleep().  Yuck.
 		 */
-		p->p_sflag |= PS_TIMEOUT;
+		td->td_flags |= TDF_TIMEOUT;
 		p->p_stats->p_ru.ru_nivcsw++;
 		mi_switch();
 	}
@@ -510,28 +546,28 @@ static void
 endtsleep(arg)
 	void *arg;
 {
-	register struct proc *p;
+	register struct thread *td = arg;
 
-	p = (struct proc *)arg;
-	CTR3(KTR_PROC, "endtsleep: proc %p (pid %d, %s)", p, p->p_pid,
-	    p->p_comm);
+	CTR3(KTR_PROC, "endtsleep: thread %p (pid %d, %s)", td, td->td_proc->p_pid,
+	    td->td_proc->p_comm);
 	mtx_lock_spin(&sched_lock);
 	/*
 	 * This is the other half of the synchronization with msleep()
 	 * described above.  If the PS_TIMEOUT flag is set, we lost the
 	 * race and just need to put the process back on the runqueue.
 	 */
-	if ((p->p_sflag & PS_TIMEOUT) != 0) {
-		p->p_sflag &= ~PS_TIMEOUT;
-		setrunqueue(p);
-	} else if (p->p_wchan != NULL) {
-		if (p->p_stat == SSLEEP)
-			setrunnable(p);
+	if ((td->td_flags & TDF_TIMEOUT) != 0) {
+		td->td_flags &= ~TDF_TIMEOUT;
+		setrunqueue(td);
+	} else if (td->td_wchan != NULL) {
+		if (td->td_proc->p_stat == SSLEEP)  /* XXXKSE */
+			setrunnable(td);
 		else
-			unsleep(p);
-		p->p_sflag |= PS_TIMEOUT;
-	} else
-		p->p_sflag |= PS_TIMOFAIL;
+			unsleep(td);
+		td->td_flags |= TDF_TIMEOUT;
+	} else {
+		td->td_flags |= TDF_TIMOFAIL;
+	}
 	mtx_unlock_spin(&sched_lock);
 }
 
@@ -539,14 +575,13 @@ endtsleep(arg)
  * Remove a process from its wait queue
  */
 void
-unsleep(p)
-	register struct proc *p;
+unsleep(struct thread *td)
 {
 
 	mtx_lock_spin(&sched_lock);
-	if (p->p_wchan != NULL) {
-		TAILQ_REMOVE(&slpque[LOOKUP(p->p_wchan)], p, p_slpq);
-		p->p_wchan = NULL;
+	if (td->td_wchan != NULL) {
+		TAILQ_REMOVE(&slpque[LOOKUP(td->td_wchan)], td, td_slpq);
+		td->td_wchan = NULL;
 	}
 	mtx_unlock_spin(&sched_lock);
 }
@@ -559,26 +594,29 @@ wakeup(ident)
 	register void *ident;
 {
 	register struct slpquehead *qp;
-	register struct proc *p;
+	register struct thread *td;
+	struct proc *p;
 
 	mtx_lock_spin(&sched_lock);
 	qp = &slpque[LOOKUP(ident)];
 restart:
-	TAILQ_FOREACH(p, qp, p_slpq) {
-		if (p->p_wchan == ident) {
-			TAILQ_REMOVE(qp, p, p_slpq);
-			p->p_wchan = NULL;
-			if (p->p_stat == SSLEEP) {
+	TAILQ_FOREACH(td, qp, td_slpq) {
+		p = td->td_proc;
+		if (td->td_wchan == ident) {
+			TAILQ_REMOVE(qp, td, td_slpq);
+			td->td_wchan = NULL;
+			if (td->td_proc->p_stat == SSLEEP) {
 				/* OPTIMIZED EXPANSION OF setrunnable(p); */
-				CTR3(KTR_PROC, "wakeup: proc %p (pid %d, %s)",
-				    p, p->p_pid, p->p_comm);
-				if (p->p_slptime > 1)
-					updatepri(p);
-				p->p_slptime = 0;
-				p->p_stat = SRUN;
+				CTR3(KTR_PROC, "wakeup: thread %p (pid %d, %s)",
+				    td, p->p_pid, p->p_comm);
+				if (td->td_ksegrp->kg_slptime > 1)
+					updatepri(td);
+				td->td_ksegrp->kg_slptime = 0;
+				td->td_kse->ke_slptime = 0;
+				td->td_proc->p_stat = SRUN;
 				if (p->p_sflag & PS_INMEM) {
-					setrunqueue(p);
-					maybe_resched(p);
+					setrunqueue(td);
+					maybe_resched(td->td_ksegrp);
 				} else {
 					p->p_sflag |= PS_SWAPINREQ;
 					wakeup((caddr_t)&proc0);
@@ -601,26 +639,29 @@ wakeup_one(ident)
 	register void *ident;
 {
 	register struct slpquehead *qp;
+	register struct thread *td;
 	register struct proc *p;
 
 	mtx_lock_spin(&sched_lock);
 	qp = &slpque[LOOKUP(ident)];
 
-	TAILQ_FOREACH(p, qp, p_slpq) {
-		if (p->p_wchan == ident) {
-			TAILQ_REMOVE(qp, p, p_slpq);
-			p->p_wchan = NULL;
-			if (p->p_stat == SSLEEP) {
+	TAILQ_FOREACH(td, qp, td_slpq) {
+		p = td->td_proc;
+		if (td->td_wchan == ident) {
+			TAILQ_REMOVE(qp, td, td_slpq);
+			td->td_wchan = NULL;
+			if (td->td_proc->p_stat == SSLEEP) {
 				/* OPTIMIZED EXPANSION OF setrunnable(p); */
 				CTR3(KTR_PROC, "wakeup1: proc %p (pid %d, %s)",
 				    p, p->p_pid, p->p_comm);
-				if (p->p_slptime > 1)
-					updatepri(p);
-				p->p_slptime = 0;
-				p->p_stat = SRUN;
+				if (td->td_ksegrp->kg_slptime > 1)
+					updatepri(td);
+				td->td_ksegrp->kg_slptime = 0;
+				td->td_kse->ke_slptime = 0;
+				td->td_proc->p_stat = SRUN;
 				if (p->p_sflag & PS_INMEM) {
-					setrunqueue(p);
-					maybe_resched(p);
+					setrunqueue(td);
+					maybe_resched(td->td_ksegrp);
 					break;
 				} else {
 					p->p_sflag |= PS_SWAPINREQ;
@@ -640,7 +681,8 @@ void
 mi_switch()
 {
 	struct timeval new_switchtime;
-	register struct proc *p = curproc;	/* XXX */
+	struct thread *td = curthread;	/* XXX */
+	register struct proc *p = td->td_proc;	/* XXX */
 #if 0
 	register struct rlimit *rlim;
 #endif
@@ -717,14 +759,14 @@ mi_switch()
 	    p->p_comm);
 	sched_crit = sched_lock.mtx_savecrit;
 	sched_nest = sched_lock.mtx_recurse;
-	p->p_lastcpu = p->p_oncpu;
-	p->p_oncpu = NOCPU;
-	p->p_sflag &= ~PS_NEEDRESCHED;
+	td->td_lastcpu = td->td_kse->ke_oncpu;
+	td->td_kse->ke_oncpu = NOCPU;
+	td->td_kse->ke_flags &= ~KEF_NEEDRESCHED;
 	cpu_switch();
-	p->p_oncpu = PCPU_GET(cpuid);
+	td->td_kse->ke_oncpu = PCPU_GET(cpuid);
 	sched_lock.mtx_savecrit = sched_crit;
 	sched_lock.mtx_recurse = sched_nest;
-	sched_lock.mtx_lock = (uintptr_t)p;
+	sched_lock.mtx_lock = (uintptr_t)td;
 	CTR3(KTR_PROC, "mi_switch: new proc %p (pid %d, %s)", p, p->p_pid,
 	    p->p_comm);
 	if (PCPU_GET(switchtime.tv_sec) == 0)
@@ -738,39 +780,42 @@ mi_switch()
  * and awakening the swapper if it isn't in memory.
  */
 void
-setrunnable(p)
-	register struct proc *p;
+setrunnable(struct thread *td)
 {
-
+	struct proc *p = td->td_proc;
 	mtx_lock_spin(&sched_lock);
 	switch (p->p_stat) {
+	case SZOMB: /* not a thread flag XXXKSE */
+		panic("setrunnabl(1)");
+	}
+	switch (td->td_proc->p_stat) {
 	case 0:
 	case SRUN:
-	case SZOMB:
 	case SWAIT:
 	default:
-		panic("setrunnable");
+		panic("setrunnable(2)");
 	case SSTOP:
 	case SSLEEP:			/* e.g. when sending signals */
-		if (p->p_sflag & PS_CVWAITQ)
-			cv_waitq_remove(p);
+		if (td->td_flags & TDF_CVWAITQ)
+			cv_waitq_remove(td);
 		else
-			unsleep(p);
+			unsleep(td);
 		break;
 
 	case SIDL:
 		break;
 	}
-	p->p_stat = SRUN;
-	if (p->p_slptime > 1)
-		updatepri(p);
-	p->p_slptime = 0;
+	td->td_proc->p_stat = SRUN;
+	if (td->td_ksegrp->kg_slptime > 1)
+		updatepri(td);
+	td->td_ksegrp->kg_slptime = 0;
+	td->td_kse->ke_slptime = 0;
 	if ((p->p_sflag & PS_INMEM) == 0) {
 		p->p_sflag |= PS_SWAPINREQ;
 		wakeup((caddr_t)&proc0);
 	} else {
-		setrunqueue(p);
-		maybe_resched(p);
+		setrunqueue(td);
+		maybe_resched(td->td_ksegrp);
 	}
 	mtx_unlock_spin(&sched_lock);
 }
@@ -781,20 +826,20 @@ setrunnable(p)
  * than that of the current process.
  */
 void
-resetpriority(p)
-	register struct proc *p;
+resetpriority(kg)
+	register struct ksegrp *kg;
 {
 	register unsigned int newpriority;
 
 	mtx_lock_spin(&sched_lock);
-	if (p->p_pri.pri_class == PRI_TIMESHARE) {
-		newpriority = PUSER + p->p_estcpu / INVERSE_ESTCPU_WEIGHT +
-		    NICE_WEIGHT * (p->p_nice - PRIO_MIN);
+	if (kg->kg_pri.pri_class == PRI_TIMESHARE) {
+		newpriority = PUSER + kg->kg_estcpu / INVERSE_ESTCPU_WEIGHT +
+		    NICE_WEIGHT * (kg->kg_nice - PRIO_MIN);
 		newpriority = min(max(newpriority, PRI_MIN_TIMESHARE),
 		    PRI_MAX_TIMESHARE);
-		p->p_pri.pri_user = newpriority;
+		kg->kg_pri.pri_user = newpriority;
 	}
-	maybe_resched(p);
+	maybe_resched(kg);
 	mtx_unlock_spin(&sched_lock);
 }
 
@@ -827,16 +872,22 @@ sched_setup(dummy)
  * run much recently, and to round-robin among other processes.
  */
 void
-schedclock(p)
-	struct proc *p;
+schedclock(td)
+	struct thread *td;
 {
-
-	p->p_cpticks++;
-	p->p_estcpu = ESTCPULIM(p->p_estcpu + 1);
-	if ((p->p_estcpu % INVERSE_ESTCPU_WEIGHT) == 0) {
-		resetpriority(p);
-		if (p->p_pri.pri_level >= PUSER)
-			p->p_pri.pri_level = p->p_pri.pri_user;
+	struct kse *ke = td->td_kse;
+	struct ksegrp *kg = td->td_ksegrp;
+
+	if (td) {
+		ke->ke_cpticks++;
+		kg->kg_estcpu = ESTCPULIM(kg->kg_estcpu + 1);
+		if ((kg->kg_estcpu % INVERSE_ESTCPU_WEIGHT) == 0) {
+			resetpriority(td->td_ksegrp);
+			if (kg->kg_pri.pri_level >= PUSER)
+				kg->kg_pri.pri_level = kg->kg_pri.pri_user;
+		}
+	} else {
+		panic("schedclock");
 	}
 }
 
@@ -844,18 +895,20 @@ schedclock(p)
  * General purpose yield system call
  */
 int
-yield(struct proc *p, struct yield_args *uap)
+yield(struct thread *td, struct yield_args *uap)
 {
-	p->p_retval[0] = 0;
+
+	struct ksegrp *kg = td->td_ksegrp;
+	td->td_retval[0] = 0;
 
 	mtx_lock_spin(&sched_lock);
 	mtx_assert(&Giant, MA_NOTOWNED);
 #if 0
 	DROP_GIANT_NOSWITCH();
 #endif
-	p->p_pri.pri_level = PRI_MAX_TIMESHARE;
-	setrunqueue(p);
-	p->p_stats->p_ru.ru_nvcsw++;
+	kg->kg_pri.pri_level = PRI_MAX_TIMESHARE;
+	setrunqueue(td);
+	kg->kg_proc->p_stats->p_ru.ru_nvcsw++;
 	mi_switch();
 	mtx_unlock_spin(&sched_lock);
 #if 0