proc->thread stage 1: change kproc_*() API to take and return threads. Note:
authorMatthew Dillon <dillon@dragonflybsd.org>
Sun, 22 Jun 2003 17:39:48 +0000 (17:39 +0000)
committerMatthew Dillon <dillon@dragonflybsd.org>
Sun, 22 Jun 2003 17:39:48 +0000 (17:39 +0000)
we won't be able to turn off the underlying proc until we have a clean thread
path all the way through, which aint now.

sys/kern/kern_kthread.c
sys/kern/kern_shutdown.c
sys/kern/uipc_mbuf.c
sys/kern/vfs_bio.c
sys/kern/vfs_subr.c
sys/opencrypto/crypto.c
sys/sys/kthread.h
sys/sys/proc.h
sys/vm/swap_pager.c
sys/vm/vm_page.c
sys/vm/vm_pageout.c

index 577b82d..b6bb422 100644 (file)
@@ -24,7 +24,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/kern/kern_kthread.c,v 1.5.2.3 2001/12/25 01:51:14 dillon Exp $
- * $DragonFly: src/sys/kern/kern_kthread.c,v 1.3 2003/06/22 04:30:42 dillon Exp $
+ * $DragonFly: src/sys/kern/kern_kthread.c,v 1.4 2003/06/22 17:39:42 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -54,7 +54,7 @@ kproc_start(udata)
        int error;
 
        error = kthread_create((void (*)(void *))kp->func, NULL,
-                   kp->global_procpp, kp->arg0);
+                   kp->global_threadpp, kp->arg0);
        if (error)
                panic("kproc_start: %s: error %d", kp->arg0, error);
 }
