1:1 Userland threading stage 2.8/4:
authorSimon Schubert <corecode@dragonflybsd.org>
Tue, 11 Oct 2005 09:59:56 +0000 (09:59 +0000)
committerSimon Schubert <corecode@dragonflybsd.org>
Tue, 11 Oct 2005 09:59:56 +0000 (09:59 +0000)
Switch the userland scheduler to use lwps instead of procs.

23 files changed:
sys/ddb/db_ps.c
sys/i386/i386/trap.c
sys/i386/i386/vm86.c
sys/kern/init_main.c
sys/kern/kern_clock.c
sys/kern/kern_exit.c
sys/kern/kern_fork.c
sys/kern/kern_resource.c
sys/kern/kern_sig.c
sys/kern/kern_synch.c
sys/kern/kern_upcall.c
sys/kern/lwkt_thread.c
sys/kern/usched_bsd4.c
sys/kern/vfs_aio.c
sys/netproto/smb/smb_subr.c
sys/platform/pc32/i386/trap.c
sys/platform/pc32/i386/vm86.c
sys/sys/globaldata.h
sys/sys/proc.h
sys/sys/thread.h
sys/sys/usched.h
sys/vm/vm_glue.c
sys/vm/vm_pageout.c

index f4bfd26..9505b7b 100644 (file)
@@ -31,7 +31,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/ddb/db_ps.c,v 1.20 1999/08/28 00:41:09 peter Exp $
- * $DragonFly: src/sys/ddb/db_ps.c,v 1.13 2005/04/25 22:26:22 dillon Exp $
+ * $DragonFly: src/sys/ddb/db_ps.c,v 1.14 2005/10/11 09:59:56 corecode Exp $
  */
 #include <sys/param.h>
 #include <sys/systm.h>
@@ -108,9 +108,10 @@ db_ps(dummy1, dummy2, dummy3, dummy4)
            db_printf("cpu %d tdrunqmask %08x curthread %p reqflags %04x\n",
                    gd->gd_cpuid, gd->gd_runqmask,
                    gd->gd_curthread, gd->gd_reqflags);