@@ -65,7 +65,7 @@ kproc_start(udata)
  */
 int
 kthread_create(void (*func)(void *), void *arg,
-    struct proc **newpp, const char *fmt, ...)
+    struct thread **newpp, const char *fmt, ...)
 {
        int error;
        va_list ap;
@@ -81,7 +81,7 @@ kthread_create(void (*func)(void *), void *arg,
 
        /* save a global descriptor, if desired */
        if (newpp != NULL)
-               *newpp = p2;
+               *newpp = p2->p_thread;
 
        /* this is a non-swapped system process */
        p2->p_flag |= P_INMEM | P_SYSTEM;
@@ -112,36 +112,45 @@ kthread_exit(int ecode)
  * Participation is voluntary.
  */
 int
-suspend_kproc(struct proc *p, int timo)
+suspend_kproc(struct thread *td, int timo)
 {
+       struct proc *p = td->td_proc;
+
        /*
         * Make sure this is indeed a system process and we can safely
         * use the p_siglist field.
         */
        if ((p->p_flag & P_SYSTEM) == 0)
                return (EINVAL);
+       KASSERT(p != NULL, ("suspend_kproc: no proc context: %p", td));
        SIGADDSET(p->p_siglist, SIGSTOP);
        wakeup(p);
        return tsleep((caddr_t)&p->p_siglist, PPAUSE, "suspkp", timo);
 }
 
 int
-resume_kproc(struct proc *p)
+resume_kproc(struct thread *td)
 {
+       struct proc *p = td->td_proc;
+
        /*
         * Make sure this is indeed a system process and we can safely
         * use the p_siglist field.
         */
        if ((p->p_flag & P_SYSTEM) == 0)
                return (EINVAL);
+       KASSERT(p != NULL, ("suspend_kproc: no proc context: %p", td));
        SIGDELSET(p->p_siglist, SIGSTOP);
        wakeup((caddr_t)&p->p_siglist);
        return (0);
 }
 
 void
-kproc_suspend_loop(struct proc *p)
+kproc_suspend_loop(struct thread *td)
 {
+       struct proc *p = td->td_proc;
+
+       KASSERT(p != NULL, ("suspend_kproc: no proc context: %p", td));
        while (SIGISMEMBER(p->p_siglist, SIGSTOP)) {
                wakeup((caddr_t)&p->p_siglist);
                tsleep((caddr_t)&p->p_siglist, PPAUSE, "kpsusp", 0);
index 2a1b773..8acaa52 100644 (file)
@@ -37,7 +37,7 @@
  *
  *     @(#)kern_shutdown.c     8.3 (Berkeley) 1/21/94
  * $FreeBSD: src/sys/kern/kern_shutdown.c,v 1.72.2.12 2002/02/21 19:15:10 dillon Exp $
- * $DragonFly: src/sys/kern/kern_shutdown.c,v 1.3 2003/06/19 01:55:06 dillon Exp $
+ * $DragonFly: src/sys/kern/kern_shutdown.c,v 1.4 2003/06/22 17:39:42 dillon Exp $
  */
 
 #include "opt_ddb.h"
@@ -630,16 +630,22 @@ SYSCTL_INT(_kern_shutdown, OID_AUTO, kproc_shutdown_wait, CTLFLAG_RW,
 void
 shutdown_kproc(void *arg, int howto)
 {
+       struct thread *td;
        struct proc *p;
        int error;
 
        if (panicstr)
                return;
 
-       p = (struct proc *)arg;
-       printf("Waiting (max %d seconds) for system process `%s' to stop...",
-           kproc_shutdown_wait, p->p_comm);
-       error = suspend_kproc(p, kproc_shutdown_wait * hz);
+       td = (struct thread *)arg;
+       if ((p = td->td_proc) != NULL) {
+           printf("Waiting (max %d seconds) for system process `%s' to stop...",
+               kproc_shutdown_wait, p->p_comm);
+       } else {
+           printf("Waiting (max %d seconds) for system thread %p to stop...",
+               kproc_shutdown_wait, td);
+       }
+       error = suspend_kproc(td, kproc_shutdown_wait * hz);
 
        if (error == EWOULDBLOCK)
                printf("timed out\n");
index 7ef432f..f3826a5 100644 (file)
@@ -32,7 +32,7 @@
  *
  *     @(#)uipc_mbuf.c 8.2 (Berkeley) 1/4/94
  * $FreeBSD: src/sys/kern/uipc_mbuf.c,v 1.51.2.24 2003/04/15 06:59:29 silby Exp $
- * $DragonFly: src/sys/kern/uipc_mbuf.c,v 1.2 2003/06/17 04:28:41 dillon Exp $
+ * $DragonFly: src/sys/kern/uipc_mbuf.c,v 1.3 2003/06/22 17:39:42 dillon Exp $
  */
 
 #include "opt_param.h"
@@ -303,13 +303,13 @@ kproc_mclalloc(void)
        }
 }
 
-static struct proc *mclallocproc;
+static struct thread *mclallocthread;
 static struct kproc_desc mclalloc_kp = {
        "mclalloc",
        kproc_mclalloc,
-       &mclallocproc
+       &mclallocthread
 };
-SYSINIT(mclallocproc, SI_SUB_KTHREAD_UPDATE, SI_ORDER_ANY, kproc_start,
+SYSINIT(mclallocthread, SI_SUB_KTHREAD_UPDATE, SI_ORDER_ANY, kproc_start,
           &mclalloc_kp);
 #endif
 
index 1e68924..76b4ae7 100644 (file)
@@ -12,7 +12,7 @@
  *             John S. Dyson.
  *
  * $FreeBSD: src/sys/kern/vfs_bio.c,v 1.242.2.20 2003/05/28 18:38:10 alc Exp $
- * $DragonFly: src/sys/kern/vfs_bio.c,v 1.3 2003/06/19 01:55:06 dillon Exp $
+ * $DragonFly: src/sys/kern/vfs_bio.c,v 1.4 2003/06/22 17:39:42 dillon Exp $
  */
 
 /*
@@ -1785,12 +1785,12 @@ restart:
  *     take the load in an attempt to prevent getnewbuf() from blocking.
  */
 
-static struct proc *bufdaemonproc;
+static struct thread *bufdaemonthread;
 
 static struct kproc_desc buf_kp = {
        "bufdaemon",
        buf_daemon,
-       &bufdaemonproc
+       &bufdaemonthread
 };
 SYSINIT(bufdaemon, SI_SUB_KTHREAD_BUF, SI_ORDER_FIRST, kproc_start, &buf_kp)
 
@@ -1802,8 +1802,8 @@ buf_daemon()
        /*
         * This process needs to be suspended prior to shutdown sync.
         */
-       EVENTHANDLER_REGISTER(shutdown_pre_sync, shutdown_kproc, bufdaemonproc,
-           SHUTDOWN_PRI_LAST);
+       EVENTHANDLER_REGISTER(shutdown_pre_sync, shutdown_kproc,
+           bufdaemonthread, SHUTDOWN_PRI_LAST);
 
        /*
         * This process is allowed to take the buffer cache to the limit
@@ -1811,7 +1811,7 @@ buf_daemon()
        s = splbio();
 
        for (;;) {
-               kproc_suspend_loop(bufdaemonproc);
+               kproc_suspend_loop(bufdaemonthread);
 
                /*
                 * Do the flush.  Limit the amount of in-transit I/O we
@@ -2550,7 +2550,7 @@ allocbuf(struct buf *bp, int size)
                                 * We have a good page.  Should we wakeup the
                                 * page daemon?
                                 */
-                               if ((curproc != pageproc) &&
+                               if ((curthread != pagethread) &&
                                    ((m->queue - m->pc) == PQ_CACHE) &&
                                    ((cnt.v_free_count + cnt.v_cache_count) <
                                        (cnt.v_free_min + cnt.v_cache_min))) {
index 720f9a5..9b46185 100644 (file)
@@ -37,7 +37,7 @@
  *
  *     @(#)vfs_subr.c  8.31 (Berkeley) 5/26/95
  * $FreeBSD: src/sys/kern/vfs_subr.c,v 1.249.2.30 2003/04/04 20:35:57 tegge Exp $
- * $DragonFly: src/sys/kern/vfs_subr.c,v 1.3 2003/06/19 01:55:06 dillon Exp $
+ * $DragonFly: src/sys/kern/vfs_subr.c,v 1.4 2003/06/22 17:39:42 dillon Exp $
  */
 
 /*
@@ -518,7 +518,7 @@ vlrureclaim(struct mount *mp)
  * Calling vlrurecycle() from the bowels of file system code has some
  * interesting deadlock problems.
  */
-static struct proc *vnlruproc;
+static struct thread *vnlruthread;
 static int vnlruproc_sig;
 
 static void 
@@ -527,18 +527,19 @@ vnlru_proc(void)
        struct mount *mp, *nmp;
        int s;
        int done;
-       struct proc *p = vnlruproc;
+       struct thread *td = vnlruthread;
+       struct proc *p = td->td_proc;
 
-       EVENTHANDLER_REGISTER(shutdown_pre_sync, shutdown_kproc, p,
+       EVENTHANDLER_REGISTER(shutdown_pre_sync, shutdown_kproc, td,
            SHUTDOWN_PRI_FIRST);   
 
        s = splbio();
        for (;;) {
-               kproc_suspend_loop(p);
+               kproc_suspend_loop(td);
                if (numvnodes - freevnodes <= desiredvnodes * 9 / 10) {
                        vnlruproc_sig = 0;
                        wakeup(&vnlruproc_sig);
-                       tsleep(vnlruproc, PVFS, "vlruwt", hz);
+                       tsleep(p, PVFS, "vlruwt", hz);
                        continue;
                }
                done = 0;
@@ -556,7 +557,7 @@ vnlru_proc(void)
                simple_unlock(&mountlist_slock);
                if (done == 0) {
                        vnlru_nowhere++;
-                       tsleep(vnlruproc, PPAUSE, "vlrup", hz * 3);
+                       tsleep(p, PPAUSE, "vlrup", hz * 3);
                }
        }
        splx(s);
@@ -565,7 +566,7 @@ vnlru_proc(void)
 static struct kproc_desc vnlru_kp = {
        "vnlru",
        vnlru_proc,
-       &vnlruproc
+       &vnlruthread
 };
 SYSINIT(vnlru, SI_SUB_KTHREAD_UPDATE, SI_ORDER_FIRST, kproc_start, &vnlru_kp)
 
@@ -600,7 +601,7 @@ getnewvnode(tag, mp, vops, vpp)
        while (numvnodes - freevnodes > desiredvnodes) {
                if (vnlruproc_sig == 0) {
                        vnlruproc_sig = 1;      /* avoid unnecessary wakeups */
-                       wakeup(vnlruproc);
+                       wakeup(vnlruthread);
                }
                tsleep(&vnlruproc_sig, PVFS, "vlruwk", hz);
        }
@@ -1117,12 +1118,12 @@ vn_syncer_add_to_worklist(struct vnode *vp, int delay)
        splx(s);
 }
 
-struct  proc *updateproc;
+struct  thread *updatethread;
 static void sched_sync __P((void));
 static struct kproc_desc up_kp = {
        "syncer",
        sched_sync,
-       &updateproc
+       &updatethread
 };
 SYSINIT(syncer, SI_SUB_KTHREAD_UPDATE, SI_ORDER_FIRST, kproc_start, &up_kp)
 
@@ -1136,13 +1137,14 @@ sched_sync(void)
        struct vnode *vp;
        long starttime;
        int s;
-       struct proc *p = updateproc;
+       struct thread *td = updatethread;
+       struct proc *p = td->td_proc;
 
-       EVENTHANDLER_REGISTER(shutdown_pre_sync, shutdown_kproc, p,
+       EVENTHANDLER_REGISTER(shutdown_pre_sync, shutdown_kproc, td,
            SHUTDOWN_PRI_LAST);   
 
        for (;;) {
-               kproc_suspend_loop(p);
+               kproc_suspend_loop(td);
 
                starttime = time_second;
 
@@ -1229,8 +1231,8 @@ speedup_syncer()
        int s;
 
        s = splhigh();
-       if (updateproc->p_wchan == &lbolt)
-               setrunnable(updateproc);
+       if (updatethread->td_proc->p_wchan == &lbolt) /* YYY */
+               setrunnable(updatethread->td_proc);
        splx(s);
        if (rushjob < syncdelay / 2) {
                rushjob += 1;
index fb61496..0111632 100644 (file)
@@ -1,5 +1,5 @@
 /*     $FreeBSD: src/sys/opencrypto/crypto.c,v 1.4.2.7 2003/06/03 00:09:02 sam Exp $   */
-/*     $DragonFly: src/sys/opencrypto/crypto.c,v 1.2 2003/06/17 04:28:54 dillon Exp $  */
+/*     $DragonFly: src/sys/opencrypto/crypto.c,v 1.3 2003/06/22 17:39:44 dillon Exp $  */
 /*     $OpenBSD: crypto.c,v 1.38 2002/06/11 11:14:29 beck Exp $        */
 /*
  * The author of this code is Angelos D. Keromytis (angelos@cis.upenn.edu)
@@ -114,7 +114,7 @@ MALLOC_DEFINE(M_CRYPTO_DATA, "crypto", "crypto session records");
  */ 
 static void cryptointr(void);          /* swi thread to dispatch ops */
 static void cryptoret(void);           /* kernel thread for callbacks*/
-static struct proc *cryptoproc;
+static struct thread *cryptothread;
 static void crypto_destroy(void);
 static int crypto_invoke(struct cryptop *crp, int hint);
 static int crypto_kinvoke(struct cryptkop *krp, int hint);
@@ -158,7 +158,7 @@ crypto_init(void)
 
        register_swi(SWI_CRYPTO, cryptointr);
        error = kthread_create((void (*)(void *)) cryptoret, NULL,
-                   &cryptoproc, "cryptoret");
+                   &cryptothread, "cryptoret");
        if (error) {
                printf("crypto_init: cannot start cryptoret thread; error %d",
                        error);
index 532b334..0ed6c5a 100644 (file)
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/sys/kthread.h,v 1.2 2000/01/07 08:36:44 luoqi Exp $
- * $DragonFly: src/sys/sys/kthread.h,v 1.2 2003/06/17 04:28:58 dillon Exp $
+ * $DragonFly: src/sys/sys/kthread.h,v 1.3 2003/06/22 17:39:46 dillon Exp $
  */
 
 #ifndef _SYS_KTHREAD_H_
 #define _SYS_KTHREAD_H_
 
 struct proc;
+struct thread;
 
 /* 
  * A kernel process descriptor; used to start "internal" daemons
@@ -40,17 +41,17 @@ struct proc;
 struct kproc_desc {
        char            *arg0;                  /* arg 0 (for 'ps' listing) */
        void            (*func) __P((void));    /* "main" for kernel process */
-       struct proc     **global_procpp;        /* ptr to proc ptr save area */
+       struct thread   **global_threadpp;      /* ptr to proc ptr save area */
 };
 
 void   kproc_start __P((const void *));
-int     kthread_create __P((void (*)(void *), void *, struct proc **,
+int     kthread_create __P((void (*)(void *), void *, struct thread **,
            const char *, ...)) __printflike(4, 5);
 void    kthread_exit __P((int)) __dead2;
 
-int    suspend_kproc __P((struct proc *, int));
-int    resume_kproc __P((struct proc *));
-void   kproc_suspend_loop __P((struct proc *));
+int    suspend_kproc __P((struct thread *, int));
+int    resume_kproc __P((struct thread *));
+void   kproc_suspend_loop __P((struct thread *));
 void   shutdown_kproc __P((void *, int));
 
 #endif
index 437a939..82e7949 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.11 2003/06/22 04:30:43 dillon Exp $
+ * $DragonFly: src/sys/sys/proc.h,v 1.12 2003/06/22 17:39:46 dillon Exp $
  */
 
 #ifndef _SYS_PROC_H_
@@ -386,7 +386,8 @@ extern int sched_quantum;           /* Scheduling quantum in ticks */
 LIST_HEAD(proclist, proc);
 extern struct proclist allproc;                /* List of all processes. */
 extern struct proclist zombproc;       /* List of zombie processes. */
-extern struct proc *initproc, *pageproc, *updateproc; /* Process slots for init, pager. */
+extern struct proc *initproc;          /* Process slot for init */
+extern struct thread *pagethread, *updatethread;
 
 #define        NQS     32                      /* 32 run queues. */
 TAILQ_HEAD(rq, proc);
index cc61fe2..fa6bc2e 100644 (file)
@@ -65,7 +65,7 @@
  *     @(#)swap_pager.c        8.9 (Berkeley) 3/21/94
  *
  * $FreeBSD: src/sys/vm/swap_pager.c,v 1.130.2.12 2002/08/31 21:15:55 dillon Exp $
- * $DragonFly: src/sys/vm/swap_pager.c,v 1.3 2003/06/19 01:55:08 dillon Exp $
+ * $DragonFly: src/sys/vm/swap_pager.c,v 1.4 2003/06/22 17:39:48 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -1251,7 +1251,7 @@ swap_pager_putpages(object, m, count, sync, rtvals)
        if (object->type != OBJT_SWAP)
                swp_pager_meta_build(object, 0, SWAPBLK_NONE);
 
-       if (curproc != pageproc)
+       if (curthread != pagethread)
                sync = TRUE;
 
        /*
index d5f880c..f9fcdac 100644 (file)
@@ -35,7 +35,7 @@
  *
  *     from: @(#)vm_page.c     7.4 (Berkeley) 5/7/91
  * $FreeBSD: src/sys/vm/vm_page.c,v 1.147.2.18 2002/03/10 05:03:19 alc Exp $
- * $DragonFly: src/sys/vm/vm_page.c,v 1.3 2003/06/21 07:54:57 dillon Exp $
+ * $DragonFly: src/sys/vm/vm_page.c,v 1.4 2003/06/22 17:39:48 dillon Exp $
  */
 
 /*
@@ -745,7 +745,7 @@ vm_page_alloc(vm_object_t object, vm_pindex_t pindex, int page_req)
         * The pager is allowed to eat deeper into the free page list.
         */
 
-       if ((curproc == pageproc) && (page_req != VM_ALLOC_INTERRUPT)) {
+       if ((curthread == pagethread) && (page_req != VM_ALLOC_INTERRUPT)) {
                page_req = VM_ALLOC_SYSTEM;
        };
 
@@ -869,7 +869,7 @@ vm_wait(void)
        int s;
 
        s = splvm();
-       if (curproc == pageproc) {
+       if (curthread == pagethread) {
                vm_pageout_pages_needed = 1;
                tsleep(&vm_pageout_pages_needed, PSWP, "VMWait", 0);
        } else {
index 00c132d..7b47326 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.2 2003/06/17 04:29:00 dillon Exp $
+ * $DragonFly: src/sys/vm/vm_pageout.c,v 1.3 2003/06/22 17:39:48 dillon Exp $
  */
 
 /*
@@ -105,24 +105,24 @@ static void vm_pageout __P((void));
 static int vm_pageout_clean __P((vm_page_t));
 static void vm_pageout_scan __P((int pass));
 static int vm_pageout_free_page_calc __P((vm_size_t count));
-struct proc *pageproc;
+struct thread *pagethread;
 
 static struct kproc_desc page_kp = {
        "pagedaemon",
        vm_pageout,
-       &pageproc
+       &pagethread
 };
 SYSINIT(pagedaemon, SI_SUB_KTHREAD_PAGE, SI_ORDER_FIRST, kproc_start, &page_kp)
 
 #if !defined(NO_SWAPPING)
 /* the kernel process "vm_daemon"*/
 static void vm_daemon __P((void));
-static struct  proc *vmproc;
+static struct  thread *vmthread;
 
 static struct kproc_desc vm_kp = {
        "vmdaemon",
        vm_daemon,
-       &vmproc
+       &vmthread
 };
 SYSINIT(vmdaemon, SI_SUB_KTHREAD_VM, SI_ORDER_FIRST, kproc_start, &vm_kp)
 #endif
@@ -1411,7 +1411,7 @@ vm_pageout()
 void
 pagedaemon_wakeup()
 {
-       if (!vm_pages_needed && curproc != pageproc) {
+       if (!vm_pages_needed && curthread != pagethread) {
                vm_pages_needed++;
                wakeup(&vm_pages_needed);
        }