-           db_printf("       uschedcp %p (%d) upri %d\n",
+           db_printf("       uschedcp %p (%d/%d) upri %d\n",
                    gd->gd_uschedcp,
-                   (gd->gd_uschedcp ? gd->gd_uschedcp->p_pid : -1),
+                   (gd->gd_uschedcp ? gd->gd_uschedcp->lwp_proc->p_pid : -1),
+                   (gd->gd_uschedcp ? gd->gd_uschedcp->lwp_tid : -1),
                    gd->gd_upri);
            if (gd->gd_curthread && gd->gd_curthread->td_preempted) {
                    db_printf("       PREEMPTING THREAD %p\n",
@@ -195,12 +196,13 @@ db_ps(dummy1, dummy2, dummy3, dummy4)
        }
        if (db_more(&nl) < 0)
            return;
-       db_printf("CURCPU %d CURTHREAD %p (%d) USCHEDCP %p (%d) UPRI %d\n",
+       db_printf("CURCPU %d CURTHREAD %p (%d) USCHEDCP %p (%d/%d) UPRI %d\n",
            mycpu->gd_cpuid,
            curthread,
            (curthread->td_proc ? curthread->td_proc->p_pid : -1),
            mycpu->gd_uschedcp,
-           (mycpu->gd_uschedcp ? mycpu->gd_uschedcp->p_pid : -1),
+           (mycpu->gd_uschedcp ? mycpu->gd_uschedcp->lwp_proc->p_pid : -1),
+           (mycpu->gd_uschedcp ? mycpu->gd_uschedcp->lwp_tid : -1),
            mycpu->gd_upri);
        db_dump_td_tokens(curthread);
 }
index a0ab503..2bd2cc7 100644 (file)
@@ -36,7 +36,7 @@
  *
  *     from: @(#)trap.c        7.4 (Berkeley) 5/13/91
  * $FreeBSD: src/sys/i386/i386/trap.c,v 1.147.2.11 2003/02/27 19:09:59 luoqi Exp $
- * $DragonFly: src/sys/i386/i386/Attic/trap.c,v 1.63 2005/10/09 21:38:04 corecode Exp $
+ * $DragonFly: src/sys/i386/i386/Attic/trap.c,v 1.64 2005/10/11 09:59:56 corecode Exp $
  */
 
 /*
@@ -182,11 +182,11 @@ extern int max_sysmsg;
 static void
 passive_release(struct thread *td)
 {
-       struct proc *p = td->td_proc;
+       struct lwp *lp = td->td_lwp;
 
        td->td_release = NULL;
        lwkt_setpri_self(TDPRI_KERN_USER);
-       p->p_usched->release_curproc(p);
+       lp->lwp_proc->p_usched->release_curproc(lp);
 }
 
 /*
@@ -253,7 +253,6 @@ userret(struct lwp *lp, struct trapframe *frame, int sticks)
 static __inline void
 userexit(struct lwp *lp)
 {
-       struct proc *p = lp->lwp_proc;
        struct thread *td = lp->lwp_thread;
        globaldata_t gd = td->td_gd;
 
@@ -264,7 +263,7 @@ userexit(struct lwp *lp)
         * be chosen again if it has a considerably better priority.
         */
        if (user_resched_wanted())
-               p->p_usched->release_curproc(p);
+               lp->lwp_proc->p_usched->release_curproc(lp);
 #endif
 
 again:
@@ -286,9 +285,9 @@ again:
         * to figure out which is the best of [ existing, waking-up ]
         * threads.
         */
-       if (p != gd->gd_uschedcp) {
+       if (lp != gd->gd_uschedcp) {
                ++slow_release;
-               p->p_usched->acquire_curproc(p);
+               lp->lwp_proc->p_usched->acquire_curproc(lp);
                /* We may have switched cpus on acquisition */
                gd = td->td_gd;
        } else {
@@ -320,8 +319,8 @@ again:
         * is pending the trap will be re-entered.
         */
        if (user_resched_wanted()) {
-               p->p_usched->select_curproc(gd);
-               if (p != gd->gd_uschedcp) {
+               lp->lwp_proc->p_usched->select_curproc(gd);
+               if (lp != gd->gd_uschedcp) {
                        lwkt_setpri_self(TDPRI_KERN_USER);
                        goto again;
                }
index 1582ef1..789171e 100644 (file)
@@ -25,7 +25,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/i386/i386/vm86.c,v 1.31.2.2 2001/10/05 06:18:55 peter Exp $
- * $DragonFly: src/sys/i386/i386/Attic/vm86.c,v 1.15 2005/10/07 21:55:15 corecode Exp $
+ * $DragonFly: src/sys/i386/i386/Attic/vm86.c,v 1.16 2005/10/11 09:59:56 corecode Exp $
  */
 
 #include <sys/param.h>
@@ -54,7 +54,7 @@
 #include <bus/isa/rtc.h>
 #include <i386/isa/timerreg.h>
 
-extern int i386_extend_pcb     (struct proc *);
+extern int i386_extend_pcb     (struct lwp *);
 extern int vm86pa;
 extern struct pcb *vm86pcb;
 
index be22bd8..1f4b5f5 100644 (file)
@@ -40,7 +40,7 @@
  *
  *     @(#)init_main.c 8.9 (Berkeley) 1/21/94
  * $FreeBSD: src/sys/kern/init_main.c,v 1.134.2.8 2003/06/06 20:21:32 tegge Exp $
- * $DragonFly: src/sys/kern/init_main.c,v 1.47 2005/10/09 21:38:04 corecode Exp $
+ * $DragonFly: src/sys/kern/init_main.c,v 1.48 2005/10/11 09:59:56 corecode Exp $
  */
 
 #include "opt_init_path.h"
@@ -456,11 +456,16 @@ start_init(void *dummy)
        char *var, *path, *next, *s;
        char *ucp, **uap, *arg0, *arg1;
        struct proc *p;
+       struct lwp *lp;
        struct mount *mp;
        struct vnode *vp;
 
        p = curproc;
 
+       KKASSERT(p->p_nthreads == 1);
+
+       lp = LIST_FIRST(&p->p_lwps);
+
        /* Get the vnode for '/'.  Set p->p_fd->fd_cdir to reference it. */
        mp = mountlist_boot_getfirst();
        if (VFS_ROOT(mp, &vp))
@@ -568,8 +573,8 @@ start_init(void *dummy)
                 * release it.
                 */
                if ((error = execve(&args)) == 0) {
-                       if (p->p_thread->td_gd->gd_uschedcp != p)
-                               p->p_usched->acquire_curproc(p);
+                       if (lp->lwp_thread->td_gd->gd_uschedcp != lp)
+                               lp->lwp_proc->p_usched->acquire_curproc(lp);
                        rel_mplock();
                        return;
                }
@@ -594,7 +599,7 @@ create_init(const void *udata __unused)
        int error;
 
        crit_enter();
-       error = fork1(&proc0, RFFDG | RFPROC, &initproc);
+       error = fork1(&proc0.p_lwp, RFFDG | RFPROC, &initproc);
        if (error)
                panic("cannot fork init: %d", error);
        initproc->p_flag |= P_INMEM | P_SYSTEM;
@@ -609,7 +614,7 @@ SYSINIT(init,SI_SUB_CREATE_INIT, SI_ORDER_FIRST, create_init, NULL)
 static void
 kick_init(const void *udata __unused)
 {
-       start_forked_proc(&proc0, initproc);
+       start_forked_proc(&proc0.p_lwp, initproc);
 }
 SYSINIT(kickinit,SI_SUB_KTHREAD_INIT, SI_ORDER_FIRST, kick_init, NULL)
 
index 537853f..07bf5a0 100644 (file)
@@ -70,7 +70,7 @@
  *
  *     @(#)kern_clock.c        8.5 (Berkeley) 1/21/94
  * $FreeBSD: src/sys/kern/kern_clock.c,v 1.105.2.10 2002/10/17 13:19:40 maxim Exp $
- * $DragonFly: src/sys/kern/kern_clock.c,v 1.46 2005/10/08 12:24:26 corecode Exp $
+ * $DragonFly: src/sys/kern/kern_clock.c,v 1.47 2005/10/11 09:59:56 corecode Exp $
  */
 
 #include "opt_ntp.h"
@@ -634,28 +634,33 @@ statclock(systimer_t info, struct intrframe *frame)
 static void
 schedclock(systimer_t info, struct intrframe *frame)
 {
-       struct proc *p;
+       struct lwp *lp;
        struct pstats *pstats;
        struct rusage *ru;
        struct vmspace *vm;
        long rss;
 
-       if ((p = lwkt_preempted_proc()) != NULL) {
+       if ((lp = lwkt_preempted_proc()) != NULL) {
                /*
                 * Account for cpu time used and hit the scheduler.  Note
                 * that this call MUST BE MP SAFE, and the BGL IS NOT HELD
                 * HERE.
                 */
-               ++p->p_cpticks;
-                p->p_usched->schedulerclock(p, info->periodic, info->time);
+               ++lp->lwp_cpticks;
+               /*
+                * XXX I think accessing lwp_proc's p_usched is
+                * reasonably MP safe.  This needs to be revisited
+                * when we have pluggable schedulers.
+                */
+               lp->lwp_proc->p_usched->schedulerclock(lp, info->periodic, info->time);
        }
-       if ((p = curproc) != NULL) {
+       if ((lp = curthread->td_lwp) != NULL) {
                /*
                 * Update resource usage integrals and maximums.
                 */
-               if ((pstats = p->p_stats) != NULL &&
+               if ((pstats = lp->lwp_stats) != NULL &&
                    (ru = &pstats->p_ru) != NULL &&
-                   (vm = p->p_vmspace) != NULL) {
+                   (vm = lp->lwp_proc->p_vmspace) != NULL) {
                        ru->ru_ixrss += pgtok(vm->vm_tsize);
                        ru->ru_idrss += pgtok(vm->vm_dsize);
                        ru->ru_isrss += pgtok(vm->vm_ssize);
index 4cc3fec..9c1b528 100644 (file)
@@ -37,7 +37,7 @@
  *
  *     @(#)kern_exit.c 8.7 (Berkeley) 2/12/94
  * $FreeBSD: src/sys/kern/kern_exit.c,v 1.92.2.11 2003/01/13 22:51:16 dillon Exp $
- * $DragonFly: src/sys/kern/kern_exit.c,v 1.46 2005/10/09 21:38:04 corecode Exp $
+ * $DragonFly: src/sys/kern/kern_exit.c,v 1.47 2005/10/11 09:59:56 corecode Exp $
  */
 
 #include "opt_compat.h"
@@ -396,7 +396,7 @@ exit1(int rv)
         * Release the current user process designation on the process so
         * the userland scheduler can work in someone else.
         */
-       p->p_usched->release_curproc(p);
+       p->p_usched->release_curproc(lp);
 
        /*
         * Finally, call machine-dependent code to release the remaining
@@ -490,7 +490,7 @@ loop:
                        lwkt_wait_free(p->p_thread);
 
                        /* scheduling hook for heuristic */
-                       p->p_usched->heuristic_exiting(q, p);
+                       p->p_usched->heuristic_exiting(td->td_lwp, &p->p_lwp);
 
                        /* Take care of our return values. */
                        *res = p->p_pid;
index 4f4e220..fc30504 100644 (file)
@@ -37,7 +37,7 @@
  *
  *     @(#)kern_fork.c 8.6 (Berkeley) 4/8/94
  * $FreeBSD: src/sys/kern/kern_fork.c,v 1.72.2.14 2003/06/26 04:15:10 silby Exp $
- * $DragonFly: src/sys/kern/kern_fork.c,v 1.42 2005/10/09 21:38:04 corecode Exp $
+ * $DragonFly: src/sys/kern/kern_fork.c,v 1.43 2005/10/11 09:59:56 corecode Exp $
  */
 
 #include "opt_ktrace.h"
@@ -89,13 +89,13 @@ int forksleep; /* Place for fork1() to sleep on. */
 int
 fork(struct fork_args *uap)
 {
-       struct proc *p = curproc;
+       struct lwp *lp = curthread->td_lwp;
        struct proc *p2;
        int error;
 
-       error = fork1(p, RFFDG | RFPROC, &p2);
+       error = fork1(lp, RFFDG | RFPROC, &p2);
        if (error == 0) {
-               start_forked_proc(p, p2);
+               start_forked_proc(lp, p2);
                uap->sysmsg_fds[0] = p2->p_pid;
                uap->sysmsg_fds[1] = 0;
        }
@@ -106,13 +106,13 @@ fork(struct fork_args *uap)
 int
 vfork(struct vfork_args *uap)
 {
-       struct proc *p = curproc;
+       struct lwp *lp = curthread->td_lwp;
        struct proc *p2;
        int error;
 
-       error = fork1(p, RFFDG | RFPROC | RFPPWAIT | RFMEM, &p2);
+       error = fork1(lp, RFFDG | RFPROC | RFPPWAIT | RFMEM, &p2);
        if (error == 0) {
-               start_forked_proc(p, p2);
+               start_forked_proc(lp, p2);
                uap->sysmsg_fds[0] = p2->p_pid;
                uap->sysmsg_fds[1] = 0;
        }
@@ -133,17 +133,17 @@ vfork(struct vfork_args *uap)
 int
 rfork(struct rfork_args *uap)
 {
-       struct proc *p = curproc;
+       struct lwp *lp = curthread->td_lwp;
        struct proc *p2;
        int error;
 
        if ((uap->flags & RFKERNELONLY) != 0)
                return (EINVAL);
 
-       error = fork1(p, uap->flags, &p2);
+       error = fork1(lp, uap->flags, &p2);
        if (error == 0) {
                if (p2)
-                       start_forked_proc(p, p2);
+                       start_forked_proc(lp, p2);
                uap->sysmsg_fds[0] = p2 ? p2->p_pid : 0;
                uap->sysmsg_fds[1] = 0;
        }
@@ -187,9 +187,11 @@ SYSCTL_PROC(_kern, OID_AUTO, randompid, CTLTYPE_INT|CTLFLAG_RW,
     0, 0, sysctl_kern_randompid, "I", "Random PID modulus");
 
 int
-fork1(struct proc *p1, int flags, struct proc **procp)
+fork1(struct lwp *lp1, int flags, struct proc **procp)
 {
+       struct proc *p1 = lp1->lwp_proc;
        struct proc *p2, *pptr;
+       struct lwp *lp2;
        uid_t uid;
        struct proc *newproc;
        int ok;
@@ -294,9 +296,10 @@ fork1(struct proc *p1, int flags, struct proc **procp)
        LIST_INIT(&newproc->p_lwps);
 
        /* XXX lwp */
-       LIST_INSERT_HEAD(&newproc->p_lwps, &newproc->p_lwp, lwp_list);
-       newproc->p_lwp.lwp_proc = newproc;
-       newproc->p_lwp.lwp_tid = 0;
+       lp2 = &newproc->p_lwp;
+       lp2->lwp_proc = newproc;
+       lp2->lwp_tid = 0;
+       LIST_INSERT_HEAD(&newproc->p_lwps, lp2, lwp_list);
        newproc->p_nthreads = 1;
 
        /*
@@ -366,14 +369,14 @@ again:
         */
        bzero(&p2->p_startzero,
            (unsigned) ((caddr_t)&p2->p_endzero - (caddr_t)&p2->p_startzero));
-       bzero(&p2->p_lwp.lwp_startzero,
-           (unsigned) ((caddr_t)&p2->p_lwp.lwp_endzero -
-                       (caddr_t)&p2->p_lwp.lwp_startzero));
+       bzero(&lp2->lwp_startzero,
+           (unsigned) ((caddr_t)&lp2->lwp_endzero -
+                       (caddr_t)&lp2->lwp_startzero));
        bcopy(&p1->p_startcopy, &p2->p_startcopy,
            (unsigned) ((caddr_t)&p2->p_endcopy - (caddr_t)&p2->p_startcopy));
-       bcopy(&p1->p_lwp.lwp_startcopy, &p2->p_lwp.lwp_startcopy,
-           (unsigned) ((caddr_t)&p2->p_lwp.lwp_endcopy -
-                       (caddr_t)&p2->p_lwp.lwp_startcopy));
+       bcopy(&p1->p_lwp.lwp_startcopy, &lp2->lwp_startcopy,
+           (unsigned) ((caddr_t)&lp2->lwp_endcopy -
+                       (caddr_t)&lp2->lwp_startcopy));
 
        p2->p_aioinfo = NULL;
 
@@ -527,9 +530,9 @@ again:
         * timeout).
         */
        p2->p_usched = p1->p_usched;
-       p2->p_cpbase = mycpu->gd_schedclock.time - 
+       lp2->lwp_cpbase = mycpu->gd_schedclock.time -
                        mycpu->gd_schedclock.periodic;
-       p2->p_usched->heuristic_forking(p1, p2);
+       p2->p_usched->heuristic_forking(&p1->p_lwp, lp2);
 
        /*
         * This begins the section where we must prevent the parent
@@ -637,8 +640,14 @@ rm_at_fork(forklist_fn function)
  * as setting the fork handler, has been completed.
  */
 void
-start_forked_proc(struct proc *p1, struct proc *p2)
+start_forked_proc(struct lwp *lp1, struct proc *p2)
 {
+       struct lwp *lp2;
+
+       KKASSERT(p2 != NULL && p2->p_nthreads == 1);
+
+       lp2 = LIST_FIRST(&p2->p_lwps);
+
        /*
         * Move from SIDL to RUN queue, and activate the process's thread.
         * Activation of the thread effectively makes the process "a"
@@ -648,18 +657,18 @@ start_forked_proc(struct proc *p1, struct proc *p2)
         * code so we just schedule the LWKT thread and let the trampoline
         * deal with the userland scheduler on return to userland.
         */
-       KASSERT(p2 && p2->p_stat == SIDL,
+       KASSERT(p2->p_stat == SIDL,
            ("cannot start forked process, bad status: %p", p2));
-       p2->p_usched->resetpriority(p2);
+       p2->p_usched->resetpriority(lp2);
        crit_enter();
        p2->p_stat = SRUN;
-       p2->p_usched->setrunqueue(p2);
+       p2->p_usched->setrunqueue(lp2);
        crit_exit();
 
        /*
         * Now can be swapped.
         */
-       PRELE(p1);
+       PRELE(lp1->lwp_proc);
 
        /*
         * Preserve synchronization semantics of vfork.  If waiting for
@@ -667,6 +676,5 @@ start_forked_proc(struct proc *p1, struct proc *p2)
         * proc (in case of exit).
         */
        while (p2->p_flag & P_PPWAIT)
-               tsleep(p1, 0, "ppwait", 0);
+               tsleep(lp1->lwp_proc, 0, "ppwait", 0);
 }
-
index 83dd4d5..f7f11e6 100644 (file)
@@ -37,7 +37,7 @@
  *
  *     @(#)kern_resource.c     8.5 (Berkeley) 1/21/94
  * $FreeBSD: src/sys/kern/kern_resource.c,v 1.55.2.5 2001/11/03 01:41:08 ps Exp $
- * $DragonFly: src/sys/kern/kern_resource.c,v 1.22 2005/06/25 20:03:28 dillon Exp $
+ * $DragonFly: src/sys/kern/kern_resource.c,v 1.23 2005/10/11 09:59:56 corecode Exp $
  */
 
 #include "opt_compat.h"
@@ -204,7 +204,7 @@ donice(struct proc *chgp, int n)
        if (n < chgp->p_nice && suser_cred(cr, 0))
                return (EACCES);
        chgp->p_nice = n;
-       chgp->p_usched->resetpriority(chgp);
+       chgp->p_usched->resetpriority(&chgp->p_lwp);
        return (0);
 }
 
index 087cd4a..e947d93 100644 (file)
@@ -37,7 +37,7 @@
  *
  *     @(#)kern_sig.c  8.7 (Berkeley) 4/18/94
  * $FreeBSD: src/sys/kern/kern_sig.c,v 1.72.2.17 2003/05/16 16:34:34 obrien Exp $
- * $DragonFly: src/sys/kern/kern_sig.c,v 1.37 2005/06/06 15:02:28 dillon Exp $
+ * $DragonFly: src/sys/kern/kern_sig.c,v 1.38 2005/10/11 09:59:56 corecode Exp $
  */
 
 #include "opt_ktrace.h"
@@ -769,6 +769,7 @@ trapsignal(struct proc *p, int sig, u_long code)
 void
 psignal(struct proc *p, int sig)
 {
+       struct lwp *lp = &p->p_lwp;
        int prop;
        sig_t action;
 
@@ -963,7 +964,7 @@ psignal(struct proc *p, int sig)
                 * the new signal.  YYY needs cleanup.
                 */
 #ifdef SMP
-               if (p == lwkt_preempted_proc()) {
+               if (lp == lwkt_preempted_proc()) {
                        signotify();
                } else if (p->p_stat == SRUN) {
                        struct thread *td = p->p_thread;
@@ -973,12 +974,12 @@ psignal(struct proc *p, int sig)
                            p->p_pid, p->p_stat, p->p_flag));
 
                        if (td->td_gd != mycpu)
-                               lwkt_send_ipiq(td->td_gd, signotify_remote, p);
+                               lwkt_send_ipiq(td->td_gd, signotify_remote, lp);
                        else if (td->td_msgport.mp_flags & MSGPORTF_WAITING)
                                lwkt_schedule(td);
                }
 #else
-               if (p == lwkt_preempted_proc()) {
+               if (lp == lwkt_preempted_proc()) {
                        signotify();
                } else if (p->p_stat == SRUN) {
                        struct thread *td = p->p_thread;
@@ -1010,12 +1011,12 @@ out:
 static void
 signotify_remote(void *arg)
 {
-       struct proc *p = arg;
+       struct lwp *lp = arg;
 
-       if (p == lwkt_preempted_proc()) {
+       if (lp == lwkt_preempted_proc()) {
                signotify();
        } else {
-               struct thread *td = p->p_thread;
+               struct thread *td = lp->lwp_thread;
                if (td->td_msgport.mp_flags & MSGPORTF_WAITING)
                        lwkt_schedule(td);
        }
index 94c1731..75d8f93 100644 (file)
@@ -37,7 +37,7 @@
  *
  *     @(#)kern_synch.c        8.9 (Berkeley) 5/19/95
  * $FreeBSD: src/sys/kern/kern_synch.c,v 1.87.2.6 2002/10/13 07:29:53 kbyanc Exp $
- * $DragonFly: src/sys/kern/kern_synch.c,v 1.47 2005/06/27 18:37:57 dillon Exp $
+ * $DragonFly: src/sys/kern/kern_synch.c,v 1.48 2005/10/11 09:59:56 corecode Exp $
  */
 
 #include "opt_ktrace.h"
@@ -172,7 +172,7 @@ schedcpu(void *arg)
                 * less then 2 seconds.  The schedulers understand this.
                 */
                if (p->p_slptime <= 1) {
-                       p->p_usched->recalculate(p);
+                       p->p_usched->recalculate(&p->p_lwp);
                } else {
                        p->p_pctcpu = (p->p_pctcpu * ccpu) >> FSHIFT;
                }
@@ -187,17 +187,17 @@ schedcpu(void *arg)
  * a period of one second.
  */
 void
-updatepcpu(struct proc *p, int cpticks, int ttlticks)
+updatepcpu(struct lwp *lp, int cpticks, int ttlticks)
 {
        fixpt_t acc;
        int remticks;
 
        acc = (cpticks << FSHIFT) / ttlticks;
        if (ttlticks >= ESTCPUFREQ) {
-               p->p_pctcpu = acc;
+               lp->lwp_pctcpu = acc;
        } else {
                remticks = ESTCPUFREQ - ttlticks;
-               p->p_pctcpu = (acc * ttlticks + p->p_pctcpu * remticks) /
+               lp->lwp_pctcpu = (acc * ttlticks + lp->lwp_pctcpu * remticks) /
                                ESTCPUFREQ;
        }
 }
@@ -284,7 +284,7 @@ tsleep(void *ident, int flags, const char *wmesg, int timo)
        if (p) {
                if (flags & PNORESCHED)
                        td->td_flags |= TDF_NORESCHED;
-               p->p_usched->release_curproc(p);
+               p->p_usched->release_curproc(&p->p_lwp);
                p->p_slptime = 0;
        }
        lwkt_deschedule_self(td);
@@ -609,7 +609,7 @@ clrrunnable(struct proc *p, int stat)
 {
        crit_enter_quick(p->p_thread);
        if (p->p_stat == SRUN && (p->p_flag & P_ONRUNQ))
-               p->p_usched->remrunqueue(p);
+               p->p_usched->remrunqueue(&p->p_lwp);
        p->p_stat = stat;
        crit_exit_quick(p->p_thread);
 }
index 8f232b4..168feed 100644 (file)
@@ -31,7 +31,7 @@
  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  * 
- * $DragonFly: src/sys/kern/kern_upcall.c,v 1.7 2005/10/09 20:12:34 corecode Exp $
+ * $DragonFly: src/sys/kern/kern_upcall.c,v 1.8 2005/10/11 09:59:56 corecode Exp $
  */
 
 /*
@@ -66,7 +66,7 @@ static void
 sigupcall_remote(void *arg)
 {
        struct lwp *lp = arg;
-       if (lp->lwp_proc == lwkt_preempted_proc())
+       if (lp == lwkt_preempted_proc())
                sigupcall();
 }
 
index ebb3a02..c970b55 100644 (file)
@@ -31,7 +31,7 @@
  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  * 
- * $DragonFly: src/sys/kern/lwkt_thread.c,v 1.82 2005/07/21 06:28:50 dillon Exp $
+ * $DragonFly: src/sys/kern/lwkt_thread.c,v 1.83 2005/10/11 09:59:56 corecode Exp $
  */
 
 /*
@@ -1236,13 +1236,13 @@ lwkt_setcpu_remote(void *arg)
 }
 #endif
 
-struct proc *
+struct lwp *
 lwkt_preempted_proc(void)
 {
     thread_t td = curthread;
     while (td->td_preempted)
        td = td->td_preempted;
-    return(td->td_proc);
+    return(td->td_lwp);
 }
 
 /*
index 62c8391..8f987b5 100644 (file)
@@ -23,7 +23,7 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- * $DragonFly: src/sys/kern/usched_bsd4.c,v 1.2 2005/09/27 18:03:32 dillon Exp $
+ * $DragonFly: src/sys/kern/usched_bsd4.c,v 1.3 2005/10/11 09:59:56 corecode Exp $
  */
 
 #include <sys/param.h>
 
 #define ESTCPULIM(v)   min((v), ESTCPUMAX)
 
-TAILQ_HEAD(rq, proc);
+TAILQ_HEAD(rq, lwp);
 
-#define p_priority     p_usdata.bsd4.priority
-#define p_rqindex      p_usdata.bsd4.rqindex
-#define p_origcpu      p_usdata.bsd4.origcpu
-#define p_estcpu       p_usdata.bsd4.estcpu
+#define lwp_priority   lwp_usdata.bsd4.priority
+#define lwp_rqindex    lwp_usdata.bsd4.rqindex
+#define lwp_origcpu    lwp_usdata.bsd4.origcpu
+#define lwp_estcpu     lwp_usdata.bsd4.estcpu
 
-static void bsd4_acquire_curproc(struct proc *p);
-static void bsd4_release_curproc(struct proc *p);
+static void bsd4_acquire_curproc(struct lwp *lp);
+static void bsd4_release_curproc(struct lwp *lp);
 static void bsd4_select_curproc(globaldata_t gd);
-static void bsd4_setrunqueue(struct proc *p);
-static void bsd4_remrunqueue(struct proc *p);
-static void bsd4_schedulerclock(struct proc *p, sysclock_t period,
+static void bsd4_setrunqueue(struct lwp *lp);
+static void bsd4_remrunqueue(struct lwp *lp);
+static void bsd4_schedulerclock(struct lwp *lp, sysclock_t period,
                                sysclock_t cpstamp);
-static void bsd4_resetpriority(struct proc *p);
-static void bsd4_forking(struct proc *pp, struct proc *p);
-static void bsd4_exiting(struct proc *pp, struct proc *p);
+static void bsd4_resetpriority(struct lwp *lp);
+static void bsd4_forking(struct lwp *plp, struct lwp *lp);
+static void bsd4_exiting(struct lwp *plp, struct lwp *lp);
 
-static void bsd4_recalculate_estcpu(struct proc *p);
+static void bsd4_recalculate_estcpu(struct lwp *lp);
 
 struct usched usched_bsd4 = {
        { NULL },
@@ -195,10 +195,10 @@ SYSINIT(runqueue, SI_SUB_RUN_QUEUE, SI_ORDER_FIRST, rqinit, NULL)
  * bounce between processes trying to acquire the current process designation.
  */
 static
-struct proc *
-chooseproc(struct proc *chkp)
+struct lwp *
+chooseproc(struct lwp *chklp)
 {
-       struct proc *p;
+       struct lwp *lp;
        struct rq *q;
        u_int32_t *which;
        u_int32_t pri;
@@ -218,45 +218,45 @@ chooseproc(struct proc *chkp)
        } else {
                return NULL;
        }
-       p = TAILQ_FIRST(q);
-       KASSERT(p, ("chooseproc: no proc on busy queue"));
+       lp = TAILQ_FIRST(q);
+       KASSERT(lp, ("chooseproc: no lwp on busy queue"));
 
        /*
-        * If the passed process <chkp> is reasonably close to the selected
-        * processed <p>, return NULL (indicating that <chkp> should be kept).
+        * If the passed lwp <chklp> is reasonably close to the selected
+        * lwp <lp>, return NULL (indicating that <chklp> should be kept).
         * 
-        * Note that we must error on the side of <chkp> to avoid bouncing
+        * Note that we must error on the side of <chklp> to avoid bouncing
         * between threads in the acquire code.
         */
-       if (chkp) {
-               if (chkp->p_priority < p->p_priority + PPQ)
+       if (chklp) {
+               if (chklp->lwp_priority < lp->lwp_priority + PPQ)
                        return(NULL);
        }
 
 #ifdef SMP
        /*
-        * If the chosen process does not reside on this cpu spend a few
+        * If the chosen lwp does not reside on this cpu spend a few
         * cycles looking for a better candidate at the same priority level.
         * This is a fallback check, setrunqueue() tries to wakeup the
         * correct cpu and is our front-line affinity.
         */
-       if (p->p_thread->td_gd != mycpu &&
-           (chkp = TAILQ_NEXT(p, p_procq)) != NULL
+       if (lp->lwp_thread->td_gd != mycpu &&
+           (chklp = TAILQ_NEXT(lp, lwp_procq)) != NULL
        ) {
-               if (chkp->p_thread->td_gd == mycpu) {
+               if (chklp->lwp_thread->td_gd == mycpu) {
                        ++choose_affinity;
-                       p = chkp;
+                       lp = chklp;
                }
        }
 #endif
 
-       TAILQ_REMOVE(q, p, p_procq);
+       TAILQ_REMOVE(q, lp, lwp_procq);
        --runqcount;
        if (TAILQ_EMPTY(q))
                *which &= ~(1 << pri);
-       KASSERT((p->p_flag & P_ONRUNQ) != 0, ("not on runq6!"));
-       p->p_flag &= ~P_ONRUNQ;
-       return p;
+       KASSERT((lp->lwp_proc->p_flag & P_ONRUNQ) != 0, ("not on runq6!"));
+       lp->lwp_proc->p_flag &= ~P_ONRUNQ;
+       return lp;
 }
 
 #ifdef SMP
@@ -305,7 +305,7 @@ need_user_resched_remote(void *dummy)
  * This must be called at splhigh().
  */
 static void
-bsd4_setrunqueue(struct proc *p)
+bsd4_setrunqueue(struct lwp *lp)
 {
        struct rq *q;
        struct globaldata *gd;
@@ -318,15 +318,16 @@ bsd4_setrunqueue(struct proc *p)
 #endif
 
        crit_enter();
-       KASSERT(p->p_stat == SRUN, ("setrunqueue: proc not SRUN"));
-       KASSERT((p->p_flag & P_ONRUNQ) == 0,
-           ("process %d already on runq! flag %08x", p->p_pid, p->p_flag));
-       KKASSERT((p->p_thread->td_flags & TDF_RUNQ) == 0);
+       KASSERT(lp->lwp_proc->p_stat == SRUN, ("setrunqueue: proc not SRUN"));
+       KASSERT((lp->lwp_proc->p_flag & P_ONRUNQ) == 0,
+           ("lwp %d/%d already on runq! flag %08x", lp->lwp_proc->p_pid,
+            lp->lwp_tid, lp->lwp_proc->p_flag));
+       KKASSERT((lp->lwp_thread->td_flags & TDF_RUNQ) == 0);
 
        /*
         * Note: gd is the gd of the TARGET thread's cpu, not our cpu.
         */
-       gd = p->p_thread->td_gd;
+       gd = lp->lwp_thread->td_gd;
 
        /*
         * Because recalculate is only called once or twice for long sleeps,
@@ -335,15 +336,15 @@ bsd4_setrunqueue(struct proc *p)
         * will wrap if the process was sleeping long enough (e.g. ~10 min
         * with the ACPI timer) and really mess up the nticks calculation.
         */
-       if (p->p_slptime) {
-           bsd4_recalculate_estcpu(p);
-           p->p_slptime = 0;
+       if (lp->lwp_slptime) {
+           bsd4_recalculate_estcpu(lp);
+           lp->lwp_slptime = 0;
        }
        /*
         * We have not been released, make sure that we are not the currently
         * designated process.
         */
-       KKASSERT(gd->gd_uschedcp != p);
+       KKASSERT(gd->gd_uschedcp != lp);
 
        /*
         * Check cpu affinity.  The associated thread is stable at the
@@ -357,9 +358,9 @@ bsd4_setrunqueue(struct proc *p)
 
        if ((curprocmask & (1 << cpuid)) == 0) {
                curprocmask |= 1 << cpuid;
-               gd->gd_uschedcp = p;
-               gd->gd_upri = p->p_priority;
-               lwkt_schedule(p->p_thread);
+               gd->gd_uschedcp = lp;
+               gd->gd_upri = lp->lwp_priority;
+               lwkt_schedule(lp->lwp_thread);
                /* CANNOT TOUCH PROC OR TD AFTER SCHEDULE CALL TO REMOTE CPU */
                crit_exit();
 #ifdef SMP
@@ -375,20 +376,20 @@ bsd4_setrunqueue(struct proc *p)
         * action by the target cpu.
         */
        ++runqcount;
-       p->p_flag |= P_ONRUNQ;
-       if (p->p_rtprio.type == RTP_PRIO_NORMAL) {
-               pri = (p->p_priority & PRIMASK) / PPQ;
+       lp->lwp_proc->p_flag |= P_ONRUNQ;
+       if (lp->lwp_rtprio.type == RTP_PRIO_NORMAL) {
+               pri = (lp->lwp_priority & PRIMASK) / PPQ;
                q = &queues[pri];
                queuebits |= 1 << pri;
                needresched = (queuebits & ((1 << pri) - 1));
-       } else if (p->p_rtprio.type == RTP_PRIO_REALTIME ||
-                  p->p_rtprio.type == RTP_PRIO_FIFO) {
-               pri = (u_int8_t)p->p_rtprio.prio;
+       } else if (lp->lwp_rtprio.type == RTP_PRIO_REALTIME ||
+                  lp->lwp_rtprio.type == RTP_PRIO_FIFO) {
+               pri = (u_int8_t)lp->lwp_rtprio.prio;
                q = &rtqueues[pri];
                rtqueuebits |= 1 << pri;
                needresched = (rtqueuebits & ((1 << pri) - 1));
-       } else if (p->p_rtprio.type == RTP_PRIO_IDLE) {
-               pri = (u_int8_t)p->p_rtprio.prio;
+       } else if (lp->lwp_rtprio.type == RTP_PRIO_IDLE) {
+               pri = (u_int8_t)lp->lwp_rtprio.prio;
                q = &idqueues[pri];
                idqueuebits |= 1 << pri;
                needresched = (idqueuebits & ((1 << pri) - 1));
@@ -397,8 +398,8 @@ bsd4_setrunqueue(struct proc *p)
                panic("setrunqueue: invalid rtprio type");
        }
        KKASSERT(pri < 32);
-       p->p_rqindex = pri;             /* remember the queue index */
-       TAILQ_INSERT_TAIL(q, p, p_procq);
+       lp->lwp_rqindex = pri;          /* remember the queue index */
+       TAILQ_INSERT_TAIL(q, lp, lwp_procq);
 
 #ifdef SMP
        /*
@@ -417,21 +418,21 @@ bsd4_setrunqueue(struct proc *p)
         * another cpu's gd_upri to avoid sending ipiq storms).
         */
        if (gd == mycpu) {
-               if ((p->p_thread->td_flags & TDF_NORESCHED) == 0) {
-                       if (p->p_priority < gd->gd_upri - PPQ) {
-                               gd->gd_upri = p->p_priority;
+               if ((lp->lwp_thread->td_flags & TDF_NORESCHED) == 0) {
+                       if (lp->lwp_priority < gd->gd_upri - PPQ) {
+                               gd->gd_upri = lp->lwp_priority;
                                gd->gd_rrcount = 0;
                                need_user_resched();
                                --count;
-                       } else if (gd->gd_uschedcp == p && needresched) {
+                       } else if (gd->gd_uschedcp == lp && needresched) {
                                gd->gd_rrcount = 0;
                                need_user_resched();
                                --count;
                        }
                }
        } else if (remote_resched) {
-               if (p->p_priority < gd->gd_upri - PPQ) {
-                       gd->gd_upri = p->p_priority;
+               if (lp->lwp_priority < gd->gd_upri - PPQ) {
+                       gd->gd_upri = lp->lwp_priority;
                        lwkt_send_ipiq(gd, need_user_resched_remote, NULL);
                        --count;
                        ++remote_resched_affinity;
@@ -444,9 +445,10 @@ bsd4_setrunqueue(struct proc *p)
         */
        if (count &&
            (mask = ~curprocmask & rdyprocmask & mycpu->gd_other_cpus) != 0 &&
-           (p->p_flag & P_PASSIVE_ACQ) == 0) {
+           (lp->lwp_proc->p_flag & P_PASSIVE_ACQ) == 0) {
                if (!mask)
-                       printf("PROC %d nocpu to schedule it on\n", p->p_pid);
+                       printf("lwp %d/%d nocpu to schedule it on\n",
+                              lp->lwp_proc->p_pid, lp->lwp_tid);
                while (mask && count) {
                        cpuid = bsfl(mask);
                        KKASSERT((curprocmask & (1 << cpuid)) == 0);
@@ -484,20 +486,20 @@ bsd4_setrunqueue(struct proc *p)
                if (rdyprocmask & (1 << cpuid)) {
                        gd = globaldata_find(cpuid);
 
-                       if (p->p_priority < gd->gd_upri - PPQ) {
-                               gd->gd_upri = p->p_priority;
+                       if (lp->lwp_priority < gd->gd_upri - PPQ) {
+                               gd->gd_upri = lp->lwp_priority;
                                lwkt_send_ipiq(gd, need_user_resched_remote, NULL);
                                ++remote_resched_nonaffinity;
                        }
                }
        }
 #else
-       if ((p->p_thread->td_flags & TDF_NORESCHED) == 0) {
-               if (p->p_priority < gd->gd_upri - PPQ) {
-                       gd->gd_upri = p->p_priority;
+       if ((lp->lwp_thread->td_flags & TDF_NORESCHED) == 0) {
+               if (lp->lwp_priority < gd->gd_upri - PPQ) {
+                       gd->gd_upri = lp->lwp_priority;
                        gd->gd_rrcount = 0;
                        need_user_resched();
-               } else if (gd->gd_uschedcp == p && needresched) {
+               } else if (gd->gd_uschedcp == lp && needresched) {
                        gd->gd_rrcount = 0;
                        need_user_resched();
                }
@@ -518,32 +520,32 @@ bsd4_setrunqueue(struct proc *p)
  * This must be called at splhigh().
  */
 static void
-bsd4_remrunqueue(struct proc *p)
+bsd4_remrunqueue(struct lwp *lp)
 {
        struct rq *q;
        u_int32_t *which;
        u_int8_t pri;
 
        crit_enter();
-       KASSERT((p->p_flag & P_ONRUNQ) != 0, ("not on runq4!"));
-       p->p_flag &= ~P_ONRUNQ;
+       KASSERT((lp->lwp_proc->p_flag & P_ONRUNQ) != 0, ("not on runq4!"));
+       lp->lwp_proc->p_flag &= ~P_ONRUNQ;
        --runqcount;
        KKASSERT(runqcount >= 0);
-       pri = p->p_rqindex;
-       if (p->p_rtprio.type == RTP_PRIO_NORMAL) {
+       pri = lp->lwp_rqindex;
+       if (lp->lwp_rtprio.type == RTP_PRIO_NORMAL) {
                q = &queues[pri];
                which = &queuebits;
-       } else if (p->p_rtprio.type == RTP_PRIO_REALTIME ||
-                  p->p_rtprio.type == RTP_PRIO_FIFO) {
+       } else if (lp->lwp_rtprio.type == RTP_PRIO_REALTIME ||
+                  lp->lwp_rtprio.type == RTP_PRIO_FIFO) {
                q = &rtqueues[pri];
                which = &rtqueuebits;
-       } else if (p->p_rtprio.type == RTP_PRIO_IDLE) {
+       } else if (lp->lwp_rtprio.type == RTP_PRIO_IDLE) {
                q = &idqueues[pri];
                which = &idqueuebits;
        } else {
                panic("remrunqueue: invalid rtprio type");
        }
-       TAILQ_REMOVE(q, p, p_procq);
+       TAILQ_REMOVE(q, lp, lwp_procq);
        if (TAILQ_EMPTY(q)) {
                KASSERT((*which & (1 << pri)) != 0,
                        ("remrunqueue: remove from empty queue"));
@@ -558,7 +560,7 @@ bsd4_remrunqueue(struct proc *p)
  */
 static
 void
-bsd4_schedulerclock(struct proc *p, sysclock_t period, sysclock_t cpstamp)
+bsd4_schedulerclock(struct lwp *lp, sysclock_t period, sysclock_t cpstamp)
 {
        globaldata_t gd = mycpu;
 
@@ -576,19 +578,19 @@ bsd4_schedulerclock(struct proc *p, sysclock_t period, sysclock_t cpstamp)
         * push the process into another scheduling queue.  It typically
         * takes 4 ticks to bump the queue.
         */
-       p->p_estcpu = ESTCPULIM(p->p_estcpu + ESTCPUINCR);
+       lp->lwp_estcpu = ESTCPULIM(lp->lwp_estcpu + ESTCPUINCR);
 
        /*
         * Reducing p_origcpu over time causes more of our estcpu to be
         * returned to the parent when we exit.  This is a small tweak
         * for the batch detection heuristic.
         */
-       if (p->p_origcpu)
-               --p->p_origcpu;
+       if (lp->lwp_origcpu)
+               --lp->lwp_origcpu;
 
        /* XXX optimize, avoid lock if no reset is required */
        if (try_mplock()) {
-               bsd4_resetpriority(p);
+               bsd4_resetpriority(lp);
                rel_mplock();
        }
 }
@@ -610,20 +612,20 @@ bsd4_schedulerclock(struct proc *p, sysclock_t period, sysclock_t cpstamp)
  * useable.
  */
 static void
-bsd4_release_curproc(struct proc *p)
+bsd4_release_curproc(struct lwp *lp)
 {
        int cpuid;
        globaldata_t gd = mycpu;
 
-       KKASSERT(p->p_thread->td_gd == gd);
+       KKASSERT(lp->lwp_thread->td_gd == gd);
        crit_enter();
        cpuid = gd->gd_cpuid;
 
-       if (gd->gd_uschedcp == p) {
+       if (gd->gd_uschedcp == lp) {
                if (try_mplock()) {
                        /* 
                         * YYY when the MP lock is not assumed (see else) we
-                        * will have to check that gd_uschedcp is still == p
+                        * will have to check that gd_uschedcp is still == lp
                         * after acquisition of the MP lock
                         */
                        gd->gd_uschedcp = NULL;
@@ -660,7 +662,7 @@ static
 void
 bsd4_select_curproc(globaldata_t gd)
 {
-       struct proc *np;
+       struct lwp *nlp;
        int cpuid = gd->gd_cpuid;
        void *old;
 
@@ -675,18 +677,18 @@ bsd4_select_curproc(globaldata_t gd)
         * We do not clear the user resched request here,
         * we need to test it later when we re-acquire.
         *
-        * NOTE: chooseproc returns NULL if the chosen proc
+        * NOTE: chooseproc returns NULL if the chosen lwp
         * is gd_uschedcp. XXX needs cleanup.
         */
        old = gd->gd_uschedcp;
-       if ((np = chooseproc(gd->gd_uschedcp)) != NULL) {
+       if ((nlp = chooseproc(gd->gd_uschedcp)) != NULL) {
                curprocmask |= 1 << cpuid;
-               gd->gd_upri = np->p_priority;
-               gd->gd_uschedcp = np;
-               lwkt_acquire(np->p_thread);
-               lwkt_schedule(np->p_thread);
+               gd->gd_upri = nlp->lwp_priority;
+               gd->gd_uschedcp = nlp;
+               lwkt_acquire(nlp->lwp_thread);
+               lwkt_schedule(nlp->lwp_thread);
        } else if (gd->gd_uschedcp) {
-               gd->gd_upri = gd->gd_uschedcp->p_priority;
+               gd->gd_upri = gd->gd_uschedcp->lwp_priority;
                KKASSERT(curprocmask & (1 << cpuid));
        } else if (runqcount && (rdyprocmask & (1 << cpuid))) {
                /*gd->gd_uschedcp = NULL;*/
@@ -702,35 +704,35 @@ bsd4_select_curproc(globaldata_t gd)
 /*
  * Acquire the current process designation on the CURRENT process only.
  * This function is called at kernel-user priority (not userland priority)
- * when curproc does not match gd_uschedcp.
+ * when curlwp does not match gd_uschedcp.
  *
  * Basically we recalculate our estcpu to hopefully give us a more
- * favorable disposition, setrunqueue, then wait for the curproc
+ * favorable disposition, setrunqueue, then wait for the curlwp
  * designation to be handed to us (if the setrunqueue didn't do it).
  */
 static void
-bsd4_acquire_curproc(struct proc *p)
+bsd4_acquire_curproc(struct lwp *lp)
 {
        globaldata_t gd = mycpu;
 
        crit_enter();
-       ++p->p_stats->p_ru.ru_nivcsw;
+       ++lp->lwp_stats->p_ru.ru_nivcsw;
 
        /*
         * Loop until we become the current process.  
         */
        do {
-               KKASSERT(p == gd->gd_curthread->td_proc);
-               bsd4_recalculate_estcpu(p);
+               KKASSERT(lp == gd->gd_curthread->td_lwp);
+               bsd4_recalculate_estcpu(lp);
                lwkt_deschedule_self(gd->gd_curthread);
-               bsd4_setrunqueue(p);
+               bsd4_setrunqueue(lp);
                lwkt_switch();
 
                /*
                 * WE MAY HAVE BEEN MIGRATED TO ANOTHER CPU, RELOAD GD.
                 */
                gd = mycpu;
-       } while (gd->gd_uschedcp != p);
+       } while (gd->gd_uschedcp != lp);
 
        crit_exit();
 
@@ -738,7 +740,7 @@ bsd4_acquire_curproc(struct proc *p)
         * That's it.  Cleanup, we are done.  The caller can return to
         * user mode now.
         */
-       KKASSERT((p->p_flag & P_ONRUNQ) == 0);
+       KKASSERT((lp->lwp_proc->p_flag & P_ONRUNQ) == 0);
 }
 
 /*
@@ -747,7 +749,7 @@ bsd4_acquire_curproc(struct proc *p)
  * than that of the current process.
  */
 static void
-bsd4_resetpriority(struct proc *p)
+bsd4_resetpriority(struct lwp *lp)
 {
        int newpriority;
        int opq;
@@ -756,17 +758,17 @@ bsd4_resetpriority(struct proc *p)
        /*
         * Set p_priority for general process comparisons
         */
-       switch(p->p_rtprio.type) {
+       switch(lp->lwp_rtprio.type) {
        case RTP_PRIO_REALTIME:
-               p->p_priority = PRIBASE_REALTIME + p->p_rtprio.prio;
+               lp->lwp_priority = PRIBASE_REALTIME + lp->lwp_rtprio.prio;
                return;
        case RTP_PRIO_NORMAL:
                break;
        case RTP_PRIO_IDLE:
-               p->p_priority = PRIBASE_IDLE + p->p_rtprio.prio;
+               lp->lwp_priority = PRIBASE_IDLE + lp->lwp_rtprio.prio;
                return;
        case RTP_PRIO_THREAD:
-               p->p_priority = PRIBASE_THREAD + p->p_rtprio.prio;
+               lp->lwp_priority = PRIBASE_THREAD + lp->lwp_rtprio.prio;
                return;
        }
 
@@ -784,29 +786,29 @@ bsd4_resetpriority(struct proc *p)
         * estcpu range into the priority range so the actual PPQ value
         * is incorrect, but it's still a reasonable way to think about it.
         */
-       newpriority = (p->p_nice - PRIO_MIN) * PPQ / NICEPPQ;
-       newpriority += p->p_estcpu * PPQ / ESTCPUPPQ;
+       newpriority = (lp->lwp_proc->p_nice - PRIO_MIN) * PPQ / NICEPPQ;
+       newpriority += lp->lwp_estcpu * PPQ / ESTCPUPPQ;
        newpriority = newpriority * MAXPRI /
                    (PRIO_RANGE * PPQ / NICEPPQ + ESTCPUMAX * PPQ / ESTCPUPPQ);
        newpriority = MIN(newpriority, MAXPRI - 1);     /* sanity */
        newpriority = MAX(newpriority, 0);              /* sanity */
        npq = newpriority / PPQ;
        crit_enter();
-       opq = (p->p_priority & PRIMASK) / PPQ;
-       if (p->p_stat == SRUN && (p->p_flag & P_ONRUNQ) && opq != npq) {
+       opq = (lp->lwp_priority & PRIMASK) / PPQ;
+       if (lp->lwp_proc->p_stat == SRUN && (lp->lwp_proc->p_flag & P_ONRUNQ) && opq != npq) {
                /*
                 * We have to move the process to another queue
                 */
-               bsd4_remrunqueue(p);
-               p->p_priority = PRIBASE_NORMAL + newpriority;
-               bsd4_setrunqueue(p);
+               bsd4_remrunqueue(lp);
+               lp->lwp_priority = PRIBASE_NORMAL + newpriority;
+               bsd4_setrunqueue(lp);
        } else {
                /*
                 * We can just adjust the priority and it will be picked
                 * up later.
                 */
-               KKASSERT(opq == npq || (p->p_flag & P_ONRUNQ) == 0);
-               p->p_priority = PRIBASE_NORMAL + newpriority;
+               KKASSERT(opq == npq || (lp->lwp_proc->p_flag & P_ONRUNQ) == 0);
+               lp->lwp_priority = PRIBASE_NORMAL + newpriority;
        }
        crit_exit();
 }
@@ -821,13 +823,14 @@ bsd4_resetpriority(struct proc *p)
  *
  * Interactive processes will decay the boosted estcpu quickly while batch
  * processes will tend to compound it.
+ * XXX lwp should be "spawning" instead of "forking"
  */
 static void
-bsd4_forking(struct proc *pp, struct proc *p)
+bsd4_forking(struct lwp *plp, struct lwp *lp)
 {
-       p->p_estcpu = ESTCPULIM(pp->p_estcpu + ESTCPUPPQ);
-       p->p_origcpu = p->p_estcpu;
-       pp->p_estcpu = ESTCPULIM(pp->p_estcpu + ESTCPUPPQ);
+       lp->lwp_estcpu = ESTCPULIM(plp->lwp_estcpu + ESTCPUPPQ);
+       lp->lwp_origcpu = lp->lwp_estcpu;
+       plp->lwp_estcpu = ESTCPULIM(plp->lwp_estcpu + ESTCPUPPQ);
 }
 
 /*
@@ -835,14 +838,14 @@ bsd4_forking(struct proc *pp, struct proc *p)
  * back to the parent.
  */
 static void
-bsd4_exiting(struct proc *pp, struct proc *p)
+bsd4_exiting(struct lwp *plp, struct lwp *lp)
 {
        int delta;
 
-       if (pp->p_pid != 1) {
-               delta = p->p_estcpu - p->p_origcpu;
+       if (plp->lwp_proc->p_pid != 1) {
+               delta = lp->lwp_estcpu - lp->lwp_origcpu;
                if (delta > 0)
-                       pp->p_estcpu = ESTCPULIM(pp->p_estcpu + delta);
+                       plp->lwp_estcpu = ESTCPULIM(plp->lwp_estcpu + delta);
        }
 }
 
@@ -863,7 +866,7 @@ bsd4_exiting(struct proc *pp, struct proc *p)
  */
 static
 void 
-bsd4_recalculate_estcpu(struct proc *p)
+bsd4_recalculate_estcpu(struct lwp *lp)
 {
        globaldata_t gd = mycpu;
        sysclock_t cpbase;
@@ -881,15 +884,15 @@ bsd4_recalculate_estcpu(struct proc *p)
         */
        cpbase = gd->gd_schedclock.time - gd->gd_schedclock.periodic;
 
-       if (p->p_slptime > 1) {
+       if (lp->lwp_slptime > 1) {
                /*
                 * Too much time has passed, do a coarse correction.
                 */
-               p->p_estcpu = p->p_estcpu >> 1;
-               bsd4_resetpriority(p);
-               p->p_cpbase = cpbase;
-               p->p_cpticks = 0;
-       } else if (p->p_cpbase != cpbase) {
+               lp->lwp_estcpu = lp->lwp_estcpu >> 1;
+               bsd4_resetpriority(lp);
+               lp->lwp_cpbase = cpbase;
+               lp->lwp_cpticks = 0;
+       } else if (lp->lwp_cpbase != cpbase) {
                /*
                 * Adjust estcpu if we are in a different tick.  Don't waste
                 * time if we are in the same tick. 
@@ -897,15 +900,15 @@ bsd4_recalculate_estcpu(struct proc *p)
                 * First calculate the number of ticks in the measurement
                 * interval.
                 */
-               nticks = (cpbase - p->p_cpbase) / gd->gd_schedclock.periodic;
-               updatepcpu(p, p->p_cpticks, nticks);
+               nticks = (cpbase - lp->lwp_cpbase) / gd->gd_schedclock.periodic;
+               updatepcpu(lp, lp->lwp_cpticks, nticks);
 
-               if ((nleft = nticks - p->p_cpticks) < 0)
+               if ((nleft = nticks - lp->lwp_cpticks) < 0)
                        nleft = 0;
-               if (usched_debug == p->p_pid) {
-                       printf("pid %d estcpu %d cpticks %d nticks %d nleft %d",
-                               p->p_pid, p->p_estcpu,
-                               p->p_cpticks, nticks, nleft);
+               if (usched_debug == lp->lwp_proc->p_pid) {
+                       printf("pid %d tid %d estcpu %d cpticks %d nticks %d nleft %d",
+                               lp->lwp_proc->p_pid, lp->lwp_tid, lp->lwp_estcpu,
+                               lp->lwp_cpticks, nticks, nleft);
                }
 
                /*
@@ -915,24 +918,24 @@ bsd4_recalculate_estcpu(struct proc *p)
                if ((loadfac = runqcount) < 2)
                        loadfac = 2;
                ndecay = nleft * usched_bsd4_decay * 2 * 
-                       (PRIO_MAX * 2 - p->p_nice) / (loadfac * PRIO_MAX * 2);
+                       (PRIO_MAX * 2 - lp->lwp_proc->p_nice) / (loadfac * PRIO_MAX * 2);
 
                /*
                 * Adjust p_estcpu.  Handle a border case where batch jobs
                 * can get stalled long enough to decay to zero when they
                 * shouldn't.
                 */
-               if (p->p_estcpu > ndecay * 2)
-                       p->p_estcpu -= ndecay;
+               if (lp->lwp_estcpu > ndecay * 2)
+                       lp->lwp_estcpu -= ndecay;
                else
-                       p->p_estcpu >>= 1;
+                       lp->lwp_estcpu >>= 1;
 
-               if (usched_debug == p->p_pid)
-                       printf(" ndecay %d estcpu %d\n", ndecay, p->p_estcpu);
+               if (usched_debug == lp->lwp_proc->p_pid)
+                       printf(" ndecay %d estcpu %d\n", ndecay, lp->lwp_estcpu);
 
-               bsd4_resetpriority(p);
-               p->p_cpbase = cpbase;
-               p->p_cpticks = 0;
+               bsd4_resetpriority(lp);
+               lp->lwp_cpbase = cpbase;
+               lp->lwp_cpticks = 0;
        }
 }
 
@@ -955,17 +958,17 @@ sched_thread(void *dummy)
 
     get_mplock();                      /* hold the MP lock */
     for (;;) {
-       struct proc *np;
+       struct lwp *nlp;
 
        lwkt_deschedule_self(gd->gd_curthread); /* interlock */
        rdyprocmask |= cpumask;
        crit_enter_quick(gd->gd_curthread);
-       if ((curprocmask & cpumask) == 0 && (np = chooseproc(NULL)) != NULL) {
+       if ((curprocmask & cpumask) == 0 && (nlp = chooseproc(NULL)) != NULL) {
            curprocmask |= cpumask;
-           gd->gd_upri = np->p_priority;
-           gd->gd_uschedcp = np;
-           lwkt_acquire(np->p_thread);
-           lwkt_schedule(np->p_thread);
+           gd->gd_upri = nlp->lwp_priority;
+           gd->gd_uschedcp = nlp;
+           lwkt_acquire(nlp->lwp_thread);
+           lwkt_schedule(nlp->lwp_thread);
        }
        crit_exit_quick(gd->gd_curthread);
        lwkt_switch();
index 2d1c718..6bb07f1 100644 (file)
@@ -14,7 +14,7 @@
  * of the author.  This software is distributed AS-IS.
  *
  * $FreeBSD: src/sys/kern/vfs_aio.c,v 1.70.2.28 2003/05/29 06:15:35 alc Exp $
- * $DragonFly: src/sys/kern/vfs_aio.c,v 1.18 2005/08/03 16:36:33 hmp Exp $
+ * $DragonFly: src/sys/kern/vfs_aio.c,v 1.19 2005/10/11 09:59:56 corecode Exp $
  */
 
 /*
@@ -871,14 +871,15 @@ static int
 aio_newproc()
 {
        int error;
-       struct proc *p, *np;
+       struct lwp *lp;
+       struct proc *np;
 
-       p = &proc0;
-       error = fork1(p, RFPROC|RFMEM|RFNOWAIT, &np);
+       lp = &proc0.p_lwp;
+       error = fork1(lp, RFPROC|RFMEM|RFNOWAIT, &np);
        if (error)
                return error;
        cpu_set_fork_handler(np, aio_daemon, curproc);
-       start_forked_proc(p, np);
+       start_forked_proc(lp, np);
 
        /*
         * Wait until daemon is started, but continue on just in case to
index d5d3ed0..60271ab 100644 (file)
@@ -30,7 +30,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/netsmb/smb_subr.c,v 1.1.2.2 2001/09/03 08:55:11 bp Exp $
- * $DragonFly: src/sys/netproto/smb/smb_subr.c,v 1.14 2005/03/02 19:14:51 dillon Exp $
+ * $DragonFly: src/sys/netproto/smb/smb_subr.c,v 1.15 2005/10/11 09:59:56 corecode Exp $
  */
 #include <sys/param.h>
 #include <sys/systm.h>
@@ -377,7 +377,7 @@ kthread_create2(void (*func)(void *), void *arg,
                panic("kthread_create called too soon");
        }
 
-       error = fork1(&proc0, RFMEM | RFFDG | RFPROC | flags, &p2);
+       error = fork1(&proc0.p_lwp, RFMEM | RFFDG | RFPROC | flags, &p2);
        if (error)
                return error;
 
@@ -396,7 +396,7 @@ kthread_create2(void (*func)(void *), void *arg,
 
        /* call the processes' main()... */
        cpu_set_fork_handler(p2, func, arg);
-       start_forked_proc(&proc0, p2);
+       start_forked_proc(&proc0.p_lwp, p2);
 
        return 0;
 }
index 9af1485..0318a34 100644 (file)
@@ -36,7 +36,7 @@
  *
  *     from: @(#)trap.c        7.4 (Berkeley) 5/13/91
  * $FreeBSD: src/sys/i386/i386/trap.c,v 1.147.2.11 2003/02/27 19:09:59 luoqi Exp $
- * $DragonFly: src/sys/platform/pc32/i386/trap.c,v 1.63 2005/10/09 21:38:04 corecode Exp $
+ * $DragonFly: src/sys/platform/pc32/i386/trap.c,v 1.64 2005/10/11 09:59:56 corecode Exp $
  */
 
 /*
@@ -182,11 +182,11 @@ extern int max_sysmsg;
 static void
 passive_release(struct thread *td)
 {
-       struct proc *p = td->td_proc;
+       struct lwp *lp = td->td_lwp;
 
        td->td_release = NULL;
        lwkt_setpri_self(TDPRI_KERN_USER);
-       p->p_usched->release_curproc(p);
+       lp->lwp_proc->p_usched->release_curproc(lp);
 }
 
 /*
@@ -253,7 +253,6 @@ userret(struct lwp *lp, struct trapframe *frame, int sticks)
 static __inline void
 userexit(struct lwp *lp)
 {
-       struct proc *p = lp->lwp_proc;
        struct thread *td = lp->lwp_thread;
        globaldata_t gd = td->td_gd;
 
@@ -264,7 +263,7 @@ userexit(struct lwp *lp)
         * be chosen again if it has a considerably better priority.
         */
        if (user_resched_wanted())
-               p->p_usched->release_curproc(p);
+               lp->lwp_proc->p_usched->release_curproc(lp);
 #endif
 
 again:
@@ -286,9 +285,9 @@ again:
         * to figure out which is the best of [ existing, waking-up ]
         * threads.
         */
-       if (p != gd->gd_uschedcp) {
+       if (lp != gd->gd_uschedcp) {
                ++slow_release;
-               p->p_usched->acquire_curproc(p);
+               lp->lwp_proc->p_usched->acquire_curproc(lp);
                /* We may have switched cpus on acquisition */
                gd = td->td_gd;
        } else {
@@ -320,8 +319,8 @@ again:
         * is pending the trap will be re-entered.
         */
        if (user_resched_wanted()) {
-               p->p_usched->select_curproc(gd);
-               if (p != gd->gd_uschedcp) {
+               lp->lwp_proc->p_usched->select_curproc(gd);
+               if (lp != gd->gd_uschedcp) {
                        lwkt_setpri_self(TDPRI_KERN_USER);
                        goto again;
                }
index fbf11e3..baf40dd 100644 (file)
@@ -25,7 +25,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/i386/i386/vm86.c,v 1.31.2.2 2001/10/05 06:18:55 peter Exp $
- * $DragonFly: src/sys/platform/pc32/i386/vm86.c,v 1.15 2005/10/07 21:55:15 corecode Exp $
+ * $DragonFly: src/sys/platform/pc32/i386/vm86.c,v 1.16 2005/10/11 09:59:56 corecode Exp $
  */
 
 #include <sys/param.h>
@@ -54,7 +54,7 @@
 #include <bus/isa/rtc.h>
 #include <i386/isa/timerreg.h>
 
-extern int i386_extend_pcb     (struct proc *);
+extern int i386_extend_pcb     (struct lwp *);
 extern int vm86pa;
 extern struct pcb *vm86pcb;
 
index 46ac64f..5efe130 100644 (file)
@@ -55,7 +55,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/i386/include/globaldata.h,v 1.11.2.1 2000/05/16 06:58:10 dillon Exp $
- * $DragonFly: src/sys/sys/globaldata.h,v 1.38 2005/08/29 17:46:52 dillon Exp $
+ * $DragonFly: src/sys/sys/globaldata.h,v 1.39 2005/10/11 09:59:56 corecode Exp $
  */
 
 #ifndef _SYS_GLOBALDATA_H_
@@ -159,7 +159,7 @@ struct globaldata {
        struct nchstats *gd_nchstats;           /* namecache effectiveness */
        int             gd_pipeqcount;          /* number of structures */
        lwkt_tokref_t   gd_tokreqbase;          /* requests from other cpus */
-       struct proc     *gd_uschedcp;           /* userland scheduler */
+       struct lwp      *gd_uschedcp;           /* userland scheduler */
        /* extended by <machine/globaldata.h> */
 };
 
index 1a66b53..0d5d883 100644 (file)
@@ -37,7 +37,7 @@
  *
  *     @(#)proc.h      8.15 (Berkeley) 5/19/95
  * $FreeBSD: src/sys/sys/proc.h,v 1.99.2.9 2003/06/06 20:21:32 tegge Exp $
- * $DragonFly: src/sys/sys/proc.h,v 1.69 2005/10/09 21:38:04 corecode Exp $
+ * $DragonFly: src/sys/sys/proc.h,v 1.70 2005/10/11 09:59:56 corecode Exp $
  */
 
 #ifndef _SYS_PROC_H_
@@ -132,9 +132,7 @@ struct      pargs {
 struct jail;
 
 struct lwp {
-#ifdef notyet
        TAILQ_ENTRY(lwp) lwp_procq;     /* run/sleep queue. */
-#endif
        LIST_ENTRY(lwp) lwp_list;       /* List of all threads in the proc. */
 
        struct proc     *lwp_proc;      /* Link to our proc. */
@@ -185,7 +183,6 @@ struct lwp {
 };
 
 struct proc {
-       TAILQ_ENTRY(proc) p_procq;      /* run/sleep queue. */
        LIST_ENTRY(proc) p_list;        /* List of all processes. */
 
        /* substructures: */
@@ -450,7 +447,7 @@ extern struct vm_zone *proc_zone;
 
 int    enterpgrp (struct proc *p, pid_t pgid, int mksess);
 void   fixjobc (struct proc *p, struct pgrp *pgrp, int entering);
-void   updatepcpu(struct proc *, int, int);
+void   updatepcpu(struct lwp *, int, int);
 int    inferior (struct proc *p);
 int    leavepgrp (struct proc *p);
 void   sess_hold(struct session *sp);
@@ -475,8 +472,8 @@ void        exit1 (int) __dead2;
 void   cpu_fork (struct proc *, struct proc *, int);
 void   cpu_set_fork_handler (struct proc *, void (*)(void *), void *);
 void   cpu_set_thread_handler(struct thread *td, void (*retfunc)(void), void *func, void *arg);
-int    fork1 (struct proc *, int, struct proc **);
-void   start_forked_proc (struct proc *, struct proc *);
+int    fork1 (struct lwp *, int, struct proc **);
+void   start_forked_proc (struct lwp *, struct proc *);
 int    trace_req (struct proc *);
 void   cpu_proc_wait (struct proc *);
 void   cpu_thread_wait (struct thread *);
index ee7d6a4..2c090b9 100644 (file)
@@ -7,7 +7,7 @@
  * Types which must already be defined when this header is included by
  * userland:   struct md_thread
  * 
- * $DragonFly: src/sys/sys/thread.h,v 1.68 2005/10/05 21:53:41 corecode Exp $
+ * $DragonFly: src/sys/sys/thread.h,v 1.69 2005/10/11 09:59:56 corecode Exp $
  */
 
 #ifndef _SYS_THREAD_H_
@@ -415,7 +415,7 @@ extern void lwkt_cpusync_add(cpumask_t mask, lwkt_cpusync_t poll);
 extern void lwkt_cpusync_finish(lwkt_cpusync_t poll);
 extern void lwkt_smp_stopped(void);
 extern void crit_panic(void);
-extern struct proc *lwkt_preempted_proc(void);
+extern struct lwp *lwkt_preempted_proc(void);
 
 extern int  lwkt_create (void (*func)(void *), void *arg, struct thread **ptd,
                            struct thread *template, int tdflags, int cpu,
index 0fb0ad2..0416016 100644 (file)
@@ -3,7 +3,7 @@
  *
  *     Userland scheduler API
  * 
- * $DragonFly: src/sys/sys/usched.h,v 1.5 2005/06/29 01:25:06 dillon Exp $
+ * $DragonFly: src/sys/sys/usched.h,v 1.6 2005/10/11 09:59:56 corecode Exp $
  */
 
 #ifndef _SYS_USCHED_H_
@@ -20,16 +20,16 @@ struct usched {
     TAILQ_ENTRY(usched) entry;
     const char *name;
     const char *desc;
-    void (*acquire_curproc)(struct proc *);
-    void (*release_curproc)(struct proc *);
+    void (*acquire_curproc)(struct lwp *);
+    void (*release_curproc)(struct lwp *);
     void (*select_curproc)(struct globaldata *);
-    void (*setrunqueue)(struct proc *);
-    void (*remrunqueue)(struct proc *);
-    void (*schedulerclock)(struct proc *, sysclock_t, sysclock_t);
-    void (*recalculate)(struct proc *);
-    void (*resetpriority)(struct proc *);
-    void (*heuristic_forking)(struct proc *, struct proc *);
-    void (*heuristic_exiting)(struct proc *, struct proc *);
+    void (*setrunqueue)(struct lwp *);
+    void (*remrunqueue)(struct lwp *);
+    void (*schedulerclock)(struct lwp *, sysclock_t, sysclock_t);
+    void (*recalculate)(struct lwp *);
+    void (*resetpriority)(struct lwp *);
+    void (*heuristic_forking)(struct lwp *, struct lwp *);
+    void (*heuristic_exiting)(struct lwp *, struct lwp *);
 };
 
 union usched_data {
index a389c87..43311b2 100644 (file)
@@ -60,7 +60,7 @@
  * rights to redistribute these changes.
  *
  * $FreeBSD: src/sys/vm/vm_glue.c,v 1.94.2.4 2003/01/13 22:51:17 dillon Exp $
- * $DragonFly: src/sys/vm/vm_glue.c,v 1.34 2005/10/08 19:46:51 corecode Exp $
+ * $DragonFly: src/sys/vm/vm_glue.c,v 1.35 2005/10/11 09:59:56 corecode Exp $
  */
 
 #include "opt_vm.h"
@@ -533,7 +533,7 @@ swapout(struct proc *p)
        p->p_flag &= ~P_INMEM;
        p->p_flag |= P_SWAPPING;
        if (p->p_flag & P_ONRUNQ)
-               p->p_usched->remrunqueue(p);
+               p->p_usched->remrunqueue(&p->p_lwp);
        crit_exit();
 
        pmap_swapout_proc(p);
index 5481994..1d776d1 100644 (file)
@@ -66,7 +66,7 @@
  * rights to redistribute these changes.
  *
  * $FreeBSD: src/sys/vm/vm_pageout.c,v 1.151.2.15 2002/12/29 18:21:04 dillon Exp $
- * $DragonFly: src/sys/vm/vm_pageout.c,v 1.14 2005/06/27 18:38:00 dillon Exp $
+ * $DragonFly: src/sys/vm/vm_pageout.c,v 1.15 2005/10/11 09:59:56 corecode Exp $
  */
 
 /*
@@ -1164,7 +1164,7 @@ rescan0:
                if (bigproc != NULL) {
                        killproc(bigproc, "out of swap space");
                        bigproc->p_nice = PRIO_MIN;
-                       bigproc->p_usched->resetpriority(bigproc);
+                       bigproc->p_usched->resetpriority(&bigproc->p_lwp);
                        wakeup(&vmstats.v_free_count);
                }
        }