Remove spl*() calls from kern, replacing them with critical sections.
authorMatthew Dillon <dillon@dragonflybsd.org>
Mon, 6 Jun 2005 15:02:28 +0000 (15:02 +0000)
committerMatthew Dillon <dillon@dragonflybsd.org>
Mon, 6 Jun 2005 15:02:28 +0000 (15:02 +0000)
Change the meaning of safepri from a cpl mask to a thread priority.
Make a minor adjustment to tests within one of the buffer cache's
critical sections.

42 files changed:
sys/i386/i386/autoconf.c
sys/i386/i386/machdep.c
sys/kern/init_main.c
sys/kern/kern_clock.c
sys/kern/kern_descrip.c
sys/kern/kern_event.c
sys/kern/kern_exit.c
sys/kern/kern_fork.c
sys/kern/kern_intr.c
sys/kern/kern_lock.c
sys/kern/kern_msfbuf.c
sys/kern/kern_physio.c
sys/kern/kern_poll.c
sys/kern/kern_random.c
sys/kern/kern_resource.c
sys/kern/kern_sig.c
sys/kern/kern_synch.c
sys/kern/kern_timeout.c
sys/kern/kern_xio.c
sys/kern/subr_diskslice.c
sys/kern/subr_log.c
sys/kern/subr_prof.c
sys/kern/subr_rman.c
sys/kern/subr_taskqueue.c
sys/kern/sys_generic.c
sys/kern/sys_process.c
sys/kern/tty.c
sys/kern/tty_pty.c
sys/kern/uipc_accf.c
sys/kern/uipc_domain.c
sys/kern/uipc_socket.c
sys/kern/vfs_aio.c
sys/kern/vfs_bio.c
sys/kern/vfs_cluster.c
sys/kern/vfs_conf.c
sys/kern/vfs_mount.c
sys/kern/vfs_subr.c
sys/kern/vfs_sync.c
sys/kern/vfs_syscalls.c
sys/platform/pc32/i386/autoconf.c
sys/platform/pc32/i386/machdep.c
sys/sys/thread2.h

index 0c29580..19d7e98 100644 (file)
@@ -35,7 +35,7 @@
  *
  *     from: @(#)autoconf.c    7.1 (Berkeley) 5/9/91
  * $FreeBSD: src/sys/i386/i386/autoconf.c,v 1.146.2.2 2001/06/07 06:05:58 dd Exp $
- * $DragonFly: src/sys/i386/i386/Attic/autoconf.c,v 1.15 2004/10/14 18:31:02 dillon Exp $
+ * $DragonFly: src/sys/i386/i386/Attic/autoconf.c,v 1.16 2005/06/06 15:02:26 dillon Exp $
  */
 
 /*
@@ -181,7 +181,7 @@ configure(dummy)
         * completely safe (since a panic may occur in a critical region
         * at splhigh()), but we want at least bio interrupts to work.
         */
-       safepri = curthread->td_cpl;
+       safepri = TDPRI_KERN_USER;
 }
 
 static void
index cec9277..7c595ae 100644 (file)
@@ -36,7 +36,7 @@
  *
  *     from: @(#)machdep.c     7.4 (Berkeley) 6/3/91
  * $FreeBSD: src/sys/i386/i386/machdep.c,v 1.385.2.30 2003/05/31 08:48:05 alc Exp $
- * $DragonFly: src/sys/i386/i386/Attic/machdep.c,v 1.72 2005/03/17 08:22:38 swildner Exp $
+ * $DragonFly: src/sys/i386/i386/Attic/machdep.c,v 1.73 2005/06/06 15:02:26 dillon Exp $
  */
 
 #include "use_apm.h"
@@ -1872,7 +1872,8 @@ init386(int first)
        thread0.td_flags |= TDF_RUNNING;
        thread0.td_proc = &proc0;
        thread0.td_switch = cpu_heavy_switch;   /* YYY eventually LWKT */
-       safepri = thread0.td_cpl = SWI_MASK | HWI_MASK;
+       thread0.td_cpl = 0;                     /* crit section protects us */
+       safepri = TDPRI_MAX;
 
        /* make ldt memory segments */
        /*
index 74b4f48..fabeae7 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.41 2005/04/19 17:54:42 dillon Exp $
+ * $DragonFly: src/sys/kern/init_main.c,v 1.42 2005/06/06 15:02:27 dillon Exp $
  */
 
 #include "opt_init_path.h"
@@ -590,15 +590,14 @@ static void
 create_init(const void *udata __unused)
 {
        int error;
-       int s;
 
-       s = splhigh();
+       crit_enter();
        error = fork1(&proc0, RFFDG | RFPROC, &initproc);
        if (error)
                panic("cannot fork init: %d", error);
        initproc->p_flag |= P_INMEM | P_SYSTEM;
        cpu_set_fork_handler(initproc, start_init, NULL);
-       splx(s);
+       crit_exit();
 }
 SYSINIT(init,SI_SUB_CREATE_INIT, SI_ORDER_FIRST, create_init, NULL)
 
index 742325f..1386a32 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.42 2005/06/03 23:57:32 dillon Exp $
+ * $DragonFly: src/sys/kern/kern_clock.c,v 1.43 2005/06/06 15:02:27 dillon Exp $
  */
 
 #include "opt_ntp.h"
@@ -606,7 +606,7 @@ statclock(systimer_t info, struct intrframe *frame)
                 * in ``non-process'' (i.e., interrupt) work.
                 *
                 * XXX assume system if frame is NULL.  A NULL frame 
-                * can occur if ipi processing is done from an splx().
+                * can occur if ipi processing is done from a crit_exit().
                 */
                if (frame && CLKF_INTR(frame))
                        td->td_iticks += bump;
@@ -742,10 +742,10 @@ startprofclock(struct proc *p)
                p->p_flag |= P_PROFIL;
 #if 0  /* XXX */
                if (++profprocs == 1 && stathz != 0) {
-                       s = splstatclock();
+                       crit_enter();
                        psdiv = psratio;
                        setstatclockrate(profhz);
-                       splx(s);
+                       crit_exit();
                }
 #endif
        }
@@ -761,10 +761,10 @@ stopprofclock(struct proc *p)
                p->p_flag &= ~P_PROFIL;
 #if 0  /* XXX */
                if (--profprocs == 0 && stathz != 0) {
-                       s = splstatclock();
+                       crit_enter();
                        psdiv = 1;
                        setstatclockrate(stathz);
-                       splx(s);
+                       crit_exit();
                }
 #endif
        }
index 651942a..0c8725d 100644 (file)
@@ -37,7 +37,7 @@
  *
  *     @(#)kern_descrip.c      8.6 (Berkeley) 4/19/94
  * $FreeBSD: src/sys/kern/kern_descrip.c,v 1.81.2.19 2004/02/28 00:43:31 tegge Exp $
- * $DragonFly: src/sys/kern/kern_descrip.c,v 1.41 2005/04/08 17:39:31 joerg Exp $
+ * $DragonFly: src/sys/kern/kern_descrip.c,v 1.42 2005/06/06 15:02:27 dillon Exp $
  */
 
 #include "opt_compat.h"
@@ -66,6 +66,7 @@
 #include <vm/vm.h>
 #include <vm/vm_extern.h>
 
+#include <sys/thread2.h>
 #include <sys/file2.h>
 
 static MALLOC_DEFINE(M_FILEDESC, "file desc", "Open file descriptor table");
@@ -498,13 +499,11 @@ kern_dup(enum dup_type type, int old, int new, int *res)
 void
 funsetown(struct sigio *sigio)
 {
-       int s;
-
        if (sigio == NULL)
                return;
-       s = splhigh();
+       crit_enter();
        *(sigio->sio_myref) = NULL;
-       splx(s);
+       crit_exit();
        if (sigio->sio_pgid < 0) {
                SLIST_REMOVE(&sigio->sio_pgrp->pg_sigiolst, sigio,
                             sigio, sio_pgsigio);
@@ -538,7 +537,6 @@ fsetown(pid_t pgid, struct sigio **sigiop)
        struct proc *proc;
        struct pgrp *pgrp;
        struct sigio *sigio;
-       int s;
 
        if (pgid == 0) {
                funsetown(*sigiop);
@@ -593,9 +591,9 @@ fsetown(pid_t pgid, struct sigio **sigiop)
        /* It would be convenient if p_ruid was in ucred. */
        sigio->sio_ruid = curproc->p_ucred->cr_ruid;
        sigio->sio_myref = sigiop;
-       s = splhigh();
+       crit_enter();
        *sigiop = sigio;
-       splx(s);
+       crit_exit();
        return (0);
 }
 
index c75c329..0464def 100644 (file)
@@ -24,7 +24,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/kern/kern_event.c,v 1.2.2.10 2004/04/04 07:03:14 cperciva Exp $
- * $DragonFly: src/sys/kern/kern_event.c,v 1.13 2004/11/12 00:09:23 dillon Exp $
+ * $DragonFly: src/sys/kern/kern_event.c,v 1.14 2005/06/06 15:02:27 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -47,6 +47,7 @@
 #include <sys/sysctl.h>
 #include <sys/sysproto.h>
 #include <sys/uio.h>
+#include <sys/thread2.h>
 #include <sys/file2.h>
 
 #include <vm/vm_zone.h>
@@ -464,7 +465,7 @@ kqueue_register(struct kqueue *kq, struct kevent *kev, struct thread *td)
        struct filterops *fops;
        struct file *fp = NULL;
        struct knote *kn = NULL;
-       int s, error = 0;
+       int error = 0;
 
        if (kev->filter < 0) {
                if (kev->filter + EVFILT_SYSCOUNT < 0)
@@ -555,11 +556,10 @@ kqueue_register(struct kqueue *kq, struct kevent *kev, struct thread *td)
                        kn->kn_kevent.udata = kev->udata;
                }
 
-               s = splhigh();
+               crit_enter();
                if (kn->kn_fop->f_event(kn, 0))
                        KNOTE_ACTIVATE(kn);
-               splx(s);
-
+               crit_exit();
        } else if (kev->flags & EV_DELETE) {
                kn->kn_fop->f_detach(kn);
                knote_drop(kn, td);
@@ -568,18 +568,18 @@ kqueue_register(struct kqueue *kq, struct kevent *kev, struct thread *td)
 
        if ((kev->flags & EV_DISABLE) &&
            ((kn->kn_status & KN_DISABLED) == 0)) {
-               s = splhigh();
+               crit_enter();
                kn->kn_status |= KN_DISABLED;
-               splx(s);
+               crit_exit();
        }
 
        if ((kev->flags & EV_ENABLE) && (kn->kn_status & KN_DISABLED)) {
-               s = splhigh();
+               crit_enter();
                kn->kn_status &= ~KN_DISABLED;
                if ((kn->kn_status & KN_ACTIVE) &&
                    ((kn->kn_status & KN_QUEUED) == 0))
                        knote_enqueue(kn);
-               splx(s);
+               crit_exit();
        }
 
 done:
@@ -597,7 +597,7 @@ kqueue_scan(struct file *fp, int maxevents, struct kevent *ulistp,
        struct kevent *kevp;
        struct timeval atv, rtv, ttv;
        struct knote *kn, marker;
-       int s, count, timeout, nkev = 0, error = 0;
+       int count, timeout, nkev = 0, error = 0;
 
        count = maxevents;
        if (count == 0)
@@ -636,7 +636,7 @@ retry:
 
 start:
        kevp = kq->kq_kev;
-       s = splhigh();
+       crit_enter();
        if (kq->kq_count == 0) {
                if (timeout < 0) { 
                        error = EWOULDBLOCK;
@@ -644,7 +644,7 @@ start:
                        kq->kq_state |= KQ_SLEEP;
                        error = tsleep(kq, PCATCH, "kqread", timeout);
                }
-               splx(s);
+               crit_exit();
                if (error == 0)
                        goto retry;
                /* don't restart after signals... */
@@ -660,7 +660,7 @@ start:
                kn = TAILQ_FIRST(&kq->kq_head);
                TAILQ_REMOVE(&kq->kq_head, kn, kn_tqe); 
                if (kn == &marker) {
-                       splx(s);
+                       crit_exit();
                        if (count == maxevents)
                                goto retry;
                        goto done;
@@ -682,10 +682,10 @@ start:
                if (kn->kn_flags & EV_ONESHOT) {
                        kn->kn_status &= ~KN_QUEUED;
                        kq->kq_count--;
-                       splx(s);
+                       crit_exit();
                        kn->kn_fop->f_detach(kn);
                        knote_drop(kn, td);
-                       s = splhigh();
+                       crit_enter();
                } else if (kn->kn_flags & EV_CLEAR) {
                        kn->kn_data = 0;
                        kn->kn_fflags = 0;
@@ -696,19 +696,19 @@ start:
                }
                count--;
                if (nkev == KQ_NEVENTS) {
-                       splx(s);
+                       crit_exit();
                        error = copyout((caddr_t)&kq->kq_kev, (caddr_t)ulistp,
                            sizeof(struct kevent) * nkev);
                        ulistp += nkev;
                        nkev = 0;
                        kevp = kq->kq_kev;
-                       s = splhigh();
+                       crit_enter();
                        if (error)
                                break;
                }
        }
        TAILQ_REMOVE(&kq->kq_head, &marker, kn_tqe); 
-       splx(s);
+       crit_exit();
 done:
        if (nkev != 0)
                error = copyout((caddr_t)&kq->kq_kev, (caddr_t)ulistp,
@@ -750,8 +750,8 @@ kqueue_poll(struct file *fp, int events, struct ucred *cred, struct thread *td)
 {
        struct kqueue *kq = (struct kqueue *)fp->f_data;
        int revents = 0;
-       int s = splnet();
 
+       crit_enter();
         if (events & (POLLIN | POLLRDNORM)) {
                 if (kq->kq_count) {
                         revents |= events & (POLLIN | POLLRDNORM);
@@ -760,7 +760,7 @@ kqueue_poll(struct file *fp, int events, struct ucred *cred, struct thread *td)
                        kq->kq_state |= KQ_SEL;
                }
        }
-       splx(s);
+       crit_exit();
        return (revents);
 }
 
@@ -920,8 +920,8 @@ done:
 }
 
 /*
- * should be called at spl == 0, since we don't want to hold spl
- * while calling fdrop and free.
+ * should be called outside of a critical section, since we don't want to
+ * hold a critical section while calling fdrop and free.
  */
 static void
 knote_drop(struct knote *kn, struct thread *td)
@@ -949,14 +949,14 @@ static void
 knote_enqueue(struct knote *kn)
 {
        struct kqueue *kq = kn->kn_kq;
-       int s = splhigh();
 
+       crit_enter();
        KASSERT((kn->kn_status & KN_QUEUED) == 0, ("knote already queued"));
 
        TAILQ_INSERT_TAIL(&kq->kq_head, kn, kn_tqe); 
        kn->kn_status |= KN_QUEUED;
        kq->kq_count++;
-       splx(s);
+       crit_exit();
        kqueue_wakeup(kq);
 }
 
@@ -964,14 +964,14 @@ static void
 knote_dequeue(struct knote *kn)
 {
        struct kqueue *kq = kn->kn_kq;
-       int s = splhigh();
 
        KASSERT(kn->kn_status & KN_QUEUED, ("knote not queued"));
+       crit_enter();
 
        TAILQ_REMOVE(&kq->kq_head, kn, kn_tqe); 
        kn->kn_status &= ~KN_QUEUED;
        kq->kq_count--;
-       splx(s);
+       crit_exit();
 }
 
 static void
index 0b6f37d..290800d 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.40 2005/04/20 16:37:09 cpressey Exp $
+ * $DragonFly: src/sys/kern/kern_exit.c,v 1.41 2005/06/06 15:02:27 dillon Exp $
  */
 
 #include "opt_compat.h"
@@ -75,6 +75,8 @@
 #include <vm/vm_extern.h>
 #include <sys/user.h>
 
+#include <sys/thread2.h>
+
 /* Required to be non-static for SysVR4 emulator */
 MALLOC_DEFINE(M_ZOMBIE, "zombie", "zombie proc status");
 
@@ -650,15 +652,14 @@ check_sigacts(void)
 {
        struct proc *p = curproc;
        struct sigacts *pss;
-       int s;
 
        if (p->p_procsig->ps_refcnt == 1 &&
            p->p_sigacts != &p->p_addr->u_sigacts) {
                pss = p->p_sigacts;
-               s = splhigh();
+               crit_enter();
                p->p_addr->u_sigacts = *pss;
                p->p_sigacts = &p->p_addr->u_sigacts;
-               splx(s);
+               crit_exit();
                FREE(pss, M_SUBPROC);
        }
 }
index 33c72ab..2790a7d 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.32 2005/01/31 22:29:59 joerg Exp $
+ * $DragonFly: src/sys/kern/kern_fork.c,v 1.33 2005/06/06 15:02:27 dillon Exp $
  */
 
 #include "opt_ktrace.h"
@@ -67,6 +67,7 @@
 
 #include <sys/vmmeter.h>
 #include <sys/user.h>
+#include <sys/thread2.h>
 
 static MALLOC_DEFINE(M_ATFORK, "atfork", "atfork callback");
 
@@ -384,12 +385,11 @@ again:
                p2->p_procsig->ps_refcnt++;
                if (p1->p_sigacts == &p1->p_addr->u_sigacts) {
                        struct sigacts *newsigacts;
-                       int s;
 
                        /* Create the shared sigacts structure */
                        MALLOC(newsigacts, struct sigacts *,
                            sizeof(struct sigacts), M_SUBPROC, M_WAITOK);
-                       s = splhigh();
+                       crit_enter();
                        /*
                         * Set p_sigacts to the new shared structure.
                         * Note that this is updating p1->p_sigacts at the
@@ -400,7 +400,7 @@ again:
                        bcopy(&p1->p_addr->u_sigacts, p2->p_sigacts,
                            sizeof(*p2->p_sigacts));
                        *p2->p_sigacts = p1->p_addr->u_sigacts;
-                       splx(s);
+                       crit_exit();
                }
        } else {
                MALLOC(p2->p_procsig, struct procsig *, sizeof(struct procsig),
@@ -640,10 +640,10 @@ start_forked_proc(struct proc *p1, struct proc *p2)
        KASSERT(p2 && p2->p_stat == SIDL,
            ("cannot start forked process, bad status: %p", p2));
        resetpriority(p2);
-       (void) splhigh();
+       crit_enter();
        p2->p_stat = SRUN;
        setrunqueue(p2);
-       (void) spl0();
+       crit_exit();
 
        /*
         * Now can be swapped.
index cdbb2e7..40b3998 100644 (file)
@@ -24,7 +24,7 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/kern/kern_intr.c,v 1.24.2.1 2001/10/14 20:05:50 luigi Exp $
- * $DragonFly: src/sys/kern/kern_intr.c,v 1.20 2005/06/01 17:43:42 dillon Exp $
+ * $DragonFly: src/sys/kern/kern_intr.c,v 1.21 2005/06/06 15:02:27 dillon Exp $
  *
  */
 
@@ -74,18 +74,6 @@ SYSCTL_INT(_kern, OID_AUTO, livelock_limit,
 SYSCTL_INT(_kern, OID_AUTO, livelock_fallback,
         CTLFLAG_RW, &livelock_fallback, 0, "Livelock interrupt fallback rate");
 
-/*
- * TEMPORARY sysctl to allow interrupt handlers to run without the critical
- * section (if set to 0).
- *
- * SEQUENCE OF EVENTS: default to prior operation, testing, change default
- * to 0, lots more testing, then make operation without a critical section
- * mandatory and remove the sysctl code and variable.
- */
-static int int_use_crit_section = 1;
-SYSCTL_INT(_kern, OID_AUTO, int_use_crit_section,
-        CTLFLAG_RW, &int_use_crit_section, 0, "Run interrupts entirely within a critical section");
-
 static void ithread_handler(void *arg);
 
 /*
@@ -298,8 +286,6 @@ ithread_handler(void *arg)
     intrec_t *nrec;
     struct random_softc *sc = &irandom_ary[intr];
     globaldata_t gd = mycpu;
-    int in_crit_section;       /* REMOVE WHEN TESTING COMPLETE */
-    intrmask_t s;
 
     /*
      * The loop must be entered with one critical section held.
@@ -308,31 +294,29 @@ ithread_handler(void *arg)
 
     for (;;) {
        /*
-        * Deal with the sysctl variable allowing the interrupt thread to run
-        * without a critical section.  Once this is proven out it will
-        * become the default.  Note that a critical section is always
-        * held as of the top of the loop.
-        */
-       in_crit_section = int_use_crit_section;
-       if (in_crit_section == 0)
-           crit_exit_gd(gd);
-
-       /*
         * We can get woken up by the livelock periodic code too, run the 
         * handlers only if there is a real interrupt pending.  XXX
         *
         * Clear irunning[] prior to running the handlers to interlock
         * again new events occuring during processing of existing events.
+        *
+        * For now run each handler in a critical section.
         */
        irunning[intr] = 0;
        for (rec = *list; rec; rec = nrec) {
            nrec = rec->next;
-           s = splq(*rec->maskptr);
            rec->handler(rec->argument);
-           splx(s);
        }
 
        /*
+        * Do a quick exit/enter to catch any higher-priority
+        * interrupt sources and so user/system/interrupt statistics
+        * work for interrupt threads.
+        */
+       crit_exit_gd(gd);
+       crit_enter_gd(gd);
+
+       /*
         * This is our interrupt hook to add rate randomness to the random
         * number generator.
         */
@@ -412,16 +396,11 @@ ithread_handler(void *arg)
         * section safe and must be handled by the platform specific
         * ithread_done() routine.
         */
-       if (in_crit_section) {
-           if (irunning[intr] == 0)
-               ithread_done(intr);
-       } else {
-           crit_enter_gd(gd);
-           if (irunning[intr] == 0)
-               ithread_done(intr);
-       }
+       if (irunning[intr] == 0)
+           ithread_done(intr);
        /* must be in critical section on loop */
     }
+    /* not reached */
 }
 
 /* 
index 7dc9c1b..b612a6e 100644 (file)
@@ -39,7 +39,7 @@
  *
  *     @(#)kern_lock.c 8.18 (Berkeley) 5/21/95
  * $FreeBSD: src/sys/kern/kern_lock.c,v 1.31.2.3 2001/12/25 01:44:44 dillon Exp $
- * $DragonFly: src/sys/kern/kern_lock.c,v 1.13 2005/01/19 18:00:39 drhodus Exp $
+ * $DragonFly: src/sys/kern/kern_lock.c,v 1.14 2005/06/06 15:02:27 dillon Exp $
  */
 
 #include "opt_lint.h"
@@ -50,6 +50,7 @@
 #include <sys/proc.h>
 #include <sys/lock.h>
 #include <sys/sysctl.h>
+#include <sys/thread2.h>
 
 /*
  * 0: no warnings, 1: warnings, 2: panic
@@ -108,7 +109,7 @@ shareunlock(struct lock *lkp, int decr) {
 static int
 acquire(struct lock *lkp, int extflags, int wanted) 
 {
-       int s, error;
+       int error;
 
        if ((extflags & LK_NOWAIT) && (lkp->lk_flags & wanted)) {
                return EBUSY;
@@ -119,7 +120,7 @@ acquire(struct lock *lkp, int extflags, int wanted)
                        return 0;
        }
 
-       s = splhigh();
+       crit_enter();
        while ((lkp->lk_flags & wanted) != 0) {
                lkp->lk_flags |= LK_WAIT_NONZERO;
                lkp->lk_waitcount++;
@@ -133,15 +134,15 @@ acquire(struct lock *lkp, int extflags, int wanted)
                        lkp->lk_waitcount--;
                }
                if (error) {
-                       splx(s);
+                       crit_exit();
                        return error;
                }
                if (extflags & LK_SLEEPFAIL) {
-                       splx(s);
+                       crit_exit();
                        return ENOLCK;
                }
        }
-       splx(s);
+       crit_exit();
        return 0;
 }
 
index 9679a56..1eefbd8 100644 (file)
@@ -36,7 +36,7 @@
  *     Copyright (c) 1998 David Greenman.  All rights reserved.
  *     src/sys/kern/kern_sfbuf.c,v 1.7 2004/05/13 19:46:18 dillon
  *
- * $DragonFly: src/sys/kern/kern_msfbuf.c,v 1.13 2005/04/20 10:24:48 hmp Exp $
+ * $DragonFly: src/sys/kern/kern_msfbuf.c,v 1.14 2005/06/06 15:02:27 dillon Exp $
  */
 /*
  * MSFBUFs cache linear multi-page ephermal mappings and operate similar
@@ -410,8 +410,6 @@ msf_buf_ref(struct msf_buf *msf)
  * and release resources back to the system.  Note that the sfbuf's
  * removal from the freelist is delayed, so it may in fact already be
  * on the free list.  This is the optimal (and most likely) scenario.
- *
- * Must be called at splimp.
  */
 void
 msf_buf_free(struct msf_buf *msf)
index cc79a5a..1921794 100644 (file)
@@ -17,7 +17,7 @@
  *    are met.
  *
  * $FreeBSD: src/sys/kern/kern_physio.c,v 1.46.2.4 2003/11/14 09:51:47 simokawa Exp $
- * $DragonFly: src/sys/kern/kern_physio.c,v 1.9 2004/12/31 22:30:19 dillon Exp $
+ * $DragonFly: src/sys/kern/kern_physio.c,v 1.10 2005/06/06 15:02:28 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -47,7 +47,6 @@ physio(dev_t dev, struct uio *uio, int ioflag)
 {
        int i;
        int error;
-       int spl;
        int chk_blockno;
        caddr_t sa;
        off_t blockno;
@@ -122,10 +121,10 @@ physio(dev_t dev, struct uio *uio, int ioflag)
                                }
 
                        BUF_STRATEGY(bp, 0);
-                       spl = splbio();
+                       crit_enter();
                        while ((bp->b_flags & B_DONE) == 0)
                                tsleep((caddr_t)bp, 0, "physstr", 0);
-                       splx(spl);
+                       crit_exit();
 
                        if (uio->uio_segflg == UIO_USERSPACE)
                                vunmapbuf(bp);
index c1440e1..b6e9305 100644 (file)
@@ -25,7 +25,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/kern/kern_poll.c,v 1.2.2.4 2002/06/27 23:26:33 luigi Exp $
- * $DragonFly: src/sys/kern/kern_poll.c,v 1.17 2005/06/01 20:47:14 joerg Exp $
+ * $DragonFly: src/sys/kern/kern_poll.c,v 1.18 2005/06/06 15:02:28 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -252,8 +252,8 @@ netisr_pollmore(struct netmsg *msg)
 {
        struct timeval t;
        int kern_load;
-       int s = splhigh();
 
+       crit_enter();
        lwkt_replymsg(&msg->nm_lmsg, 0);
        phase = 5;
        if (residual_burst > 0) {
@@ -290,17 +290,19 @@ netisr_pollmore(struct netmsg *msg)
                phase = 6;
        }
 out:
-       splx(s);
+       crit_exit();
        return(EASYNC);
 }
 
 /*
  * netisr_poll is scheduled by schednetisr when appropriate, typically once
- * per tick. It is called at splnet() so first thing to do is to upgrade to
- * splimp(), and call all registered handlers.
+ * per tick.
  *
  * Note that the message is replied immediately in order to allow a new
  * ISR to be scheduled in the handler.
+ *
+ * XXX each registration should indicate whether it needs a critical
+ * section to operate.
  */
 /* ARGSUSED */
 static int
@@ -309,10 +311,9 @@ netisr_poll(struct netmsg *msg)
        static int reg_frac_count;
        int i, cycles;
        enum poll_cmd arg = POLL_ONLY;
-       int s;
 
        lwkt_replymsg(&msg->nm_lmsg, 0);
-       s = splimp();
+       crit_enter();
        phase = 3;
        if (residual_burst == 0) { /* first call in this tick */
                microuptime(&poll_start_t);
@@ -377,7 +378,7 @@ netisr_poll(struct netmsg *msg)
        }
        schednetisr(NETISR_POLLMORE);
        phase = 4;
-       splx(s);
+       crit_exit();
        return(EASYNC);
 }
 
index 6b8623d..2911a07 100644 (file)
@@ -2,7 +2,7 @@
  * kern_random.c -- A strong random number generator
  *
  * $FreeBSD: src/sys/kern/kern_random.c,v 1.36.2.4 2002/09/17 17:11:57 sam Exp $
- * $DragonFly: src/sys/kern/Attic/kern_random.c,v 1.8 2005/06/01 17:43:42 dillon Exp $
+ * $DragonFly: src/sys/kern/Attic/kern_random.c,v 1.9 2005/06/06 15:02:28 dillon Exp $
  *
  * Version 0.95, last modified 18-Oct-95
  * 
@@ -48,6 +48,7 @@
 #include <sys/select.h>
 #include <sys/systm.h>
 #include <sys/systimer.h>
+#include <sys/thread2.h>
 
 #ifdef __i386__
 #include <i386/isa/icu.h>
@@ -363,17 +364,16 @@ add_true_randomness(int val)
 int
 random_poll(dev_t dev, int events, struct thread *td)
 {
-       int s;
        int revents = 0;
 
-       s = splhigh();
+       crit_enter();
        if (events & (POLLIN | POLLRDNORM)) {
                if (random_state.entropy_count >= 8)
                        revents |= events & (POLLIN | POLLRDNORM);
                else
                        selrecord(td, &random_state.rsel);
        }
-       splx(s);
+       crit_exit();
        if (events & (POLLOUT | POLLWRNORM))
                revents |= events & (POLLOUT | POLLWRNORM);     /* heh */
 
index b7c3e62..bd4648f 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.20 2004/05/03 16:06:26 joerg Exp $
+ * $DragonFly: src/sys/kern/kern_resource.c,v 1.21 2005/06/06 15:02:28 dillon Exp $
  */
 
 #include "opt_compat.h"
@@ -643,20 +643,19 @@ int
 chgsbsize(struct uidinfo *uip, u_long *hiwat, u_long to, rlim_t max)
 {
        rlim_t new;
-       int s;
 
-       s = splnet();
+       crit_enter();
        new = uip->ui_sbsize + to - *hiwat;
        /* don't allow them to exceed max, but allow subtraction */
        if (to > *hiwat && new > max) {
-               splx(s);
+               crit_exit();
                return (0);
        }
        uip->ui_sbsize = new;
        *hiwat = to;
        if (uip->ui_sbsize < 0)
                printf("negative sbsize for uid = %d\n", uip->ui_uid);
-       splx(s);
+       crit_exit();
        return (1);
 }
 
index c9103c0..087cd4a 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.36 2005/03/02 06:17:17 davidxu Exp $
+ * $DragonFly: src/sys/kern/kern_sig.c,v 1.37 2005/06/06 15:02:28 dillon Exp $
  */
 
 #include "opt_ktrace.h"
@@ -65,6 +65,7 @@
 #include <sys/malloc.h>
 #include <sys/unistd.h>
 #include <sys/kern_syscall.h>
+#include <sys/thread2.h>
 
 
 #include <machine/ipl.h>
@@ -260,7 +261,7 @@ kern_sigaction(int sig, struct sigaction *act, struct sigaction *oact)
                /*
                 * Change setting atomically.
                 */
-               splhigh();
+               crit_enter();
 
                ps->ps_catchmask[_SIG_IDX(sig)] = act->sa_mask;
                SIG_CANTMASK(ps->ps_catchmask[_SIG_IDX(sig)]);
@@ -331,7 +332,7 @@ kern_sigaction(int sig, struct sigaction *act, struct sigaction *oact)
                                SIGADDSET(p->p_sigcatch, sig);
                }
 
-               spl0();
+               crit_exit();
        }
        return (0);
 }
@@ -413,8 +414,7 @@ execsigs(struct proc *p)
  * kern_sigprocmask() - MP SAFE ONLY IF p == curproc
  *
  *     Manipulate signal mask.  This routine is MP SAFE *ONLY* if
- *     p == curproc.  Also remember that in order to remain MP SAFE
- *     no spl*() calls may be made.
+ *     p == curproc.
  */
 int
 kern_sigprocmask(int how, sigset_t *set, sigset_t *oset)
@@ -769,7 +769,7 @@ trapsignal(struct proc *p, int sig, u_long code)
 void
 psignal(struct proc *p, int sig)
 {
-       int s, prop;
+       int prop;
        sig_t action;
 
        if (sig > _SIG_MAXSIG || sig <= 0) {
@@ -777,9 +777,9 @@ psignal(struct proc *p, int sig)
                panic("psignal signal number");
        }
 
-       s = splhigh();
+       crit_enter();
        KNOTE(&p->p_klist, NOTE_SIGNAL | sig);
-       splx(s);
+       crit_exit();
 
        prop = sigprop(sig);
 
@@ -838,7 +838,9 @@ psignal(struct proc *p, int sig)
         */
        if (action == SIG_HOLD && (!(prop & SA_CONT) || p->p_stat != SSTOP))
                return;
-       s = splhigh();
+
+       crit_enter();
+
        switch (p->p_stat) {
        case SSLEEP:
                /*
@@ -995,7 +997,7 @@ psignal(struct proc *p, int sig)
 run:
        setrunnable(p);
 out:
-       splx(s);
+       crit_exit();
 }
 
 #ifdef SMP
@@ -1416,7 +1418,7 @@ postsig(int sig)
                 * mask from before the sigsuspend is what we want
                 * restored after the signal processing is completed.
                 */
-               splhigh();
+               crit_enter();
                if (p->p_flag & P_OLDMASK) {
                        returnmask = p->p_oldsigmask;
                        p->p_flag &= ~P_OLDMASK;
@@ -1438,7 +1440,7 @@ postsig(int sig)
                                SIGADDSET(p->p_sigignore, sig);
                        ps->ps_sigact[_SIG_IDX(sig)] = SIG_DFL;
                }
-               spl0();
+               crit_exit();
                p->p_stats->p_ru.ru_nsignals++;
                if (p->p_sig != sig) {
                        code = 0;
index 75e0efa..9ef2796 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.41 2005/01/14 02:20:22 dillon Exp $
+ * $DragonFly: src/sys/kern/kern_synch.c,v 1.42 2005/06/06 15:02:28 dillon Exp $
  */
 
 #include "opt_ktrace.h"
@@ -69,6 +69,7 @@ int   lbolt;
 int    sched_quantum;          /* Roundrobin scheduling quantum in ticks. */
 int    ncpus;
 int    ncpus2, ncpus2_shift, ncpus2_mask;
+int    safepri;
 
 static struct callout loadav_callout;
 static struct callout roundrobin_callout;
@@ -91,7 +92,6 @@ static void   loadav (void *arg);
 static void    roundrobin (void *arg);
 static void    schedcpu (void *arg);
 static void    updatepri (struct proc *p);
-static void    crit_panicints(void);
 
 static int
 sysctl_kern_quantum(SYSCTL_HANDLER_ARGS)
@@ -212,7 +212,6 @@ schedcpu(void *arg)
 {
        fixpt_t loadfac = averunnable.ldavg[0];
        struct proc *p;
-       int s;
        unsigned int ndecay;
 
        FOREACH_PROC_IN_SYSTEM(p) {
@@ -237,7 +236,7 @@ schedcpu(void *arg)
                if (p->p_slptime > 1)
                        continue;
                /* prevent state changes and protect run queue */
-               s = splhigh();
+               crit_enter();
                /*
                 * p_cpticks runs at ESTCPUFREQ but must be divided by the
                 * load average for par-100% use.  Higher p_interactive
@@ -271,7 +270,7 @@ schedcpu(void *arg)
                else
                        p->p_estcpu = 0;
                resetpriority(p);
-               splx(s);
+               crit_exit();
        }
        wakeup((caddr_t)&lbolt);
        callout_reset(&schedcpu_callout, hz, schedcpu, NULL);
@@ -307,13 +306,7 @@ static TAILQ_HEAD(slpquehead, thread) slpque[TABLESIZE];
 /*
  * During autoconfiguration or after a panic, a sleep will simply
  * lower the priority briefly to allow interrupts, then return.
- * The priority to be used (safepri) is machine-dependent, thus this
- * value is initialized and maintained in the machine-dependent layers.
- * This priority will typically be 0, or the lowest priority
- * that is safe for use on the interrupt stack; it can be made
- * higher to block network software interrupts after panics.
  */
-int safepri;
 
 void
 sleepinit(void)
@@ -347,6 +340,7 @@ tsleep(void *ident, int flags, const char *wmesg, int timo)
        struct proc *p = td->td_proc;           /* may be NULL */
        int sig = 0, catch = flags & PCATCH;
        int id = LOOKUP(ident);
+       int oldpri;
        struct callout thandle;
 
        /*
@@ -360,7 +354,11 @@ tsleep(void *ident, int flags, const char *wmesg, int timo)
                 * don't run any other procs or panic below,
                 * in case this is the idle process and already asleep.
                 */
-               crit_panicints();
+               splz();
+               oldpri = td->td_pri & TDPRI_MASK;
+               lwkt_setpri_self(safepri);
+               lwkt_switch();
+               lwkt_setpri_self(oldpri);
                return (0);
        }
        KKASSERT(td != &mycpu->gd_idlethread);  /* you must be kidding! */
@@ -673,9 +671,8 @@ mi_switch(struct proc *p)
 void
 setrunnable(struct proc *p)
 {
-       int s;
+       crit_enter();
 
-       s = splhigh();
        switch (p->p_stat) {
        case 0:
        case SRUN:
@@ -703,7 +700,7 @@ setrunnable(struct proc *p)
 #endif
        if (p->p_flag & P_INMEM)
                lwkt_schedule(p->p_thread);
-       splx(s);
+       crit_exit();
        if (p->p_slptime > 1)
                updatepri(p);
        p->p_slptime = 0;
@@ -892,17 +889,3 @@ schedulerclock(void *dummy)
        }
 }
 
-static
-void
-crit_panicints(void)
-{
-    int s;
-    int cpri;
-
-    s = splhigh();
-    cpri = crit_panic_save();
-    splx(safepri);
-    crit_panic_restore(cpri);
-    splx(s);
-}
-
index 8a2eba1..dc9d5a7 100644 (file)
@@ -70,7 +70,7 @@
  *
  *     From: @(#)kern_clock.c  8.5 (Berkeley) 1/21/94
  * $FreeBSD: src/sys/kern/kern_timeout.c,v 1.59.2.1 2001/11/13 18:24:52 archie Exp $
- * $DragonFly: src/sys/kern/kern_timeout.c,v 1.15 2005/06/03 23:57:32 dillon Exp $
+ * $DragonFly: src/sys/kern/kern_timeout.c,v 1.16 2005/06/06 15:02:28 dillon Exp $
  */
 /*
  * DRAGONFLY BGL STATUS
@@ -562,7 +562,6 @@ adjust_timeout_calltodo(struct timeval *time_change)
 {
        struct callout *p;
        unsigned long delta_ticks;
-       int s;
 
        /* 
         * How many ticks were we asleep?
@@ -590,7 +589,7 @@ adjust_timeout_calltodo(struct timeval *time_change)
         */
 
        /* don't collide with softclock() */
-       s = splhigh(); 
+       crit_enter();
        for (p = calltodo.c_next; p != NULL; p = p->c_next) {
                p->c_time -= delta_ticks;
 
@@ -601,7 +600,7 @@ adjust_timeout_calltodo(struct timeval *time_change)
                /* take back the ticks the timer didn't use (p->c_time <= 0) */
                delta_ticks = -p->c_time;
        }
-       splx(s);
+       crit_exit();
 
        return;
 }
index 572f4ac..c7a9087 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_xio.c,v 1.9 2005/03/02 18:42:08 hmp Exp $
+ * $DragonFly: src/sys/kern/kern_xio.c,v 1.10 2005/06/06 15:02:28 dillon Exp $
  */
 /*
  * Kernel XIO interface.  An initialized XIO is basically a collection of
@@ -97,7 +97,6 @@ xio_init_ubuf(xio_t xio, void *ubase, size_t ubytes, int flags)
     vm_page_t m;
     int i;
     int n;
-    int s;
     int vmprot;
 
     addr = trunc_page((vm_offset_t)ubase);
@@ -118,10 +117,10 @@ xio_init_ubuf(xio_t xio, void *ubase, size_t ubytes, int flags)
                break;
            if ((paddr = pmap_kextract(addr)) == 0)
                break;
-           s = splvm();
+           crit_enter();
            m = PHYS_TO_VM_PAGE(paddr);
            vm_page_hold(m);
-           splx(s);
+           crit_exit();
            xio->xio_pages[i] = m;
            ubytes -= n;
            xio->xio_bytes += n;
@@ -157,7 +156,6 @@ xio_init_kbuf(xio_t xio, void *kbase, size_t kbytes)
     vm_page_t m;
     int i;
     int n;
-    int s;
 
     addr = trunc_page((vm_offset_t)kbase);
     xio->xio_flags = 0;
@@ -170,10 +168,10 @@ xio_init_kbuf(xio_t xio, void *kbase, size_t kbytes)
     for (i = 0; n && i < XIO_INTERNAL_PAGES; ++i) {
        if ((paddr = pmap_kextract(addr)) == 0)
            break;
-       s = splvm();
+       crit_enter();
        m = PHYS_TO_VM_PAGE(paddr);
        vm_page_hold(m);
-       splx(s);
+       crit_exit();
        xio->xio_pages[i] = m;
        kbytes -= n;
        xio->xio_bytes += n;
@@ -202,15 +200,14 @@ void
 xio_release(xio_t xio)
 {
     int i;
-    int s;
     vm_page_t m;
 
-    s = splvm();
+    crit_enter();
     for (i = 0; i < xio->xio_npages; ++i) {
        m = xio->xio_pages[i];
        vm_page_unhold(m);
     }
-    splx(s);
+    crit_exit();
     xio->xio_offset = 0;
     xio->xio_npages = 0;
     xio->xio_bytes = 0;
index 94a60b7..ce65964 100644 (file)
@@ -44,7 +44,7 @@
  *     from: @(#)ufs_disksubr.c        7.16 (Berkeley) 5/4/91
  *     from: ufs_disksubr.c,v 1.8 1994/06/07 01:21:39 phk Exp $
  * $FreeBSD: src/sys/kern/subr_diskslice.c,v 1.82.2.6 2001/07/24 09:49:41 dd Exp $
- * $DragonFly: src/sys/kern/subr_diskslice.c,v 1.9 2005/04/30 23:04:21 swildner Exp $
+ * $DragonFly: src/sys/kern/subr_diskslice.c,v 1.10 2005/06/06 15:02:28 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -60,6 +60,7 @@
 #include <sys/syslog.h>
 #include <sys/vnode.h>
 #include <sys/device.h>
+#include <sys/thread2.h>
 
 #include <vfs/ufs/fs.h>
 
@@ -144,7 +145,6 @@ dscheck(struct buf *bp, struct diskslices *ssp)
        daddr_t secno;
        daddr_t slicerel_secno;
        struct diskslice *sp;
-       int s;
 
        blkno = bp->b_blkno;
        if (blkno < 0) {
@@ -259,9 +259,9 @@ dscheck(struct buf *bp, struct diskslices *ssp)
                         * temporarily corrupting the in-core copy.
                         */
                        if (bp->b_vp != NULL) {
-                               s = splbio();
+                               crit_enter();
                                bp->b_vp->v_numoutput++;
-                               splx(s);
+                               crit_exit();
                        }
                        /* XXX need name here. */
                        msg = fixlabel((char *)NULL, sp,
index 04c12e4..9b9e683 100644 (file)
@@ -32,7 +32,7 @@
  *
  *     @(#)subr_log.c  8.1 (Berkeley) 6/10/93
  * $FreeBSD: src/sys/kern/subr_log.c,v 1.39.2.2 2001/06/02 08:11:25 phk Exp $
- * $DragonFly: src/sys/kern/subr_log.c,v 1.7 2004/05/19 22:52:58 dillon Exp $
+ * $DragonFly: src/sys/kern/subr_log.c,v 1.8 2005/06/06 15:02:28 dillon Exp $
  */
 
 /*
@@ -52,6 +52,7 @@
 #include <sys/poll.h>
 #include <sys/filedesc.h>
 #include <sys/sysctl.h>
+#include <sys/thread2.h>
 
 #define LOG_ASYNC      0x04
 #define LOG_RDWAIT     0x08
@@ -133,22 +134,21 @@ logread(dev_t dev, struct uio *uio, int flag)
 {
        struct msgbuf *mbp = msgbufp;
        long l;
-       int s;
        int error = 0;
 
-       s = splhigh();
+       crit_enter();
        while (mbp->msg_bufr == mbp->msg_bufx) {
                if (flag & IO_NDELAY) {
-                       splx(s);
+                       crit_exit();
                        return (EWOULDBLOCK);
                }
                logsoftc.sc_state |= LOG_RDWAIT;
                if ((error = tsleep((caddr_t)mbp, PCATCH, "klog", 0))) {
-                       splx(s);
+                       crit_exit();
                        return (error);
                }
        }
-       splx(s);
+       crit_exit();
        logsoftc.sc_state &= ~LOG_RDWAIT;
 
        while (uio->uio_resid > 0) {
@@ -173,18 +173,16 @@ logread(dev_t dev, struct uio *uio, int flag)
 static int
 logpoll(dev_t dev, int events, struct thread *td)
 {
-       int s;
        int revents = 0;
 
-       s = splhigh();
-
+       crit_enter();
        if (events & (POLLIN | POLLRDNORM)) {
                if (msgbufp->msg_bufr != msgbufp->msg_bufx)
                        revents |= events & (POLLIN | POLLRDNORM);
                else
                        selrecord(td, &logsoftc.sc_selp);
        }
-       splx(s);
+       crit_exit();
        return (revents);
 }
 
@@ -216,15 +214,14 @@ static    int
 logioctl(dev_t dev, u_long com, caddr_t data, int flag, struct thread *td)
 {
        long l;
-       int s;
 
        switch (com) {
 
        /* return number of characters immediately available */
        case FIONREAD:
-               s = splhigh();
+               crit_enter();
                l = msgbufp->msg_bufx - msgbufp->msg_bufr;
-               splx(s);
+               crit_exit();
                if (l < 0)
                        l += msgbufp->msg_size;
                *(int *)data = l;
index 545ec26..71e79a4 100644 (file)
@@ -32,7 +32,7 @@
  *
  *     @(#)subr_prof.c 8.3 (Berkeley) 9/23/93
  * $FreeBSD: src/sys/kern/subr_prof.c,v 1.32.2.2 2000/08/03 00:09:32 ps Exp $
- * $DragonFly: src/sys/kern/subr_prof.c,v 1.9 2004/06/01 22:19:30 dillon Exp $
+ * $DragonFly: src/sys/kern/subr_prof.c,v 1.10 2005/06/06 15:02:28 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -42,6 +42,7 @@
 #include <sys/proc.h>
 #include <sys/resourcevar.h>
 #include <sys/sysctl.h>
+#include <sys/thread2.h>
 
 #include <machine/ipl.h>
 #include <machine/cpu.h>
@@ -348,7 +349,6 @@ profil(struct profil_args *uap)
 {
        struct proc *p = curproc;
        struct uprof *upp;
-       int s;
 
        if (uap->scale > (1 << 16))
                return (EINVAL);
@@ -359,13 +359,13 @@ profil(struct profil_args *uap)
        upp = &p->p_stats->p_prof;
 
        /* Block profile interrupts while changing state. */
-       s = splstatclock();
+       crit_enter();
        upp->pr_off = uap->offset;
        upp->pr_scale = uap->scale;
        upp->pr_base = uap->samples;
        upp->pr_size = uap->size;
        startprofclock(p);
-       splx(s);
+       crit_exit();
 
        return (0);
 }
index ad1d6b0..e9081e3 100644 (file)
@@ -27,7 +27,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/kern/subr_rman.c,v 1.10.2.1 2001/06/05 08:06:08 imp Exp $
- * $DragonFly: src/sys/kern/subr_rman.c,v 1.6 2004/03/01 06:33:17 dillon Exp $
+ * $DragonFly: src/sys/kern/subr_rman.c,v 1.7 2005/06/06 15:02:28 dillon Exp $
  */
 
 /*
@@ -461,7 +461,7 @@ rman_activate_resource(struct resource *r)
 int
 rman_await_resource(struct resource *r, lwkt_tokref_t ilock, int slpflags, int timo)
 {
-       int     rv, s;
+       int     rv;
        struct  resource *whohas;
        struct  rman *rm;
 
@@ -475,20 +475,20 @@ rman_await_resource(struct resource *r, lwkt_tokref_t ilock, int slpflags, int t
                if (r->r_sharehead == 0)
                        panic("rman_await_resource");
                /*
-                * splhigh hopefully will prevent a race between
-                * lwkt_reltoken and tsleep where a process
+                * A critical section will hopefully will prevent a race 
+                * between lwkt_reltoken and tsleep where a process
                 * could conceivably get in and release the resource
                 * before we have a chance to sleep on it. YYY
                 */
-               s = splhigh();
+               crit_enter();
                whohas->r_flags |= RF_WANTED;
                rv = tsleep(r->r_sharehead, slpflags, "rmwait", timo);
                if (rv) {
                        lwkt_reltoken(ilock);
-                       splx(s);
+                       crit_exit();
                        return rv;
                }
-               splx(s);
+               crit_exit();
        }
 }
 
index 0e84361..76f574f 100644 (file)
@@ -24,7 +24,7 @@
  * SUCH DAMAGE.
  *
  *      $FreeBSD: src/sys/kern/subr_taskqueue.c,v 1.1.2.3 2003/09/10 00:40:39 ken Exp $
- *     $DragonFly: src/sys/kern/subr_taskqueue.c,v 1.5 2005/02/01 22:41:26 dillon Exp $
+ *     $DragonFly: src/sys/kern/subr_taskqueue.c,v 1.6 2005/06/06 15:02:28 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -35,6 +35,7 @@
 #include <sys/interrupt.h>
 #include <sys/malloc.h>
 #include <sys/kthread.h>
+#include <sys/thread2.h>
 
 #include <machine/ipl.h>
 
@@ -58,7 +59,6 @@ taskqueue_create(const char *name, int mflags,
 {
        struct taskqueue *queue;
        static int once = 1;
-       int s;
 
        queue = malloc(sizeof(struct taskqueue), M_TASKQUEUE, mflags);
        if (!queue)
@@ -69,13 +69,13 @@ taskqueue_create(const char *name, int mflags,
        queue->tq_context = context;
        queue->tq_draining = 0;
 
-       s = splhigh();
+       crit_enter();
        if (once) {
                STAILQ_INIT(&taskqueue_queues);
                once = 0;
        }
        STAILQ_INSERT_TAIL(&taskqueue_queues, queue, tq_link);
-       splx(s);
+       crit_exit();
 
        return queue;
 }
@@ -83,15 +83,15 @@ taskqueue_create(const char *name, int mflags,
 void
 taskqueue_free(struct taskqueue *queue)
 {
-       int s = splhigh();
+       crit_enter();
        queue->tq_draining = 1;
-       splx(s);
+       crit_exit();
 
        taskqueue_run(queue);
 
-       s = splhigh();
+       crit_enter();
        STAILQ_REMOVE(&taskqueue_queues, queue, taskqueue, tq_link);
-       splx(s);
+       crit_exit();
 
        free(queue, M_TASKQUEUE);
 }
@@ -100,15 +100,15 @@ struct taskqueue *
 taskqueue_find(const char *name)
 {
        struct taskqueue *queue;
-       int s;
 
-       s = splhigh();
-       STAILQ_FOREACH(queue, &taskqueue_queues, tq_link)
+       crit_enter();
+       STAILQ_FOREACH(queue, &taskqueue_queues, tq_link) {
                if (!strcmp(queue->tq_name, name)) {
-                       splx(s);
+                       crit_exit();
                        return queue;
                }
-       splx(s);
+       }
+       crit_exit();
        return 0;
 }
 
@@ -118,13 +118,13 @@ taskqueue_enqueue(struct taskqueue *queue, struct task *task)
        struct task *ins;
        struct task *prev;
 
-       int s = splhigh();
+       crit_enter();
 
        /*
         * Don't allow new tasks on a queue which is being freed.
         */
        if (queue->tq_draining) {
-               splx(s);
+               crit_exit();
                return EPIPE;
        }
 
@@ -133,7 +133,7 @@ taskqueue_enqueue(struct taskqueue *queue, struct task *task)
         */
        if (task->ta_pending) {
                task->ta_pending++;
-               splx(s);
+               crit_exit();
                return 0;
        }
 
@@ -160,7 +160,7 @@ taskqueue_enqueue(struct taskqueue *queue, struct task *task)
        if (queue->tq_enqueue)
                queue->tq_enqueue(queue->tq_context);
 
-       splx(s);
+       crit_exit();
 
        return 0;
 }
@@ -168,11 +168,10 @@ taskqueue_enqueue(struct taskqueue *queue, struct task *task)
 void
 taskqueue_run(struct taskqueue *queue)
 {
-       int s;
        struct task *task;
        int pending;
 
-       s = splhigh();
+       crit_enter();
        while (STAILQ_FIRST(&queue->tq_queue)) {
                /*
                 * Carefully remove the first task from the queue and
@@ -182,13 +181,13 @@ taskqueue_run(struct taskqueue *queue)
                STAILQ_REMOVE_HEAD(&queue->tq_queue, ta_link);
                pending = task->ta_pending;
                task->ta_pending = 0;
-               splx(s);
+               crit_exit();
 
                task->ta_func(task->ta_context, pending);
 
-               s = splhigh();
+               crit_enter();
        }
-       splx(s);
+       crit_exit();
 }
 
 static void
@@ -206,14 +205,12 @@ taskqueue_swi_run(void *arg)
 static void
 taskqueue_kthread(void *arg)
 {
-       int s;
-
        for (;;) {
                taskqueue_run(taskqueue_thread);
-               s = splhigh();
+               crit_enter();
                if (STAILQ_EMPTY(&taskqueue_thread->tq_queue))
                        tsleep(&taskqueue_thread, 0, "tqthr", 0);
-               splx(s);
+               crit_exit();
        }
 }
 
index ff4e17d..f22d3db 100644 (file)
@@ -37,7 +37,7 @@
  *
  *     @(#)sys_generic.c       8.5 (Berkeley) 1/21/94
  * $FreeBSD: src/sys/kern/sys_generic.c,v 1.55.2.10 2001/03/17 10:39:32 peter Exp $
- * $DragonFly: src/sys/kern/sys_generic.c,v 1.20 2005/03/29 00:35:55 drhodus Exp $
+ * $DragonFly: src/sys/kern/sys_generic.c,v 1.21 2005/06/06 15:02:28 dillon Exp $
  */
 
 #include "opt_ktrace.h"
@@ -637,7 +637,7 @@ select(struct select_args *uap)
        fd_mask s_selbits[howmany(2048, NFDBITS)];
        fd_mask *ibits[3], *obits[3], *selbits, *sbp;
        struct timeval atv, rtv, ttv;
-       int s, ncoll, error, timo;
+       int ncoll, error, timo;
        u_int nbufbytes, ncpbytes, nfdbits;
 
        if (uap->nd < 0)
@@ -720,16 +720,16 @@ retry:
                timo = ttv.tv_sec > 24 * 60 * 60 ?
                    24 * 60 * 60 * hz : tvtohz_high(&ttv);
        }
-       s = splhigh();
+       crit_enter();
        if ((p->p_flag & P_SELECT) == 0 || nselcoll != ncoll) {
-               splx(s);
+               crit_exit();
                goto retry;
        }
        p->p_flag &= ~P_SELECT;
 
        error = tsleep((caddr_t)&selwait, PCATCH, "select", timo);
        
-       splx(s);
+       crit_exit();
        if (error == 0)
                goto retry;
 done:
@@ -800,7 +800,7 @@ poll(struct poll_args *uap)
        struct pollfd *bits;
        struct pollfd smallbits[32];
        struct timeval atv, rtv, ttv;
-       int s, ncoll, error = 0, timo;
+       int ncoll, error = 0, timo;
        u_int nfds;
        size_t ni;
        struct proc *p = curproc;
@@ -852,14 +852,14 @@ retry:
                timo = ttv.tv_sec > 24 * 60 * 60 ?
                    24 * 60 * 60 * hz : tvtohz_high(&ttv);
        } 
-       s = splhigh(); 
+       crit_enter();
        if ((p->p_flag & P_SELECT) == 0 || nselcoll != ncoll) {
-               splx(s);
+               crit_exit();
                goto retry;
        }
        p->p_flag &= ~P_SELECT;
        error = tsleep((caddr_t)&selwait, PCATCH, "poll", timo);
-       splx(s);
+       crit_exit();
        if (error == 0)
                goto retry;
 done:
@@ -964,7 +964,6 @@ void
 selwakeup(struct selinfo *sip)
 {
        struct proc *p;
-       int s;
 
        if (sip->si_pid == 0)
                return;
@@ -976,7 +975,7 @@ selwakeup(struct selinfo *sip)
        p = pfind(sip->si_pid);
        sip->si_pid = 0;
        if (p != NULL) {
-               s = splhigh();
+               crit_enter();
                if (p->p_wchan == (caddr_t)&selwait) {
                        if (p->p_stat == SSLEEP)
                                setrunnable(p);
@@ -984,7 +983,7 @@ selwakeup(struct selinfo *sip)
                                unsleep(p->p_thread);
                } else if (p->p_flag & P_SELECT)
                        p->p_flag &= ~P_SELECT;
-               splx(s);
+               crit_exit();
        }
 }
 
index 5ca2193..093a1f5 100644 (file)
@@ -29,7 +29,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/kern/sys_process.c,v 1.51.2.6 2003/01/08 03:06:45 kan Exp $
- * $DragonFly: src/sys/kern/sys_process.c,v 1.14 2003/10/15 21:52:38 dillon Exp $
+ * $DragonFly: src/sys/kern/sys_process.c,v 1.15 2005/06/06 15:02:28 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -439,14 +439,14 @@ kern_ptrace(struct proc *curp, int req, pid_t pid, void *addr, int data, int *re
 
        sendsig:
                /* deliver or queue signal */
-               s = splhigh();
+               crit_enter();
                if (p->p_stat == SSTOP) {
                        p->p_xstat = data;
                        setrunnable(p);
                } else if (data) {
                        psignal(p, data);
                }
-               splx(s);
+               crit_exit();
                return 0;
 
        case PT_WRITE_I:
index 26193db..ce79b5e 100644 (file)
@@ -37,7 +37,7 @@
  *
  *     @(#)tty.c       8.8 (Berkeley) 1/21/94
  * $FreeBSD: src/sys/kern/tty.c,v 1.129.2.5 2002/03/11 01:32:31 dd Exp $
- * $DragonFly: src/sys/kern/tty.c,v 1.16 2004/12/29 02:40:52 dillon Exp $
+ * $DragonFly: src/sys/kern/tty.c,v 1.17 2005/06/06 15:02:28 dillon Exp $
  */
 
 /*-
@@ -219,9 +219,7 @@ ttyopen(device, tp)
        dev_t device;
        struct tty *tp;
 {
-       int s;
-
-       s = spltty();
+       crit_enter();
        tp->t_dev = device;
        if (!ISSET(tp->t_state, TS_ISOPEN)) {
                SET(tp->t_state, TS_ISOPEN);
@@ -230,7 +228,7 @@ ttyopen(device, tp)
                bzero(&tp->t_winsize, sizeof(tp->t_winsize));
        }
        ttsetwater(tp);
-       splx(s);
+       crit_exit();
        return (0);
 }
 
@@ -247,10 +245,8 @@ int
 ttyclose(tp)
        struct tty *tp;
 {
-       int s;
-
        funsetown(tp->t_sigio);
-       s = spltty();
+       crit_enter();
        if (constty == tp)
                constty = NULL;
 
@@ -263,7 +259,7 @@ ttyclose(tp)
        tp->t_line = TTYDISC;
        ttyclearsession(tp);
        tp->t_state = 0;
-       splx(s);
+       crit_exit();
        return (0);
 }
 
@@ -677,7 +673,7 @@ ttyoutput(c, tp)
        struct tty *tp;
 {
        tcflag_t oflag;
-       int col, s;
+       int col;
 
        oflag = tp->t_oflag;
        if (!ISSET(oflag, OPOST)) {
@@ -700,11 +696,11 @@ ttyoutput(c, tp)
            ISSET(oflag, OXTABS) && !ISSET(tp->t_lflag, EXTPROC)) {
                c = 8 - (tp->t_column & 7);
                if (!ISSET(tp->t_lflag, FLUSHO)) {
-                       s = spltty();           /* Don't interrupt tabs. */
+                       crit_enter();           /* Don't interrupt tabs. */
                        c -= b_to_q("        ", c, &tp->t_outq);
                        tk_nout += c;
                        tp->t_outcc += c;
-                       splx(s);
+                       crit_exit();
                }
                tp->t_column += c;
                return (c ? -1 : '\t');
@@ -771,7 +767,7 @@ ttioctl(struct tty *tp, u_long cmd, void *data, int flag)
 {
        struct thread *td = curthread;
        struct proc *p = td->td_proc;
-       int s, error;
+       int error;
 
        KKASSERT(p);
 
@@ -825,19 +821,19 @@ ttioctl(struct tty *tp, u_long cmd, void *data, int flag)
 
        switch (cmd) {                  /* Process the ioctl. */
        case FIOASYNC:                  /* set/clear async i/o */
-               s = spltty();
+               crit_enter();
                if (*(int *)data)
                        SET(tp->t_state, TS_ASYNC);
                else
                        CLR(tp->t_state, TS_ASYNC);
-               splx(s);
+               crit_exit();
                break;
        case FIONBIO:                   /* set/clear non-blocking i/o */
                break;                  /* XXX: delete. */
        case FIONREAD:                  /* get # bytes to read */
-               s = spltty();
+               crit_enter();
                *(int *)data = ttnread(tp);
-               splx(s);
+               crit_exit();
                break;
 
        case FIOSETOWN:
@@ -859,9 +855,9 @@ ttioctl(struct tty *tp, u_long cmd, void *data, int flag)
                break;
 
        case TIOCEXCL:                  /* set exclusive use of tty */
-               s = spltty();
+               crit_enter();
                SET(tp->t_state, TS_XCLUDE);
-               splx(s);
+               crit_exit();
                break;
        case TIOCFLUSH: {               /* flush buffers */
                int flags = *(int *)data;
@@ -910,15 +906,15 @@ ttioctl(struct tty *tp, u_long cmd, void *data, int flag)
                break;
 #ifdef TIOCHPCL
        case TIOCHPCL:                  /* hang up on last close */
-               s = spltty();
+               crit_enter();
                SET(tp->t_cflag, HUPCL);
-               splx(s);
+               crit_exit();
                break;
 #endif
        case TIOCNXCL:                  /* reset exclusive use of tty */
-               s = spltty();
+               crit_enter();
                CLR(tp->t_state, TS_XCLUDE);
-               splx(s);
+               crit_exit();
                break;
        case TIOCOUTQ:                  /* output queue size */
                *(int *)data = tp->t_outq.c_cc;
@@ -934,11 +930,11 @@ ttioctl(struct tty *tp, u_long cmd, void *data, int flag)
                        t->c_ispeed = tp->t_ospeed;
                if (t->c_ispeed == 0)
                        return (EINVAL);
-               s = spltty();
+               crit_enter();
                if (cmd == TIOCSETAW || cmd == TIOCSETAF) {
                        error = ttywait(tp);
                        if (error) {
-                               splx(s);
+                               crit_exit();
                                return (error);
                        }
                        if (cmd == TIOCSETAF)
@@ -949,7 +945,7 @@ ttioctl(struct tty *tp, u_long cmd, void *data, int flag)
                         * Set device hardware.
                         */
                        if (tp->t_param && (error = (*tp->t_param)(tp, t))) {
-                               splx(s);
+                               crit_exit();
                                return (error);
                        }
                        if (ISSET(t->c_cflag, CLOCAL) &&
@@ -1017,7 +1013,7 @@ ttioctl(struct tty *tp, u_long cmd, void *data, int flag)
                    t->c_cc[VTIME] != tp->t_cc[VTIME])
                        ttwakeup(tp);
                bcopy(t->c_cc, tp->t_cc, sizeof(t->c_cc));
-               splx(s);
+               crit_exit();
                break;
        }
        case TIOCSETD: {                /* set line discipline */
@@ -1027,45 +1023,45 @@ ttioctl(struct tty *tp, u_long cmd, void *data, int flag)
                if ((u_int)t >= nlinesw)
                        return (ENXIO);
                if (t != tp->t_line) {
-                       s = spltty();
+                       crit_enter();
                        (*linesw[tp->t_line].l_close)(tp, flag);
                        error = (*linesw[t].l_open)(device, tp);
                        if (error) {
                                (void)(*linesw[tp->t_line].l_open)(device, tp);
-                               splx(s);
+                               crit_exit();
                                return (error);
                        }
                        tp->t_line = t;
-                       splx(s);
+                       crit_exit();
                }
                break;
        }
        case TIOCSTART:                 /* start output, like ^Q */
-               s = spltty();
+               crit_enter();
                if (ISSET(tp->t_state, TS_TTSTOP) ||
                    ISSET(tp->t_lflag, FLUSHO)) {
                        CLR(tp->t_lflag, FLUSHO);
                        CLR(tp->t_state, TS_TTSTOP);
                        ttstart(tp);
                }
-               splx(s);
+               crit_exit();
                break;
        case TIOCSTI:                   /* simulate terminal input */
                if ((flag & FREAD) == 0 && suser(td))
                        return (EPERM);
                if (!isctty(p, tp) && suser(td))
                        return (EACCES);
-               s = spltty();
+               crit_enter();
                (*linesw[tp->t_line].l_rint)(*(u_char *)data, tp);
-               splx(s);
+               crit_exit();
                break;
        case TIOCSTOP:                  /* stop output, like ^S */
-               s = spltty();
+               crit_enter();
                if (!ISSET(tp->t_state, TS_TTSTOP)) {
                        SET(tp->t_state, TS_TTSTOP);
                        (*tp->t_stop)(tp, 0);
                }
-               splx(s);
+               crit_exit();
                break;
        case TIOCSCTTY:                 /* become controlling tty */
                /* Session ctty vnode pointer set in vnode layer. */
@@ -1089,9 +1085,9 @@ ttioctl(struct tty *tp, u_long cmd, void *data, int flag)
                break;
        }
        case TIOCSTAT:                  /* simulate control-T */
-               s = spltty();
+               crit_enter();
                ttyinfo(tp);
-               splx(s);
+               crit_exit();
                break;
        case TIOCSWINSZ:                /* set window size */
                if (bcmp((caddr_t)&tp->t_winsize, data,
@@ -1127,7 +1123,6 @@ ttypoll(dev, events, td)
        int events;
        struct thread *td;
 {
-       int s;
        int revents = 0;
        struct tty *tp;
 
@@ -1136,7 +1131,7 @@ ttypoll(dev, events, td)
                return ((events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM))
                        | POLLHUP);
 
-       s = spltty();
+       crit_enter();
        if (events & (POLLIN | POLLRDNORM)) {
                if (ttnread(tp) > 0 || ISSET(tp->t_state, TS_ZOMBIE))
                        revents |= events & (POLLIN | POLLRDNORM);
@@ -1151,7 +1146,7 @@ ttypoll(dev, events, td)
                else
                        selrecord(td, &tp->t_wsel);
        }
-       splx(s);
+       crit_exit();
        return (revents);
 }
 
@@ -1167,7 +1162,6 @@ ttykqfilter(dev, kn)
 {
        struct tty *tp = dev->si_tty;
        struct klist *klist;
-       int s;
 
        switch (kn->kn_filter) {
        case EVFILT_READ:
@@ -1184,9 +1178,9 @@ ttykqfilter(dev, kn)
 
        kn->kn_hook = (caddr_t)dev;
 
-       s = spltty();
+       crit_enter();
        SLIST_INSERT_HEAD(klist, kn, kn_selnext);
-       splx(s);
+       crit_exit();
 
        return (0);
 }
@@ -1195,10 +1189,10 @@ static void
 filt_ttyrdetach(struct knote *kn)
 {
        struct tty *tp = ((dev_t)kn->kn_hook)->si_tty;
-       int s = spltty();
 
+       crit_enter();
        SLIST_REMOVE(&tp->t_rsel.si_note, kn, knote, kn_selnext);
-       splx(s);
+       crit_exit();
 }
 
 static int
@@ -1218,10 +1212,10 @@ static void
 filt_ttywdetach(struct knote *kn)
 {
        struct tty *tp = ((dev_t)kn->kn_hook)->si_tty;
-       int s = spltty();
 
+       crit_enter();
        SLIST_REMOVE(&tp->t_wsel.si_note, kn, knote, kn_selnext);
-       splx(s);
+       crit_exit();
 }
 
 static int
@@ -1239,7 +1233,7 @@ filt_ttywrite(kn, hint)
 }
 
 /*
- * Must be called at spltty().
+ * Must be called while in a critical section.
  */
 static int
 ttnread(tp)
@@ -1265,10 +1259,10 @@ int
 ttywait(tp)
        struct tty *tp;
 {
-       int error, s;
+       int error;
 
        error = 0;
-       s = spltty();
+       crit_enter();
        while ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) &&
               ISSET(tp->t_state, TS_CONNECTED) && tp->t_oproc) {
                (*tp->t_oproc)(tp);
@@ -1288,7 +1282,7 @@ ttywait(tp)
        }
        if (!error && (tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)))
                error = EIO;
-       splx(s);
+       crit_exit();
        return (error);
 }
 
@@ -1314,9 +1308,7 @@ ttyflush(tp, rw)
        struct tty *tp;
        int rw;
 {
-       int s;
-
-       s = spltty();
+       crit_enter();
 #if 0
 again:
 #endif
@@ -1374,7 +1366,7 @@ again:
                FLUSHQ(&tp->t_outq);
                ttwwakeup(tp);
        }
-       splx(s);
+       crit_exit();
 }
 
 /*
@@ -1443,17 +1435,14 @@ ttrstrt(tp_arg)
        void *tp_arg;
 {
        struct tty *tp;
-       int s;
 
        KASSERT(tp_arg != NULL, ("ttrstrt"));
 
        tp = tp_arg;
-       s = spltty();
-
+       crit_enter();
        CLR(tp->t_state, TS_TIMEOUT);
        ttstart(tp);
-
-       splx(s);
+       crit_exit();
 }
 #endif
 
@@ -1537,7 +1526,7 @@ ttymodem(tp, flag)
 
 /*
  * Reinput pending characters after state switch
- * call at spltty().
+ * call from a critical section.
  */
 static void
 ttypend(tp)
@@ -1577,21 +1566,20 @@ ttread(tp, uio, flag)
        tcflag_t lflag;
        cc_t *cc = tp->t_cc;
        struct proc *pp;
-       int s, first, error = 0;
+       int first, error = 0;
        int has_stime = 0, last_cc = 0;
        long slp = 0;           /* XXX this should be renamed `timo'. */
        struct timeval stime;
 
 loop:
-       s = spltty();
+       crit_enter();
        lflag = tp->t_lflag;
        /*
         * take pending input first
         */
        if (ISSET(lflag, PENDIN)) {
                ttypend(tp);
-               splx(s);        /* reduce latency */
-               s = spltty();
+               splz();         /* reduce latency */
                lflag = tp->t_lflag;    /* XXX ttypend() clobbers it */
        }
 
@@ -1599,7 +1587,7 @@ loop:
         * Hang process if it's in the background.
         */
        if ((pp = curproc) && isbackground(pp, tp)) {
-               splx(s);
+               crit_exit();
                if (SIGISMEMBER(pp->p_sigignore, SIGTTIN) ||
                    SIGISMEMBER(pp->p_sigmask, SIGTTIN) ||
                    (pp->p_flag & P_PPWAIT) || pp->p_pgrp->pg_jobc == 0)
@@ -1612,7 +1600,7 @@ loop:
        }
 
        if (ISSET(tp->t_state, TS_ZOMBIE)) {
-               splx(s);
+               crit_exit();
                return (0);     /* EOF */
        }
 
@@ -1628,10 +1616,10 @@ loop:
                if (qp->c_cc > 0)
                        goto read;
                if (!ISSET(lflag, ICANON) && cc[VMIN] == 0) {
-                       splx(s);
+                       crit_exit();
                        return (0);
                }
-               splx(s);
+               crit_exit();
                return (EWOULDBLOCK);
        }
        if (!ISSET(lflag, ICANON)) {
@@ -1654,7 +1642,7 @@ loop:
                                goto read;
 
                        /* m, t and qp->c_cc are all 0.  0 is enough input. */
-                       splx(s);
+                       crit_exit();
                        return (0);
                }
                t *= 100000;            /* time in us */
@@ -1694,7 +1682,7 @@ loop:
                                slp = t - diff(timecopy, stime);
                                if (slp <= 0) {
                                        /* Timed out, but 0 is enough input. */
-                                       splx(s);
+                                       crit_exit();
                                        return (0);
                                }
                        }
@@ -1720,7 +1708,7 @@ sleep:
                error = ttysleep(tp, TSA_HUP_OR_INPUT(tp), PCATCH,
                                 ISSET(tp->t_state, TS_CONNECTED) ?
                                 "ttyin" : "ttyhup", (int)slp);
-               splx(s);
+               crit_exit();
                if (error == EWOULDBLOCK)
                        error = 0;
                else if (error)
@@ -1735,7 +1723,7 @@ sleep:
                goto loop;
        }
 read:
-       splx(s);
+       crit_exit();
        /*
         * Input present, check for input mapping and processing.
         */
@@ -1816,11 +1804,11 @@ out:
         * Look to unblock input now that (presumably)
         * the input queue has gone down.
         */
-       s = spltty();
+       crit_enter();
        if (ISSET(tp->t_state, TS_TBLOCK) &&
            tp->t_rawq.c_cc + tp->t_canq.c_cc <= tp->t_ilowat)
                ttyunblock(tp);
-       splx(s);
+       crit_exit();
 
        return (error);
 }
@@ -1837,27 +1825,28 @@ ttycheckoutq(tp, wait)
        struct tty *tp;
        int wait;
 {
-       int hiwat, s;
+       int hiwat;
        sigset_t oldmask;
 
        hiwat = tp->t_ohiwat;
        SIGEMPTYSET(oldmask);
-       s = spltty();
+       crit_enter();
        if (wait)
                oldmask = curproc->p_siglist;
-       if (tp->t_outq.c_cc > hiwat + OBUFSIZ + 100)
+       if (tp->t_outq.c_cc > hiwat + OBUFSIZ + 100) {
                while (tp->t_outq.c_cc > hiwat) {
                        ttstart(tp);
                        if (tp->t_outq.c_cc <= hiwat)
                                break;
                        if (!(wait && SIGSETEQ(curproc->p_siglist, oldmask))) {
-                               splx(s);
+                               crit_exit();
                                return (0);
                        }
                        SET(tp->t_state, TS_SO_OLOWAT);
                        tsleep(TSA_OLOWAT(tp), 0, "ttoutq", hz);
                }
-       splx(s);
+       }
+       crit_exit();
        return (1);
 }
 
@@ -1873,7 +1862,7 @@ ttwrite(tp, uio, flag)
        char *cp = NULL;
        int cc, ce;
        struct proc *pp;
-       int i, hiwat, cnt, error, s;
+       int i, hiwat, cnt, error;
        char obuf[OBUFSIZ];
 
        hiwat = tp->t_ohiwat;
@@ -1881,26 +1870,26 @@ ttwrite(tp, uio, flag)
        error = 0;
        cc = 0;
 loop:
-       s = spltty();
+       crit_enter();
        if (ISSET(tp->t_state, TS_ZOMBIE)) {
-               splx(s);
+               crit_exit();
                if (uio->uio_resid == cnt)
                        error = EIO;
                goto out;
        }
        if (!ISSET(tp->t_state, TS_CONNECTED)) {
                if (flag & IO_NDELAY) {
-                       splx(s);
+                       crit_exit();
                        error = EWOULDBLOCK;
                        goto out;
                }
                error = ttysleep(tp, TSA_CARR_ON(tp), PCATCH, "ttydcd", 0);
-               splx(s);
+               crit_exit();
                if (error)
                        goto out;
                goto loop;
        }
-       splx(s);
+       crit_exit();
 
        /*
         * Hang the process if it's in the background.
@@ -2031,23 +2020,23 @@ out:
 
 ovhiwat:
        ttstart(tp);
-       s = spltty();
+       crit_enter();
        /*
         * This can only occur if FLUSHO is set in t_lflag,
         * or if ttstart/oproc is synchronous (or very fast).
         */
        if (tp->t_outq.c_cc <= hiwat) {
-               splx(s);
+               crit_exit();
                goto loop;
        }
        if (flag & IO_NDELAY) {
-               splx(s);
+               crit_exit();
                uio->uio_resid += cc;
                return (uio->uio_resid == cnt ? EWOULDBLOCK : 0);
        }
        SET(tp->t_state, TS_SO_OLOWAT);
        error = ttysleep(tp, TSA_OLOWAT(tp), PCATCH, "ttywri", tp->t_timeout);
-       splx(s);
+       crit_exit();
        if (error == EWOULDBLOCK)
                error = EIO;
        if (error)
@@ -2066,7 +2055,7 @@ ttyrub(c, tp)
 {
        char *cp;
        int savecol;
-       int tabc, s;
+       int tabc;
 
        if (!ISSET(tp->t_lflag, ECHO) || ISSET(tp->t_lflag, EXTPROC))
                return;
@@ -2100,7 +2089,7 @@ ttyrub(c, tp)
                                        ttyretype(tp);
                                        return;
                                }
-                               s = spltty();
+                               crit_enter();
                                savecol = tp->t_column;
                                SET(tp->t_state, TS_CNTTB);
                                SET(tp->t_lflag, FLUSHO);
@@ -2112,7 +2101,7 @@ ttyrub(c, tp)
                                        ttyecho(tabc, tp);
                                CLR(tp->t_lflag, FLUSHO);
                                CLR(tp->t_state, TS_CNTTB);
-                               splx(s);
+                               crit_exit();
 
                                /* savecol will now be length of the tab. */
                                savecol -= tp->t_column;
@@ -2176,7 +2165,7 @@ ttyretype(tp)
        struct tty *tp;
 {
        char *cp;
-       int s, c;
+       int c;
 
        /* Echo the reprint character. */
        if (tp->t_cc[VREPRINT] != _POSIX_VDISABLE)
@@ -2189,7 +2178,7 @@ ttyretype(tp)
         * FIX: NEXTC IS BROKEN - DOESN'T CHECK QUOTE
         * BIT OF FIRST CHAR.
         */
-       s = spltty();
+       crit_enter();
        for (cp = tp->t_canq.c_cf, c = (cp != NULL ? *cp : 0);
            cp != NULL; cp = nextc(&tp->t_canq, cp, &c))
                ttyecho(c, tp);
@@ -2197,7 +2186,7 @@ ttyretype(tp)
            cp != NULL; cp = nextc(&tp->t_rawq, cp, &c))
                ttyecho(c, tp);
        CLR(tp->t_state, TS_ERASE);
-       splx(s);
+       crit_exit();
 
        tp->t_rocount = tp->t_rawq.c_cc;
        tp->t_rocol = 0;
@@ -2536,18 +2525,16 @@ tputchar(c, tp)
        int c;
        struct tty *tp;
 {
-       int s;
-
-       s = spltty();
+       crit_enter();
        if (!ISSET(tp->t_state, TS_CONNECTED)) {
-               splx(s);
+               crit_exit();
                return (-1);
        }
        if (c == '\n')
                (void)ttyoutput('\r', tp);
        (void)ttyoutput(c, tp);
        ttstart(tp);
-       splx(s);
+       crit_exit();
        return (0);
 }
 
index 3ded00e..a8bd5dc 100644 (file)
@@ -32,7 +32,7 @@
  *
  *     @(#)tty_pty.c   8.4 (Berkeley) 2/20/95
  * $FreeBSD: src/sys/kern/tty_pty.c,v 1.74.2.4 2002/02/20 19:58:13 dillon Exp $
- * $DragonFly: src/sys/kern/tty_pty.c,v 1.12 2004/05/19 22:52:58 dillon Exp $
+ * $DragonFly: src/sys/kern/tty_pty.c,v 1.13 2005/06/06 15:02:28 dillon Exp $
  */
 
 /*
@@ -57,6 +57,7 @@
 #include <sys/signalvar.h>
 #include <sys/malloc.h>
 #include <sys/device.h>
+#include <sys/thread2.h>
 
 MALLOC_DEFINE(M_PTY, "ptys", "pty data structures");
 
@@ -506,7 +507,6 @@ ptcpoll(dev, events, td)
        struct tty *tp = dev->si_tty;
        struct pt_ioctl *pti = dev->si_drv1;
        int revents = 0;
-       int s;
 
        if ((tp->t_state & TS_CONNECTED) == 0)
                return (seltrue(dev, events, td) | POLLHUP);
@@ -514,7 +514,7 @@ ptcpoll(dev, events, td)
        /*
         * Need to block timeouts (ttrstart).
         */
-       s = spltty();
+       crit_enter();
 
        if (events & (POLLIN | POLLRDNORM))
                if ((tp->t_state & TS_ISOPEN) &&
@@ -542,7 +542,7 @@ ptcpoll(dev, events, td)
                if (events & (POLLOUT | POLLWRNORM)) 
                        selrecord(td, &pti->pt_selw);
        }
-       splx(s);
+       crit_exit();
 
        return (revents);
 }
index c7f2f34..ccf5bd9 100644 (file)
@@ -25,7 +25,7 @@
  * SUCH DAMAGE.
  *
  *     $FreeBSD: src/sys/kern/uipc_accf.c,v 1.2.2.2 2000/09/20 21:19:21 ps Exp $
- *     $DragonFly: src/sys/kern/uipc_accf.c,v 1.2 2003/06/17 04:28:41 dillon Exp $
+ *     $DragonFly: src/sys/kern/uipc_accf.c,v 1.3 2005/06/06 15:02:28 dillon Exp $
  */
 
 #define ACCEPT_FILTER_MOD
@@ -43,6 +43,7 @@
 #include <sys/socket.h>
 #include <sys/socketvar.h>
 #include <sys/queue.h>
+#include <sys/thread2.h>
 
 static SLIST_HEAD(, accept_filter) accept_filtlsthd =
        SLIST_HEAD_INITIALIZER(&accept_filtlsthd);
@@ -113,15 +114,15 @@ accept_filt_generic_mod_event(module_t mod, int event, void *data)
 {
        struct accept_filter *p;
        struct accept_filter *accfp = (struct accept_filter *) data;
-       int     s, error;
+       int     error;
 
        switch (event) {
        case MOD_LOAD:
                MALLOC(p, struct accept_filter *, sizeof(*p), M_ACCF, M_WAITOK);
                bcopy(accfp, p, sizeof(*p));
-               s = splnet();
+               crit_enter();
                error = accept_filt_add(p);
-               splx(s);
+               crit_exit();
                break;
 
        case MOD_UNLOAD:
@@ -132,9 +133,9 @@ accept_filt_generic_mod_event(module_t mod, int event, void *data)
                 * in the struct accept_filter.
                 */
                if (unloadable != 0) {
-                       s = splnet();
+                       crit_enter();
                        error = accept_filt_del(accfp->accf_name);
-                       splx(s);
+                       crit_exit();
                } else
                        error = EOPNOTSUPP;
                break;
index 34a9c3a..19bd416 100644 (file)
@@ -32,7 +32,7 @@
  *
  *     @(#)uipc_domain.c       8.2 (Berkeley) 10/18/93
  * $FreeBSD: src/sys/kern/uipc_domain.c,v 1.22.2.1 2001/07/03 11:01:37 ume Exp $
- * $DragonFly: src/sys/kern/uipc_domain.c,v 1.8 2005/03/04 02:21:48 hsu Exp $
+ * $DragonFly: src/sys/kern/uipc_domain.c,v 1.9 2005/06/06 15:02:28 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -45,6 +45,8 @@
 #include <sys/systm.h>
 #include <vm/vm_zone.h>
 
+#include <sys/thread2.h>
+
 /*
  * System initialization
  *
@@ -79,9 +81,8 @@ static void
 net_init_domain(struct domain *dp)
 {
        struct protosw *pr;
-       int s;
 
-       s = splnet();
+       crit_enter();
        if (dp->dom_init)
                (*dp->dom_init)();
        for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++) {
@@ -96,7 +97,7 @@ net_init_domain(struct domain *dp)
         */
        max_hdr = max_linkhdr + max_protohdr;
        max_datalen = MHLEN - max_hdr;
-       splx(s);
+       crit_exit();
 }
 
 /*
@@ -108,11 +109,10 @@ void
 net_add_domain(void *data)
 {
        struct domain *dp = data;
-       int s;
 
-       s = splnet();
+       crit_enter();
        SLIST_INSERT_HEAD(&domains, dp, dom_next);
-       splx(s);
+       crit_exit();
        net_init_domain(dp);
 }
 
index 0901d3d..30677e3 100644 (file)
@@ -82,7 +82,7 @@
  *
  *     @(#)uipc_socket.c       8.3 (Berkeley) 4/15/94
  * $FreeBSD: src/sys/kern/uipc_socket.c,v 1.68.2.24 2003/11/11 17:18:18 silby Exp $
- * $DragonFly: src/sys/kern/uipc_socket.c,v 1.31 2005/05/29 16:32:20 hsu Exp $
+ * $DragonFly: src/sys/kern/uipc_socket.c,v 1.32 2005/06/06 15:02:28 dillon Exp $
  */
 
 #include "opt_inet.h"
 #include <sys/jail.h>
 #include <vm/vm_zone.h>
 
+#include <sys/thread2.h>
+
 #include <machine/limits.h>
 
 #ifdef INET
@@ -225,11 +227,11 @@ socreate(int dom, struct socket **aso, int type,
 int
 sobind(struct socket *so, struct sockaddr *nam, struct thread *td)
 {
-       int s = splnet();
        int error;
 
+       crit_enter();
        error = so_pru_bind(so, nam, td);
-       splx(s);
+       crit_exit();
        return (error);
 }
 
@@ -256,17 +258,17 @@ sodealloc(struct socket *so)
 int
 solisten(struct socket *so, int backlog, struct thread *td)
 {
-       int s, error;
+       int error;
 
-       s = splnet();
+       crit_enter();
        if (so->so_state & (SS_ISCONNECTED | SS_ISCONNECTING)) {
-               splx(s);
+               crit_exit();
                return (EINVAL);
        }
 
        error = so_pru_listen(so, td);
        if (error) {
-               splx(s);
+               crit_exit();
                return (error);
        }
        if (TAILQ_EMPTY(&so->so_comp))
@@ -274,7 +276,7 @@ solisten(struct socket *so, int backlog, struct thread *td)
        if (backlog < 0 || backlog > somaxconn)
                backlog = somaxconn;
        so->so_qlimit = backlog;
-       splx(s);
+       crit_exit();
        return (0);
 }
 
@@ -316,9 +318,9 @@ sofree(struct socket *so)
 int
 soclose(struct socket *so)
 {
-       int s = splnet();               /* conservative */
        int error = 0;
 
+       crit_enter();
        funsetown(so->so_sigio);
        if (so->so_pcb == NULL)
                goto discard;
@@ -371,12 +373,12 @@ discard:
                panic("soclose: NOFDREF");
        so->so_state |= SS_NOFDREF;
        sofree(so);
-       splx(s);
+       crit_exit();
        return (error);
 }
 
 /*
- * Must be called at splnet...
+ * Must be called from a critical section.
  */
 int
 soabort(so)
@@ -395,26 +397,25 @@ soabort(so)
 int
 soaccept(struct socket *so, struct sockaddr **nam)
 {
-       int s = splnet();
        int error;
 
+       crit_enter();
        if ((so->so_state & SS_NOFDREF) == 0)
                panic("soaccept: !NOFDREF");
        so->so_state &= ~SS_NOFDREF;
        error = so_pru_accept(so, nam);
-       splx(s);
+       crit_exit();
        return (error);
 }
 
 int
 soconnect(struct socket *so, struct sockaddr *nam, struct thread *td)
 {
-       int s;
        int error;
 
        if (so->so_options & SO_ACCEPTCONN)
                return (EOPNOTSUPP);
-       s = splnet();
+       crit_enter();
        /*
         * If protocol is connection-based, can only connect once.
         * Otherwise, if connected, try to disconnect first.
@@ -433,27 +434,27 @@ soconnect(struct socket *so, struct sockaddr *nam, struct thread *td)
                so->so_error = 0;
                error = so_pru_connect(so, nam, td);
        }
-       splx(s);
+       crit_exit();
        return (error);
 }
 
 int
 soconnect2(struct socket *so1, struct socket *so2)
 {
-       int s = splnet();
        int error;
 
+       crit_enter();
        error = so_pru_connect2(so1, so2);
-       splx(s);
+       crit_exit();
        return (error);
 }
 
 int
 sodisconnect(struct socket *so)
 {
-       int s = splnet();
        int error;
 
+       crit_enter();
        if ((so->so_state & SS_ISCONNECTED) == 0) {
                error = ENOTCONN;
                goto bad;
@@ -464,7 +465,7 @@ sodisconnect(struct socket *so)
        }
        error = so_pru_disconnect(so);
 bad:
-       splx(s);
+       crit_exit();
        return (error);
 }
 
@@ -494,7 +495,7 @@ sosend(struct socket *so, struct sockaddr *addr, struct uio *uio,
        struct mbuf **mp;
        struct mbuf *m;
        long space, len, resid;
-       int clen = 0, error, s, dontroute, mlen;
+       int clen = 0, error, dontroute, mlen;
        int atomic = sosendallatonce(so) || top;
        int pru_flags;
 
@@ -524,20 +525,20 @@ sosend(struct socket *so, struct sockaddr *addr, struct uio *uio,
                td->td_proc->p_stats->p_ru.ru_msgsnd++;
        if (control)
                clen = control->m_len;
-#define        gotoerr(errno)  { error = errno; splx(s); goto release; }
+#define        gotoerr(errno)  { error = errno; crit_exit(); goto release; }
 
 restart:
        error = sblock(&so->so_snd, SBLOCKWAIT(flags));
        if (error)
                goto out;
        do {
-               s = splnet();
+               crit_enter();
                if (so->so_state & SS_CANTSENDMORE)
                        gotoerr(EPIPE);
                if (so->so_error) {
                        error = so->so_error;
                        so->so_error = 0;
-                       splx(s);
+                       crit_exit();
                        goto release;
                }
                if ((so->so_state & SS_ISCONNECTED) == 0) {
@@ -568,12 +569,12 @@ restart:
                                gotoerr(EWOULDBLOCK);
                        sbunlock(&so->so_snd);
                        error = sbwait(&so->so_snd);
-                       splx(s);
+                       crit_exit();
                        if (error)
                                goto out;
                        goto restart;
                }
-               splx(s);
+               crit_exit();
                mp = &top;
                space -= clen;
                do {
@@ -634,7 +635,7 @@ restart:
                    } else {
                            pru_flags = 0;
                    }
-                   s = splnet();                               /* XXX */
+                   crit_enter();
                    /*
                     * XXX all the SS_CANTSENDMORE checks previously
                     * done could be out of date.  We could have recieved
@@ -645,7 +646,7 @@ restart:
                     * also happens.  We must rethink this.
                     */
                    error = so_pru_send(so, pru_flags, top, addr, control, td);
-                   splx(s);
+                   crit_exit();
                    if (dontroute)
                            so->so_options &= ~SO_DONTROUTE;
                    clen = 0;
@@ -683,7 +684,7 @@ int
 sosendudp(struct socket *so, struct sockaddr *addr, struct uio *uio,
          struct mbuf *top, struct mbuf *control, int flags, struct thread *td)
 {
-       int resid, error, s;
+       int resid, error;
        boolean_t dontroute;            /* temporary SO_DONTROUTE setting */
 
        if (td->td_proc && td->td_proc->p_stats)
@@ -699,13 +700,13 @@ restart:
        if (error)
                goto out;
 
-       s = splnet();
+       crit_enter();
        if (so->so_state & SS_CANTSENDMORE)
                gotoerr(EPIPE);
        if (so->so_error) {
                error = so->so_error;
                so->so_error = 0;
-               splx(s);
+               crit_exit();
                goto release;
        }
        if (!(so->so_state & SS_ISCONNECTED) && addr == NULL)
@@ -717,12 +718,12 @@ restart:
                        gotoerr(EWOULDBLOCK);
                sbunlock(&so->so_snd);
                error = sbwait(&so->so_snd);
-               splx(s);
+               crit_exit();
                if (error)
                        goto out;
                goto restart;
        }
-       splx(s);
+       crit_exit();
 
        if (uio) {
                top = m_uiomove(uio);
@@ -756,7 +757,7 @@ out:
  * followed by an optional mbuf or mbufs containing ancillary data,
  * and then zero or more mbufs of data.
  * In order to avoid blocking network interrupts for the entire time here,
- * we splx() while doing the actual copy to user space.
+ * we exit the critical section while doing the actual copy to user space.
  * Although the sockbuf is locked, new data may still be appended,
  * and thus we must maintain consistency of the sockbuf during that time.
  *
@@ -774,7 +775,7 @@ soreceive(so, psa, uio, mp0, controlp, flagsp)
        int *flagsp;
 {
        struct mbuf *m, **mp;
-       int flags, len, error, s, offset;
+       int flags, len, error, offset;
        struct protosw *pr = so->so_proto;
        struct mbuf *nextrecord;
        int moff, type = 0;
@@ -815,7 +816,7 @@ restart:
        error = sblock(&so->so_rcv, SBLOCKWAIT(flags));
        if (error)
                return (error);
-       s = splnet();
+       crit_enter();
 
        m = so->so_rcv.sb_mb;
        /*
@@ -867,7 +868,7 @@ restart:
                }
                sbunlock(&so->so_rcv);
                error = sbwait(&so->so_rcv);
-               splx(s);
+               crit_exit();
                if (error)
                        return (error);
                goto restart;
@@ -948,9 +949,9 @@ dontblock:
                 * block interrupts again.
                 */
                if (mp == 0) {
-                       splx(s);
+                       crit_exit();
                        error = uiomove(mtod(m, caddr_t) + moff, (int)len, uio);
-                       s = splnet();
+                       crit_enter();
                        if (error)
                                goto release;
                } else
@@ -1025,7 +1026,7 @@ dontblock:
                        error = sbwait(&so->so_rcv);
                        if (error) {
                                sbunlock(&so->so_rcv);
-                               splx(s);
+                               crit_exit();
                                return (0);
                        }
                        m = so->so_rcv.sb_mb;
@@ -1056,7 +1057,7 @@ dontblock:
        if (orig_resid == uio->uio_resid && orig_resid &&
            (flags & MSG_EOR) == 0 && (so->so_state & SS_CANTRCVMORE) == 0) {
                sbunlock(&so->so_rcv);
-               splx(s);
+               crit_exit();
                goto restart;
        }
 
@@ -1064,7 +1065,7 @@ dontblock:
                *flagsp |= flags;
 release:
        sbunlock(&so->so_rcv);
-       splx(s);
+       crit_exit();
        return (error);
 }
 
@@ -1089,12 +1090,12 @@ sorflush(so)
 {
        struct sockbuf *sb = &so->so_rcv;
        struct protosw *pr = so->so_proto;
-       int s;
        struct sockbuf asb;
 
        sb->sb_flags |= SB_NOINTR;
        (void) sblock(sb, M_WAITOK);
-       s = splimp();
+
+       crit_enter();
        socantrcvmore(so);
        sbunlock(sb);
        asb = *sb;
@@ -1103,7 +1104,8 @@ sorflush(so)
                sb->sb_sel.si_note = asb.sb_sel.si_note;
                sb->sb_flags = SB_KNOTE;
        }
-       splx(s);
+       crit_exit();
+
        if (pr->pr_flags & PR_RIGHTS && pr->pr_domain->dom_dispose)
                (*pr->pr_domain->dom_dispose)(asb.sb_mb);
        sbrelease(&asb, so);
@@ -1624,7 +1626,8 @@ int
 sopoll(struct socket *so, int events, struct ucred *cred, struct thread *td)
 {
        int revents = 0;
-       int s = splnet();
+
+       crit_enter();
 
        if (events & (POLLIN | POLLRDNORM))
                if (soreadable(so))
@@ -1657,7 +1660,7 @@ sopoll(struct socket *so, int events, struct ucred *cred, struct thread *td)
                }
        }
 
-       splx(s);
+       crit_exit();
        return (revents);
 }
 
@@ -1666,7 +1669,6 @@ sokqfilter(struct file *fp, struct knote *kn)
 {
        struct socket *so = (struct socket *)kn->kn_fp->f_data;
        struct sockbuf *sb;
-       int s;
 
        switch (kn->kn_filter) {
        case EVFILT_READ:
@@ -1684,10 +1686,10 @@ sokqfilter(struct file *fp, struct knote *kn)
                return (1);
        }
 
-       s = splnet();
+       crit_enter();
        SLIST_INSERT_HEAD(&sb->sb_sel.si_note, kn, kn_selnext);
        sb->sb_flags |= SB_KNOTE;
-       splx(s);
+       crit_exit();
        return (0);
 }
 
@@ -1695,12 +1697,12 @@ static void
 filt_sordetach(struct knote *kn)
 {
        struct socket *so = (struct socket *)kn->kn_fp->f_data;
-       int s = splnet();
 
+       crit_enter();
        SLIST_REMOVE(&so->so_rcv.sb_sel.si_note, kn, knote, kn_selnext);
        if (SLIST_EMPTY(&so->so_rcv.sb_sel.si_note))
                so->so_rcv.sb_flags &= ~SB_KNOTE;
-       splx(s);
+       crit_exit();
 }
 
 /*ARGSUSED*/
@@ -1726,12 +1728,12 @@ static void
 filt_sowdetach(struct knote *kn)
 {
        struct socket *so = (struct socket *)kn->kn_fp->f_data;
-       int s = splnet();
 
+       crit_enter();
        SLIST_REMOVE(&so->so_snd.sb_sel.si_note, kn, knote, kn_selnext);
        if (SLIST_EMPTY(&so->so_snd.sb_sel.si_note))
                so->so_snd.sb_flags &= ~SB_KNOTE;
-       splx(s);
+       crit_exit();
 }
 
 /*ARGSUSED*/
index 55d7a8c..6f9d9eb 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.14 2004/09/16 04:42:56 dillon Exp $
+ * $DragonFly: src/sys/kern/vfs_aio.c,v 1.15 2005/06/06 15:02:28 dillon Exp $
  */
 
 /*
@@ -304,7 +304,6 @@ aio_free_entry(struct aiocblist *aiocbe)
        struct aio_liojob *lj;
        struct proc *p;
        int error;
-       int s;
 
        if (aiocbe->jobstate == JOBST_NULL)
                panic("aio_free_entry: freeing already free job");
@@ -360,20 +359,20 @@ aio_free_entry(struct aiocblist *aiocbe)
                        return error;
                if (aiocbe->jobstate != JOBST_JOBBFINISHED)
                        panic("aio_free_entry: invalid physio finish-up state");
-               s = splbio();
+               crit_enter();
                TAILQ_REMOVE(&ki->kaio_bufdone, aiocbe, plist);
-               splx(s);
+               crit_exit();
        } else if (aiocbe->jobstate == JOBST_JOBQGLOBAL) {
-               s = splnet();
+               crit_enter();
                TAILQ_REMOVE(&aio_jobs, aiocbe, list);
                TAILQ_REMOVE(&ki->kaio_jobqueue, aiocbe, plist);
-               splx(s);
+               crit_exit();
        } else if (aiocbe->jobstate == JOBST_JOBFINISHED)
                TAILQ_REMOVE(&ki->kaio_jobdone, aiocbe, plist);
        else if (aiocbe->jobstate == JOBST_JOBBFINISHED) {
-               s = splbio();
+               crit_enter();
                TAILQ_REMOVE(&ki->kaio_bufdone, aiocbe, plist);
-               splx(s);
+               crit_exit();
                if (aiocbe->bp) {
                        vunmapbuf(aiocbe->bp);
                        relpbuf(aiocbe->bp, NULL);
@@ -401,7 +400,6 @@ aio_proc_rundown(struct proc *p)
 #ifndef VFS_AIO
        return;
 #else
-       int s;
        struct kaioinfo *ki;
        struct aio_liojob *lj, *ljn;
        struct aiocblist *aiocbe, *aiocbn;
@@ -424,7 +422,7 @@ aio_proc_rundown(struct proc *p)
         * Move any aio ops that are waiting on socket I/O to the normal job
         * queues so they are cleaned up with any others.
         */
-       s = splnet();
+       crit_enter();
        for (aiocbe = TAILQ_FIRST(&ki->kaio_sockqueue); aiocbe; aiocbe =
            aiocbn) {
                aiocbn = TAILQ_NEXT(aiocbe, plist);
@@ -441,7 +439,7 @@ aio_proc_rundown(struct proc *p)
                TAILQ_INSERT_HEAD(&aio_jobs, aiocbe, list);
                TAILQ_INSERT_HEAD(&ki->kaio_jobqueue, aiocbe, plist);
        }
-       splx(s);
+       crit_exit();
 
 restart1:
        for (aiocbe = TAILQ_FIRST(&ki->kaio_jobdone); aiocbe; aiocbe = aiocbn) {
@@ -458,30 +456,26 @@ restart2:
                        goto restart2;
        }
 
-/*
- * Note the use of lots of splbio here, trying to avoid splbio for long chains
- * of I/O.  Probably unnecessary.
- */
 restart3:
-       s = splbio();
+       crit_enter();
        while (TAILQ_FIRST(&ki->kaio_bufqueue)) {
                ki->kaio_flags |= KAIO_WAKEUP;
                tsleep(p, 0, "aioprn", 0);
-               splx(s);
+               crit_exit();
                goto restart3;
        }
-       splx(s);
+       crit_exit();
 
 restart4:
-       s = splbio();
+       crit_enter();
        for (aiocbe = TAILQ_FIRST(&ki->kaio_bufdone); aiocbe; aiocbe = aiocbn) {
                aiocbn = TAILQ_NEXT(aiocbe, plist);
                if (aio_free_entry(aiocbe)) {
-                       splx(s);
+                       crit_exit();
                        goto restart4;
                }
        }
-       splx(s);
+       crit_exit();
 
         /*
          * If we've slept, jobs might have moved from one queue to another.
@@ -522,12 +516,11 @@ restart4:
 static struct aiocblist *
 aio_selectjob(struct aioproclist *aiop)
 {
-       int s;
        struct aiocblist *aiocbe;
        struct kaioinfo *ki;
        struct proc *userp;
 
-       s = splnet();
+       crit_enter();
        for (aiocbe = TAILQ_FIRST(&aio_jobs); aiocbe; aiocbe =
            TAILQ_NEXT(aiocbe, list)) {
                userp = aiocbe->userproc;
@@ -535,11 +528,11 @@ aio_selectjob(struct aioproclist *aiop)
 
                if (ki->kaio_active_count < ki->kaio_maxactive_count) {
                        TAILQ_REMOVE(&aio_jobs, aiocbe, list);
-                       splx(s);
+                       crit_exit();
                        return aiocbe;
                }
        }
-       splx(s);
+       crit_exit();
 
        return NULL;
 }
@@ -618,7 +611,6 @@ aio_process(struct aiocblist *aiocbe)
 static void
 aio_daemon(void *uproc)
 {
-       int s;
        struct aio_liojob *lj;
        struct aiocb *cb;
        struct aiocblist *aiocbe;
@@ -647,7 +639,7 @@ aio_daemon(void *uproc)
        aiop->aioproc = mycp;
        aiop->aioprocflags |= AIOP_FREE;
 
-       s = splnet();
+       crit_enter();
 
        /*
         * Place thread (lightweight process) onto the AIO free thread list.
@@ -656,7 +648,7 @@ aio_daemon(void *uproc)
                wakeup(&aio_freeproc);
        TAILQ_INSERT_HEAD(&aio_freeproc, aiop, list);
 
-       splx(s);
+       crit_exit();
 
        /* Make up a name for the daemon. */
        strcpy(mycp->p_comm, "aiod");
@@ -697,11 +689,11 @@ aio_daemon(void *uproc)
                 * Take daemon off of free queue
                 */
                if (aiop->aioprocflags & AIOP_FREE) {
-                       s = splnet();
+                       crit_enter();
                        TAILQ_REMOVE(&aio_freeproc, aiop, list);
                        TAILQ_INSERT_TAIL(&aio_activeproc, aiop, list);
                        aiop->aioprocflags &= ~AIOP_FREE;
-                       splx(s);
+                       crit_exit();
                }
                aiop->aioprocflags &= ~AIOP_SCHED;
 
@@ -772,7 +764,7 @@ aio_daemon(void *uproc)
                                wakeup(userp);
                        }
 
-                       s = splbio();
+                       crit_enter();
                        if (lj && (lj->lioj_flags &
                            (LIOJ_SIGNAL|LIOJ_SIGNAL_POSTED)) == LIOJ_SIGNAL) {
                                if ((lj->lioj_queue_finished_count ==
@@ -785,14 +777,14 @@ aio_daemon(void *uproc)
                                                    LIOJ_SIGNAL_POSTED;
                                }
                        }
-                       splx(s);
+                       crit_exit();
 
                        aiocbe->jobstate = JOBST_JOBFINISHED;
 
-                       s = splnet();
+                       crit_enter();
                        TAILQ_REMOVE(&ki->kaio_jobqueue, aiocbe, plist);
                        TAILQ_INSERT_TAIL(&ki->kaio_jobdone, aiocbe, plist);
-                       splx(s);
+                       crit_exit();
                        KNOTE(&aiocbe->klist, 0);
 
                        if (aiocbe->jobflags & AIOCBLIST_RUNDOWN) {
@@ -833,13 +825,13 @@ aio_daemon(void *uproc)
                 * If we are the first to be put onto the free queue, wakeup
                 * anyone waiting for a daemon.
                 */
-               s = splnet();
+               crit_enter();
                TAILQ_REMOVE(&aio_activeproc, aiop, list);
                if (TAILQ_EMPTY(&aio_freeproc))
                        wakeup(&aio_freeproc);
                TAILQ_INSERT_HEAD(&aio_freeproc, aiop, list);
                aiop->aioprocflags |= AIOP_FREE;
-               splx(s);
+               crit_exit();
 
                /*
                 * If daemon is inactive for a long time, allow it to exit,
@@ -847,12 +839,12 @@ aio_daemon(void *uproc)
                 */
                if (((aiop->aioprocflags & AIOP_SCHED) == 0) && tsleep(mycp,
                    0, "aiordy", aiod_lifetime)) {
-                       s = splnet();
+                       crit_enter();
                        if (TAILQ_EMPTY(&aio_jobs)) {
                                if ((aiop->aioprocflags & AIOP_FREE) &&
                                    (num_aio_procs > target_aio_procs)) {
                                        TAILQ_REMOVE(&aio_freeproc, aiop, list);
-                                       splx(s);
+                                       crit_exit();
                                        zfree(aiop_zone, aiop);
                                        num_aio_procs--;
 #ifdef DIAGNOSTIC
@@ -865,7 +857,7 @@ aio_daemon(void *uproc)
                                        exit1(0);
                                }
                        }
-                       splx(s);
+                       crit_exit();
                }
        }
 }
@@ -916,7 +908,6 @@ aio_qphysio(struct proc *p, struct aiocblist *aiocbe)
        struct vnode *vp;
        struct kaioinfo *ki;
        struct aio_liojob *lj;
-       int s;
        int notify;
 
        cb = &aiocbe->uaiocb;
@@ -982,7 +973,8 @@ aio_qphysio(struct proc *p, struct aiocblist *aiocbe)
                goto doerror;
        }
 
-       s = splbio();
+       crit_enter();
+
        aiocbe->bp = bp;
        bp->b_spc = (void *)aiocbe;
        TAILQ_INSERT_TAIL(&aio_bufjobs, aiocbe, list);
@@ -992,13 +984,13 @@ aio_qphysio(struct proc *p, struct aiocblist *aiocbe)
        num_buf_aio++;
        bp->b_error = 0;
 
-       splx(s);
+       crit_exit();
        
        /* Perform transfer. */
        BUF_STRATEGY(bp, 0);
 
        notify = 0;
-       s = splbio();
+       crit_enter();
        
        /*
         * If we had an error invoking the request, or an error in processing
@@ -1026,7 +1018,7 @@ aio_qphysio(struct proc *p, struct aiocblist *aiocbe)
                        notify = 1;
                }
        }
-       splx(s);
+       crit_exit();
        if (notify)
                KNOTE(&aiocbe->klist, 0);
        return 0;
@@ -1046,23 +1038,22 @@ doerror:
 static int
 aio_fphysio(struct aiocblist *iocb)
 {
-       int s;
        struct buf *bp;
        int error;
 
        bp = iocb->bp;
 
-       s = splbio();
+       crit_enter();
        while ((bp->b_flags & B_DONE) == 0) {
                if (tsleep(bp, 0, "physstr", aiod_timeout)) {
                        if ((bp->b_flags & B_DONE) == 0) {
-                               splx(s);
+                               crit_exit();
                                return EINPROGRESS;
                        } else
                                break;
                }
        }
-       splx(s);
+       crit_exit();
 
        /* Release mapping into kernel space. */
        vunmapbuf(bp);
@@ -1141,7 +1132,6 @@ _aio_aqueue(struct aiocb *job, struct aio_liojob *lj, int type)
        struct file *fp;
        unsigned int fd;
        struct socket *so;
-       int s;
        int error;
        int opcode, user_opcode;
        struct aiocblist *aiocbe;
@@ -1303,7 +1293,7 @@ no_kqueue:
                 * happens.
                 */
                so = (struct socket *)fp->f_data;
-               s = splnet();
+               crit_enter();
                if (((opcode == LIO_READ) && (!soreadable(so))) || ((opcode ==
                    LIO_WRITE) && (!sowriteable(so)))) {
                        TAILQ_INSERT_TAIL(&so->so_aiojobq, aiocbe, list);
@@ -1315,11 +1305,11 @@ no_kqueue:
                        aiocbe->jobstate = JOBST_JOBQGLOBAL; /* XXX */
                        ki->kaio_queue_count++;
                        num_queue_count++;
-                       splx(s);
+                       crit_exit();
                        error = 0;
                        goto done;
                }
-               splx(s);
+               crit_exit();
        }
 
        if ((error = aio_qphysio(p, aiocbe)) == 0)
@@ -1337,10 +1327,10 @@ no_kqueue:
        ki->kaio_queue_count++;
        if (lj)
                lj->lioj_queue_count++;
-       s = splnet();
+       crit_enter();
        TAILQ_INSERT_TAIL(&ki->kaio_jobqueue, aiocbe, plist);
        TAILQ_INSERT_TAIL(&aio_jobs, aiocbe, list);
-       splx(s);
+       crit_exit();
        aiocbe->jobstate = JOBST_JOBQGLOBAL;
 
        num_queue_count++;
@@ -1353,7 +1343,7 @@ no_kqueue:
         * (thread) due to resource issues, we return an error for now (EAGAIN),
         * which is likely not the correct thing to do.
         */
-       s = splnet();
+       crit_enter();
 retryproc:
        if ((aiop = TAILQ_FIRST(&aio_freeproc)) != NULL) {
                TAILQ_REMOVE(&aio_freeproc, aiop, list);
@@ -1370,7 +1360,7 @@ retryproc:
                }
                num_aio_resv_start--;
        }
-       splx(s);
+       crit_exit();
 done:
        return error;
 }
@@ -1409,7 +1399,6 @@ aio_return(struct aio_return_args *uap)
        return ENOSYS;
 #else
        struct proc *p = curproc;
-       int s;
        long jobref;
        struct aiocblist *cb, *ncb;
        struct aiocb *ujob;
@@ -1445,12 +1434,12 @@ aio_return(struct aio_return_args *uap)
                        return 0;
                }
        }
-       s = splbio();
+       crit_enter();
        for (cb = TAILQ_FIRST(&ki->kaio_bufdone); cb; cb = ncb) {
                ncb = TAILQ_NEXT(cb, plist);
                if (((intptr_t) cb->uaiocb._aiocb_private.kernelinfo)
                    == jobref) {
-                       splx(s);
+                       crit_exit();
                        if (ujob == cb->uuaiocb) {
                                uap->sysmsg_result =
                                    cb->uaiocb._aiocb_private.status;
@@ -1460,7 +1449,7 @@ aio_return(struct aio_return_args *uap)
                        return 0;
                }
        }
-       splx(s);
+       crit_exit();
 
        return (EINVAL);
 #endif /* VFS_AIO */
@@ -1545,14 +1534,14 @@ aio_suspend(struct aio_suspend_args *uap)
                        }
                }
 
-               s = splbio();
+               crit_enter();
                for (cb = TAILQ_FIRST(&ki->kaio_bufdone); cb; cb =
                    TAILQ_NEXT(cb, plist)) {
                        for (i = 0; i < njoblist; i++) {
                                if (((intptr_t)
                                    cb->uaiocb._aiocb_private.kernelinfo) ==
                                    ijoblist[i]) {
-                                       splx(s);
+                                       crit_exit();
                                        if (ujoblist[i] != cb->uuaiocb)
                                                error = EINVAL;
                                        zfree(aiol_zone, ijoblist);
@@ -1564,7 +1553,7 @@ aio_suspend(struct aio_suspend_args *uap)
 
                ki->kaio_flags |= KAIO_WAKEUP;
                error = tsleep(p, PCATCH, "aiospn", timo);
-               splx(s);
+               crit_exit();
 
                if (error == ERESTART || error == EINTR) {
                        zfree(aiol_zone, ijoblist);
@@ -1599,7 +1588,7 @@ aio_cancel(struct aio_cancel_args *uap)
        struct filedesc *fdp;
        struct socket *so;
        struct proc *po;
-       int s,error;
+       int error;
        int cancelled=0;
        int notcancelled=0;
        struct vnode *vp;
@@ -1619,7 +1608,7 @@ aio_cancel(struct aio_cancel_args *uap)
        } else if (fp->f_type == DTYPE_SOCKET) {
                so = (struct socket *)fp->f_data;
 
-               s = splnet();
+               crit_enter();
 
                for (cbe = TAILQ_FIRST(&so->so_aiojobq); cbe; cbe = cbn) {
                        cbn = TAILQ_NEXT(cbe, list);
@@ -1645,7 +1634,7 @@ aio_cancel(struct aio_cancel_args *uap)
                                        break;
                        }
                }
-               splx(s);
+               crit_exit();
 
                if ((cancelled) && (uap->aiocbp)) {
                        uap->sysmsg_result = AIO_CANCELED;
@@ -1655,7 +1644,7 @@ aio_cancel(struct aio_cancel_args *uap)
        ki=p->p_aioinfo;
        if (ki == NULL)
                goto done;
-       s = splnet();
+       crit_enter();
 
        for (cbe = TAILQ_FIRST(&ki->kaio_jobqueue); cbe; cbe = cbn) {
                cbn = TAILQ_NEXT(cbe, plist);
@@ -1683,7 +1672,7 @@ aio_cancel(struct aio_cancel_args *uap)
                        }
                }
        }
-       splx(s);
+       crit_exit();
 done:
        if (notcancelled) {
                uap->sysmsg_result = AIO_NOTCANCELED;
@@ -1711,7 +1700,6 @@ aio_error(struct aio_error_args *uap)
        return ENOSYS;
 #else
        struct proc *p = curproc;
-       int s;
        struct aiocblist *cb;
        struct kaioinfo *ki;
        long jobref;
@@ -1732,14 +1720,14 @@ aio_error(struct aio_error_args *uap)
                }
        }
 
-       s = splnet();
+       crit_enter();
 
        for (cb = TAILQ_FIRST(&ki->kaio_jobqueue); cb; cb = TAILQ_NEXT(cb,
            plist)) {
                if (((intptr_t)cb->uaiocb._aiocb_private.kernelinfo) ==
                    jobref) {
                        uap->sysmsg_result = EINPROGRESS;
-                       splx(s);
+                       crit_exit();
                        return 0;
                }
        }
@@ -1749,19 +1737,19 @@ aio_error(struct aio_error_args *uap)
                if (((intptr_t)cb->uaiocb._aiocb_private.kernelinfo) ==
                    jobref) {
                        uap->sysmsg_result = EINPROGRESS;
-                       splx(s);
+                       crit_exit();
                        return 0;
                }
        }
-       splx(s);
+       crit_exit();
 
-       s = splbio();
+       crit_enter();
        for (cb = TAILQ_FIRST(&ki->kaio_bufdone); cb; cb = TAILQ_NEXT(cb,
            plist)) {
                if (((intptr_t)cb->uaiocb._aiocb_private.kernelinfo) ==
                    jobref) {
                        uap->sysmsg_result = cb->uaiocb._aiocb_private.error;
-                       splx(s);
+                       crit_exit();
                        return 0;
                }
        }
@@ -1771,11 +1759,11 @@ aio_error(struct aio_error_args *uap)
                if (((intptr_t)cb->uaiocb._aiocb_private.kernelinfo) ==
                    jobref) {
                        uap->sysmsg_result = EINPROGRESS;
-                       splx(s);
+                       crit_exit();
                        return 0;
                }
        }
-       splx(s);
+       crit_exit();
 
 #if (0)
        /*
@@ -1827,7 +1815,6 @@ lio_listio(struct lio_listio_args *uap)
        int error, runningcode;
        int nerror;
        int i;
-       int s;
 
        if ((uap->mode != LIO_NOWAIT) && (uap->mode != LIO_WAIT))
                return EINVAL;
@@ -1954,7 +1941,7 @@ lio_listio(struct lio_listio_args *uap)
                                        }
                                }
 
-                               s = splbio();
+                               crit_enter();
                                TAILQ_FOREACH(cb, &ki->kaio_bufdone, plist) {
                                        if (((intptr_t)cb->uaiocb._aiocb_private.kernelinfo)
                                            == jobref) {
@@ -1962,7 +1949,7 @@ lio_listio(struct lio_listio_args *uap)
                                                break;
                                        }
                                }
-                               splx(s);
+                               crit_exit();
                        }
 
                        /*
@@ -2131,9 +2118,9 @@ aio_waitcomplete(struct aio_waitcomplete_args *uap)
                        return cb->uaiocb._aiocb_private.error;
                }
 
-               s = splbio();
+               crit_enter();
                if ((cb = TAILQ_FIRST(&ki->kaio_bufdone)) != 0 ) {
-                       splx(s);
+                       crit_exit();
                        suword(uap->aiocbp, (uintptr_t)cb->uuaiocb);
                        uap->sysmsg_result = cb->uaiocb._aiocb_private.status;
                        aio_free_entry(cb);
@@ -2142,7 +2129,7 @@ aio_waitcomplete(struct aio_waitcomplete_args *uap)
 
                ki->kaio_flags |= KAIO_WAKEUP;
                error = tsleep(p, PCATCH, "aiowc", timo);
-               splx(s);
+               crit_exit();
 
                if (error == ERESTART)
                        return EINTR;
index 0e330ed..d07230d 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.36 2005/05/08 00:12:22 dillon Exp $
+ * $DragonFly: src/sys/kern/vfs_bio.c,v 1.37 2005/06/06 15:02:28 dillon Exp $
  */
 
 /*
@@ -154,7 +154,8 @@ SYSCTL_INT(_vfs, OID_AUTO, bufreusecnt, CTLFLAG_RW,
  * Disable background writes for now.  There appear to be races in the 
  * flags tests and locking operations as well as races in the completion
  * code modifying the original bp (origbp) without holding a lock, assuming
- * splbio protection when there might not be splbio protection.
+ * critical section protection when there might not be critical section
+ * protection.
  *
  * XXX disable also because the RB tree can't handle multiple blocks with
  * the same lblkno.
@@ -319,13 +320,13 @@ bufcountwakeup(void)
 static __inline void
 waitrunningbufspace(void)
 {
-       while (runningbufspace > hirunningspace) {
-               int s;
-
-               s = splbio();   /* fix race against interrupt/biodone() */
-               ++runningbufreq;
-               tsleep(&runningbufreq, 0, "wdrain", 0);
-               splx(s);
+       if (runningbufspace > hirunningspace) {
+               crit_enter();
+               while (runningbufspace > hirunningspace) {
+                       ++runningbufreq;
+                       tsleep(&runningbufreq, 0, "wdrain", 0);
+               }
+               crit_exit();
        }
 }
 
@@ -491,7 +492,7 @@ bufinit(void)
 /*
  * bfreekva() - free the kva allocation for a buffer.
  *
- *     Must be called at splbio() or higher as this is the only locking for
+ *     Must be called from a critical section as this is the only locking for
  *     buffer_map.
  *
  *     Since this call frees up buffer space, we call bufspacewakeup().
@@ -526,8 +527,10 @@ bfreekva(struct buf * bp)
 void
 bremfree(struct buf * bp)
 {
-       int s = splbio();
-       int old_qindex = bp->b_qindex;
+       int old_qindex;
+
+       crit_enter();
+       old_qindex = bp->b_qindex;
 
        if (bp->b_qindex != QUEUE_NONE) {
                KASSERT(BUF_REFCNTNB(bp) == 1, 
@@ -556,7 +559,7 @@ bremfree(struct buf * bp)
                        break;
                }
        }
-       splx(s);
+       crit_exit();
 }
 
 
@@ -647,7 +650,7 @@ breadn(struct vnode * vp, daddr_t blkno, int size, daddr_t * rablkno,
 int
 bwrite(struct buf * bp)
 {
-       int oldflags, s;
+       int oldflags;
 #if 0
        struct buf *newbp;
 #endif
@@ -661,7 +664,7 @@ bwrite(struct buf * bp)
 
        if (BUF_REFCNTNB(bp) == 0)
                panic("bwrite: buffer is not busy???");
-       s = splbio();
+       crit_enter();
        /*
         * If a background write is already in progress, delay
         * writing this block if it is asynchronous. Otherwise
@@ -669,7 +672,7 @@ bwrite(struct buf * bp)
         */
        if (bp->b_xflags & BX_BKGRDINPROG) {
                if (bp->b_flags & B_ASYNC) {
-                       splx(s);
+                       crit_exit();
                        bdwrite(bp);
                        return (0);
                }
@@ -747,7 +750,7 @@ bwrite(struct buf * bp)
        bp->b_runningbufspace = bp->b_bufsize;
        runningbufspace += bp->b_runningbufspace;
 
-       splx(s);
+       crit_exit();
        if (oldflags & B_ASYNC)
                BUF_KERNPROC(bp);
        VOP_STRATEGY(bp->b_vp, bp);
@@ -910,7 +913,7 @@ bdwrite(struct buf *bp)
  *     Since the buffer is not on a queue, we do not update the numfreebuffers
  *     count.
  *
- *     Must be called at splbio().
+ *     Must be called from a critical section.
  *     The buffer must be on QUEUE_NONE.
  */
 void
@@ -935,7 +938,7 @@ bdirty(struct buf *bp)
  *     Since the buffer is not on a queue, we do not update the numfreebuffers
  *     count.
  *     
- *     Must be called at splbio().
+ *     Must be called from a critical section.
  *
  *     The buffer is typically on QUEUE_NONE but there is one case in 
  *     brelse() that calls this function after placing the buffer on
@@ -1002,15 +1005,13 @@ void
 bwillwrite(void)
 {
        if (numdirtybuffers >= hidirtybuffers) {
-               int s;
-
-               s = splbio();
+               crit_enter();
                while (numdirtybuffers >= hidirtybuffers) {
                        bd_wakeup(1);
                        needsbuffer |= VFS_BIO_NEED_DIRTYFLUSH;
                        tsleep(&needsbuffer, 0, "flswai", 0);
                }
-               splx(s);
+               crit_exit();
        }
 }
 
@@ -1033,11 +1034,9 @@ buf_dirty_count_severe(void)
 void
 brelse(struct buf * bp)
 {
-       int s;
-
        KASSERT(!(bp->b_flags & (B_CLUSTER|B_PAGING)), ("brelse: inappropriate B_PAGING or B_CLUSTER bp %p", bp));
 
-       s = splbio();
+       crit_enter();
 
        if (bp->b_flags & B_LOCKED)
                bp->b_flags &= ~B_ERROR;
@@ -1147,7 +1146,7 @@ brelse(struct buf * bp)
                         * now.  Note that we left these pages wired
                         * when we removed them so they had better exist,
                         * and they cannot be ripped out from under us so
-                        * no splvm() protection is necessary.
+                        * no critical section protection is necessary.
                         */
                        if (m == bogus_page) {
                                VOP_GETVOBJECT(vp, &obj);
@@ -1233,7 +1232,7 @@ brelse(struct buf * bp)
                panic("brelse: multiple refs");
                /* do not release to free list */
                BUF_UNLOCK(bp);
-               splx(s);
+               crit_exit();
                return;
        }
 
@@ -1320,7 +1319,7 @@ brelse(struct buf * bp)
        BUF_UNLOCK(bp);
        bp->b_flags &= ~(B_ORDERED | B_ASYNC | B_NOCACHE | B_AGE | B_RELBUF |
                        B_DIRECT | B_NOWDRAIN);
-       splx(s);
+       crit_exit();
 }
 
 /*
@@ -1337,9 +1336,7 @@ brelse(struct buf * bp)
 void
 bqrelse(struct buf * bp)
 {
-       int s;
-
-       s = splbio();
+       crit_enter();
 
        KASSERT(!(bp->b_flags & (B_CLUSTER|B_PAGING)), ("bqrelse: inappropriate B_PAGING or B_CLUSTER bp %p", bp));
 
@@ -1349,7 +1346,7 @@ bqrelse(struct buf * bp)
                /* do not release to free list */
                panic("bqrelse: multiple refs");
                BUF_UNLOCK(bp);
-               splx(s);
+               crit_exit();
                return;
        }
        if (bp->b_flags & B_LOCKED) {
@@ -1366,7 +1363,7 @@ bqrelse(struct buf * bp)
                 * buffer (most importantly: the wired pages making up its
                 * backing store) *now*.
                 */
-               splx(s);
+               crit_exit();
                brelse(bp);
                return;
        } else {
@@ -1388,16 +1385,16 @@ bqrelse(struct buf * bp)
        /* unlock */
        BUF_UNLOCK(bp);
        bp->b_flags &= ~(B_ORDERED | B_ASYNC | B_NOCACHE | B_AGE | B_RELBUF);
-       splx(s);
+       crit_exit();
 }
 
 static void
 vfs_vmio_release(struct buf *bp)
 {
-       int i, s;
+       int i;
        vm_page_t m;
 
-       s = splvm();
+       crit_enter();
        for (i = 0; i < bp->b_xio.xio_npages; i++) {
                m = bp->b_xio.xio_pages[i];
                bp->b_xio.xio_pages[i] = NULL;
@@ -1432,7 +1429,7 @@ vfs_vmio_release(struct buf *bp)
                        }
                }
        }
-       splx(s);
+       crit_exit();
        pmap_qremove(trunc_page((vm_offset_t) bp->b_data), bp->b_xio.xio_npages);
        if (bp->b_bufsize) {
                bufspacewakeup();
@@ -1479,14 +1476,13 @@ vfs_bio_awrite(struct buf * bp)
        int j;
        daddr_t lblkno = bp->b_lblkno;
        struct vnode *vp = bp->b_vp;
-       int s;
        int ncl;
        struct buf *bpa;
        int nwritten;
        int size;
        int maxcl;
 
-       s = splbio();
+       crit_enter();
        /*
         * right now we support clustered writing only to regular files.  If
         * we find a clusterable block we could be in the middle of a cluster
@@ -1534,7 +1530,7 @@ vfs_bio_awrite(struct buf * bp)
                 */
                if (ncl != 1) {
                        nwritten = cluster_wbuild(vp, size, lblkno - j, ncl);
-                       splx(s);
+                       crit_exit();
                        return nwritten;
                }
        }
@@ -1543,7 +1539,7 @@ vfs_bio_awrite(struct buf * bp)
        bremfree(bp);
        bp->b_flags |= B_ASYNC;
 
-       splx(s);
+       crit_exit();
        /*
         * default (old) behavior, writing out only one block
         *
@@ -1725,8 +1721,9 @@ restart:
                LIST_INSERT_HEAD(&invalhash, bp, b_hash);
 
                /*
-                * spl protection not required when scrapping a buffer's
-                * contents because it is already wired.
+                * critical section protection is not required when
+                * scrapping a buffer's contents because it is already 
+                * wired.
                 */
                if (bp->b_bufsize)
                        allocbuf(bp, 0);
@@ -1876,8 +1873,6 @@ SYSINIT(bufdaemon, SI_SUB_KTHREAD_BUF, SI_ORDER_FIRST, kproc_start, &buf_kp)
 static void
 buf_daemon()
 {
-       int s;
-
        /*
         * This process needs to be suspended prior to shutdown sync.
         */
@@ -1887,7 +1882,7 @@ buf_daemon()
        /*
         * This process is allowed to take the buffer cache to the limit
         */
-       s = splbio();
+       crit_enter();
 
        for (;;) {
                kproc_suspend_loop();
@@ -2004,7 +1999,7 @@ incore(struct vnode * vp, daddr_t blkno)
  *
  * Note that we ignore vm_page_free() races from interrupts against our
  * lookup, since if the caller is not protected our return value will not
- * be any more valid then otherwise once we splx().
+ * be any more valid then otherwise once we exit the critical section.
  */
 int
 inmem(struct vnode * vp, daddr_t blkno)
@@ -2179,13 +2174,12 @@ struct buf *
 getblk(struct vnode * vp, daddr_t blkno, int size, int slpflag, int slptimeo)
 {
        struct buf *bp;
-       int s;
        struct bufhashhdr *bh;
 
        if (size > MAXBSIZE)
                panic("getblk: size(%d) > MAXBSIZE(%d)", size, MAXBSIZE);
 
-       s = splbio();
+       crit_enter();
 loop:
        /*
         * Block if we are low on buffers.   Certain processes are allowed
@@ -2215,7 +2209,7 @@ loop:
                        if (BUF_TIMELOCK(bp, LK_EXCLUSIVE | LK_SLEEPFAIL,
                            "getblk", slpflag, slptimeo) == ENOLCK)
                                goto loop;
-                       splx(s);
+                       crit_exit();
                        return (struct buf *) NULL;
                }
 
@@ -2302,7 +2296,7 @@ loop:
                        goto loop;
                }
 
-               splx(s);
+               crit_exit();
                bp->b_flags &= ~B_DONE;
        } else {
                /*
@@ -2342,7 +2336,7 @@ loop:
 
                if ((bp = getnewbuf(slpflag, slptimeo, size, maxsize)) == NULL) {
                        if (slpflag || slptimeo) {
-                               splx(s);
+                               crit_exit();
                                return NULL;
                        }
                        goto loop;
@@ -2354,9 +2348,9 @@ loop:
                 * This can be a problem whether the vnode is locked or not.
                 * If the buffer is created out from under us, we have to
                 * throw away the one we just created.  There is now window
-                * race because we are safely running at splbio() from the
-                * point of the duplicate buffer creation through to here,
-                * and we've locked the buffer.
+                * race because we are safely running in a critical section
+                * from the point of the duplicate buffer creation through
+                * to here, and we've locked the buffer.
                 */
                if (gbincore(vp, blkno)) {
                        bp->b_flags |= B_INVAL;
@@ -2395,7 +2389,7 @@ loop:
 
                allocbuf(bp, size);
 
-               splx(s);
+               crit_exit();
                bp->b_flags &= ~B_DONE;
        }
        return (bp);
@@ -2405,21 +2399,21 @@ loop:
  * Get an empty, disassociated buffer of given size.  The buffer is initially
  * set to B_INVAL.
  *
- * spl protection is not required for the allocbuf() call because races are
- * impossible here.
+ * critical section protection is not required for the allocbuf() call
+ * because races are impossible here.
  */
 struct buf *
 geteblk(int size)
 {
        struct buf *bp;
-       int s;
        int maxsize;
 
        maxsize = (size + BKVAMASK) & ~BKVAMASK;
 
-       s = splbio();
-       while ((bp = getnewbuf(0, 0, size, maxsize)) == 0);
-       splx(s);
+       crit_enter();
+       while ((bp = getnewbuf(0, 0, size, maxsize)) == 0)
+               ;
+       crit_exit();
        allocbuf(bp, size);
        bp->b_flags |= B_INVAL; /* b_dep cleared by getnewbuf() */
        return (bp);
@@ -2440,8 +2434,8 @@ geteblk(int size)
  * allocbuf() only adjusts B_CACHE for VMIO buffers.  getblk() deals with
  * B_CACHE for the non-VMIO case.
  *
- * This routine does not need to be called at splbio() but you must own the
- * buffer.
+ * This routine does not need to be called from a critical section but you
+ * must own the buffer.
  */
 int
 allocbuf(struct buf *bp, int size)
@@ -2607,10 +2601,10 @@ allocbuf(struct buf *bp, int size)
                         * B_CACHE if these pages are not valid for the 
                         * range covered by the buffer.
                         *
-                        * spl protection is required to protect against
-                        * interrupts unbusying and freeing pages between
-                        * our vm_page_lookup() and our busycheck/wiring
-                        * call.
+                        * critical section protection is required to protect
+                        * against interrupts unbusying and freeing pages
+                        * between our vm_page_lookup() and our
+                        * busycheck/wiring call.
                         */
                        vp = bp->b_vp;
                        VOP_GETVOBJECT(vp, &obj);
@@ -2747,9 +2741,7 @@ allocbuf(struct buf *bp, int size)
 int
 biowait(struct buf * bp)
 {
-       int s;
-
-       s = splbio();
+       crit_enter();
        while ((bp->b_flags & B_DONE) == 0) {
 #if defined(NO_SCHEDULE_MODS)
                tsleep(bp, 0, "biowait", 0);
@@ -2760,7 +2752,7 @@ biowait(struct buf * bp)
                        tsleep(bp, 0, "biowr", 0);
 #endif
        }
-       splx(s);
+       crit_exit();
        if (bp->b_flags & B_EINTR) {
                bp->b_flags &= ~B_EINTR;
                return (EINTR);
@@ -2798,9 +2790,9 @@ biowait(struct buf * bp)
 void
 biodone(struct buf *bp)
 {
-       int s, error;
+       int error;
 
-       s = splbio();
+       crit_enter();
 
        KASSERT(BUF_REFCNTNB(bp) > 0, ("biodone: bp %p not busy %d", bp, BUF_REFCNTNB(bp)));
        KASSERT(!(bp->b_flags & B_DONE), ("biodone: bp %p already done", bp));
@@ -2811,7 +2803,7 @@ biodone(struct buf *bp)
 
        if (bp->b_flags & B_FREEBUF) {
                brelse(bp);
-               splx(s);
+               crit_exit();
                return;
        }
 
@@ -2823,7 +2815,7 @@ biodone(struct buf *bp)
        if (bp->b_flags & B_CALL) {
                bp->b_flags &= ~B_CALL;
                (*bp->b_iodone) (bp);
-               splx(s);
+               crit_exit();
                return;
        }
        if (LIST_FIRST(&bp->b_dep) != NULL && bioops.io_complete)
@@ -2966,7 +2958,7 @@ biodone(struct buf *bp)
        } else {
                wakeup(bp);
        }
-       splx(s);
+       crit_exit();
 }
 
 /*
@@ -2993,7 +2985,7 @@ vfs_unbusy_pages(struct buf *bp)
                         * When restoring bogus changes the original pages
                         * should still be wired, so we are in no danger of
                         * losing the object association and do not need
-                        * spl protection particularly.
+                        * critical section protection particularly.
                         */
                        if (m == bogus_page) {
                                m = vm_page_lookup(obj, OFF_TO_IDX(bp->b_offset) + i);
index fd6fa35..8ec185e 100644 (file)
@@ -34,7 +34,7 @@
  *
  *     @(#)vfs_cluster.c       8.7 (Berkeley) 2/13/94
  * $FreeBSD: src/sys/kern/vfs_cluster.c,v 1.92.2.9 2001/11/18 07:10:59 dillon Exp $
- * $DragonFly: src/sys/kern/vfs_cluster.c,v 1.12 2005/02/19 00:47:03 joerg Exp $
+ * $DragonFly: src/sys/kern/vfs_cluster.c,v 1.13 2005/06/06 15:02:28 dillon Exp $
  */
 
 #include "opt_debug_cluster.h"
@@ -127,16 +127,15 @@ cluster_read(struct vnode *vp, u_quad_t filesize, daddr_t lblkno,
                } else if ((bp->b_flags & B_RAM) == 0) {
                        return 0;
                } else {
-                       int s;
                        struct buf *tbp;
                        bp->b_flags &= ~B_RAM;
                        /*
-                        * We do the spl here so that there is no window
+                        * We do the crit here so that there is no window
                         * between the incore and the b_usecount increment
-                        * below.  We opt to keep the spl out of the loop
+                        * below.  We opt to keep the crit out of the loop
                         * for efficiency.
                         */
-                       s = splbio();
+                       crit_enter();
                        for (i = 1; i < maxra; i++) {
 
                                if (!(tbp = incore(vp, lblkno+i))) {
@@ -151,7 +150,7 @@ cluster_read(struct vnode *vp, u_quad_t filesize, daddr_t lblkno,
                                        (i == (maxra - 1)))
                                        tbp->b_flags |= B_RAM;
                        }
-                       splx(s);
+                       crit_exit();
                        if (i >= maxra) {
                                return 0;
                        }
@@ -731,12 +730,12 @@ int
 cluster_wbuild(struct vnode *vp, long size, daddr_t start_lbn, int len)
 {
        struct buf *bp, *tbp;
-       int i, j, s;
+       int i, j;
        int totalwritten = 0;
        int dbsize = btodb(size);
 
        while (len > 0) {
-               s = splbio();
+               crit_enter();
                /*
                 * If the buffer is not delayed-write (i.e. dirty), or it 
                 * is delayed-write but either locked or inval, it cannot 
@@ -747,12 +746,12 @@ cluster_wbuild(struct vnode *vp, long size, daddr_t start_lbn, int len)
                  BUF_LOCK(tbp, LK_EXCLUSIVE | LK_NOWAIT)) {
                        ++start_lbn;
                        --len;
-                       splx(s);
+                       crit_exit();
                        continue;
                }
                bremfree(tbp);
                tbp->b_flags &= ~B_DONE;
-               splx(s);
+               crit_exit();
 
                /*
                 * Extra memory in the buffer, punt on this buffer.
@@ -805,13 +804,13 @@ cluster_wbuild(struct vnode *vp, long size, daddr_t start_lbn, int len)
                 */
                for (i = 0; i < len; ++i, ++start_lbn) {
                        if (i != 0) { /* If not the first buffer */
-                               s = splbio();
+                               crit_enter();
                                /*
                                 * If the adjacent data is not even in core it
                                 * can't need to be written.
                                 */
                                if ((tbp = gbincore(vp, start_lbn)) == NULL) {
-                                       splx(s);
+                                       crit_exit();
                                        break;
                                }
 
@@ -828,7 +827,7 @@ cluster_wbuild(struct vnode *vp, long size, daddr_t start_lbn, int len)
                                    (bp->b_flags & (B_VMIO | B_NEEDCOMMIT))) ||
                                    (tbp->b_flags & B_LOCKED) ||
                                    BUF_LOCK(tbp, LK_EXCLUSIVE | LK_NOWAIT)) {
-                                       splx(s);
+                                       crit_exit();
                                        break;
                                }
 
@@ -843,7 +842,7 @@ cluster_wbuild(struct vnode *vp, long size, daddr_t start_lbn, int len)
                                  ((tbp->b_xio.xio_npages + bp->b_xio.xio_npages) >
                                    (vp->v_mount->mnt_iosize_max / PAGE_SIZE))) {
                                        BUF_UNLOCK(tbp);
-                                       splx(s);
+                                       crit_exit();
                                        break;
                                }
                                /*
@@ -853,7 +852,7 @@ cluster_wbuild(struct vnode *vp, long size, daddr_t start_lbn, int len)
                                 */
                                bremfree(tbp);
                                tbp->b_flags &= ~B_DONE;
-                               splx(s);
+                               crit_exit();
                        } /* end of code for non-first buffers only */
                        /* check for latent dependencies to be handled */
                        if ((LIST_FIRST(&tbp->b_dep)) != NULL &&
@@ -894,13 +893,13 @@ cluster_wbuild(struct vnode *vp, long size, daddr_t start_lbn, int len)
                        bp->b_bcount += size;
                        bp->b_bufsize += size;
 
-                       s = splbio();
+                       crit_enter();
                        bundirty(tbp);
                        tbp->b_flags &= ~(B_READ | B_DONE | B_ERROR);
                        tbp->b_flags |= B_ASYNC;
                        reassignbuf(tbp, tbp->b_vp);    /* put on clean list */
                        ++tbp->b_vp->v_numoutput;
-                       splx(s);
+                       crit_exit();
                        BUF_KERNPROC(tbp);
                        TAILQ_INSERT_TAIL(&bp->b_cluster.cluster_head,
                                tbp, b_cluster.cluster_entry);
index 411d704..fd2c1d0 100644 (file)
@@ -26,7 +26,7 @@
  * SUCH DAMAGE.
  *
  *     $FreeBSD: src/sys/kern/vfs_conf.c,v 1.49.2.5 2003/01/07 11:56:53 joerg Exp $
- *     $DragonFly: src/sys/kern/vfs_conf.c,v 1.13 2005/04/19 17:54:42 dillon Exp $
+ *     $DragonFly: src/sys/kern/vfs_conf.c,v 1.14 2005/06/06 15:02:28 dillon Exp $
  */
 
 /*
@@ -60,6 +60,7 @@
 #include <sys/device.h>
 #include <sys/namecache.h>
 #include <sys/paths.h>
+#include <sys/thread2.h>
 
 #include "opt_ddb.h"
 #ifdef DDB
@@ -192,7 +193,6 @@ vfs_mountroot_try(const char *mountfrom)
        char            *vfsname, *devname;
        int             error;
        char            patt[32];
-       int             s;
 
        vfsname = NULL;
        devname = NULL;
@@ -202,9 +202,9 @@ vfs_mountroot_try(const char *mountfrom)
        if (mountfrom == NULL)
                return(error);          /* don't complain */
 
-       s = splcam();                   /* Overkill, but annoying without it */
+       crit_enter();
        printf("Mounting root from %s\n", mountfrom);
-       splx(s);
+       crit_exit();
 
        /* parse vfs name and devname */
        vfsname = malloc(MFSNAMELEN, M_MOUNT, M_WAITOK);
index 9f5b410..c766657 100644 (file)
@@ -67,7 +67,7 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- * $DragonFly: src/sys/kern/vfs_mount.c,v 1.10 2005/04/20 17:01:50 dillon Exp $
+ * $DragonFly: src/sys/kern/vfs_mount.c,v 1.11 2005/06/06 15:02:28 dillon Exp $
  */
 
 /*
@@ -605,12 +605,11 @@ vnlru_proc(void)
 {
        struct thread *td = curthread;
        int done;
-       int s;
 
        EVENTHANDLER_REGISTER(shutdown_pre_sync, shutdown_kproc, td,
            SHUTDOWN_PRI_FIRST);   
 
-       s = splbio();
+       crit_enter();
        for (;;) {
                kproc_suspend_loop();
                if (numvnodes - freevnodes <= desiredvnodes * 9 / 10) {
@@ -641,7 +640,7 @@ vnlru_proc(void)
                        vnlru_nowhere = 0;
                }
        }
-       splx(s);
+       crit_exit();
 }
 
 /*
index e1d3635..1b50e4f 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.56 2005/05/06 11:52:02 corecode Exp $
+ * $DragonFly: src/sys/kern/vfs_subr.c,v 1.57 2005/06/06 15:02:28 dillon Exp $
  */
 
 /*
@@ -295,7 +295,7 @@ vinvalbuf(struct vnode *vp, int flags, struct thread *td,
        int slpflag, int slptimeo)
 {
        struct vinvalbuf_bp_info info;
-       int s, error;
+       int error;
        vm_object_t object;
 
        /*
@@ -303,28 +303,28 @@ vinvalbuf(struct vnode *vp, int flags, struct thread *td,
         * is updated.
         */
        if (flags & V_SAVE) {
-               s = splbio();
+               crit_enter();
                while (vp->v_numoutput) {
                        vp->v_flag |= VBWAIT;
                        error = tsleep((caddr_t)&vp->v_numoutput,
                            slpflag, "vinvlbuf", slptimeo);
                        if (error) {
-                               splx(s);
+                               crit_exit();
                                return (error);
                        }
                }
                if (!RB_EMPTY(&vp->v_rbdirty_tree)) {
-                       splx(s);
+                       crit_exit();
                        if ((error = VOP_FSYNC(vp, MNT_WAIT, td)) != 0)
                                return (error);
-                       s = splbio();
+                       crit_enter();
                        if (vp->v_numoutput > 0 ||
                            !RB_EMPTY(&vp->v_rbdirty_tree))
                                panic("vinvalbuf: dirty bufs");
                }
-               splx(s);
+               crit_exit();
        }
-       s = splbio();
+       crit_enter();
        info.slptimeo = slptimeo;
        info.slpflag = slpflag;
        info.flags = flags;
@@ -359,7 +359,7 @@ vinvalbuf(struct vnode *vp, int flags, struct thread *td,
                }
        } while (vp->v_numoutput > 0);
 
-       splx(s);
+       crit_exit();
 
        /*
         * Destroy the copy in the VM cache, too.
@@ -441,7 +441,6 @@ vtruncbuf(struct vnode *vp, struct thread *td, off_t length, int blksize)
 {
        daddr_t trunclbn;
        int count;
-       int s;
 
        /*
         * Round up to the *next* lbn, then destroy the buffers in question.  
@@ -450,7 +449,7 @@ vtruncbuf(struct vnode *vp, struct thread *td, off_t length, int blksize)
         */
        trunclbn = (length + blksize - 1) / blksize;
 
-       s = splbio();
+       crit_enter();
        do {
                count = RB_SCAN(buf_rb_tree, &vp->v_rbclean_tree, 
                                vtruncbuf_bp_trunc_cmp,
@@ -482,7 +481,7 @@ vtruncbuf(struct vnode *vp, struct thread *td, off_t length, int blksize)
                tsleep(&vp->v_numoutput, 0, "vbtrunc", 0);
        }
 
-       splx(s);
+       crit_exit();
 
        vnode_pager_setsize(vp, length);
 
@@ -591,7 +590,6 @@ struct vfsync_info {
        int lazycount;
        int lazylimit;
        daddr_t lbn;
-       int s;
        int (*checkdef)(struct buf *);
 };
 
@@ -605,11 +603,12 @@ vfsync(struct vnode *vp, int waitfor, int passes, daddr_t lbn,
 
        bzero(&info, sizeof(info));
        info.vp = vp;
-       info.s = splbio();
        info.lbn = lbn;
        if ((info.checkdef = checkdef) == NULL)
                info.syncdeps = 1;
 
+       crit_enter();
+
        switch(waitfor) {
        case MNT_LAZY:
                /*
@@ -670,7 +669,7 @@ vfsync(struct vnode *vp, int waitfor, int passes, daddr_t lbn,
                }
                break;
        }
-       splx(info.s);
+       crit_exit();
        return(error);
 }
 
@@ -756,9 +755,9 @@ vfsync_bp(struct buf *bp, void *data)
            bp->b_lblkno >= info->lbn) {
                bremfree(bp);
                bp->b_flags |= B_INVAL | B_NOCACHE;
-               splx(info->s);
+               crit_exit();
                brelse(bp);
-               info->s = splbio();
+               crit_enter();
        }
 
        if (info->synchronous) {
@@ -766,9 +765,9 @@ vfsync_bp(struct buf *bp, void *data)
                 * Synchronous flushing.  An error may be returned.
                 */
                bremfree(bp);
-               splx(info->s);
+               crit_exit();
                error = bwrite(bp);
-               info->s = splbio();
+               crit_enter();
        } else { 
                /*
                 * Asynchronous flushing.  A negative return value simply
@@ -782,9 +781,9 @@ vfsync_bp(struct buf *bp, void *data)
                } else {
                        info->lazycount += bp->b_bufsize;
                        bremfree(bp);
-                       splx(info->s);
+                       crit_exit();
                        bawrite(bp);
-                       info->s = splbio();
+                       crit_enter();
                }
                if (info->lazylimit && info->lazycount >= info->lazylimit)
                        error = 1;
index cac7209..244efb8 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_sync.c,v 1.5 2005/04/19 17:54:42 dillon Exp $
+ * $DragonFly: src/sys/kern/vfs_sync.c,v 1.6 2005/06/06 15:02:28 dillon Exp $
  */
 
 /*
@@ -188,7 +188,6 @@ sched_sync(void)
        struct synclist *slp;
        struct vnode *vp;
        long starttime;
-       int s;
        struct thread *td = curthread;
 
        EVENTHANDLER_REGISTER(shutdown_pre_sync, shutdown_kproc, td,
@@ -203,19 +202,19 @@ sched_sync(void)
                 * Push files whose dirty time has expired.  Be careful
                 * of interrupt race on slp queue.
                 */
-               s = splbio();
+               crit_enter();
                slp = &syncer_workitem_pending[syncer_delayno];
                syncer_delayno += 1;
                if (syncer_delayno == syncer_maxdelay)
                        syncer_delayno = 0;
-               splx(s);
+               crit_exit();
 
                while ((vp = LIST_FIRST(slp)) != NULL) {
                        if (vget(vp, LK_EXCLUSIVE | LK_NOWAIT, td) == 0) {
                                VOP_FSYNC(vp, MNT_LAZY, td);
                                vput(vp);
                        }
-                       s = splbio();
+                       crit_enter();
 
                        /*
                         * If the vnode is still at the head of the list
@@ -235,7 +234,7 @@ sched_sync(void)
                                }
                                vn_syncer_add_to_worklist(vp, syncdelay);
                        }
-                       splx(s);
+                       crit_exit();
                }
 
                /*
@@ -433,7 +432,8 @@ sync_inactive(struct vop_inactive_args *ap)
 /*
  * The syncer vnode is no longer needed and is being decommissioned.
  *
- * Modifications to the worklist must be protected at splbio().
+ * Modifications to the worklist must be protected with a critical
+ * section.
  *
  *     sync_reclaim { struct vnode *a_vp }
  */
@@ -441,15 +441,14 @@ static int
 sync_reclaim(struct vop_reclaim_args *ap)
 {
        struct vnode *vp = ap->a_vp;
-       int s;
 
-       s = splbio();
+       crit_enter();
        vp->v_mount->mnt_syncer = NULL;
        if (vp->v_flag & VONWORKLST) {
                LIST_REMOVE(vp, v_synclist);
                vp->v_flag &= ~VONWORKLST;
        }
-       splx(s);
+       crit_exit();
 
        return (0);
 }
index b4b6c6a..db70e99 100644 (file)
@@ -37,7 +37,7 @@
  *
  *     @(#)vfs_syscalls.c      8.13 (Berkeley) 4/15/94
  * $FreeBSD: src/sys/kern/vfs_syscalls.c,v 1.151.2.18 2003/04/04 20:35:58 tegge Exp $
- * $DragonFly: src/sys/kern/vfs_syscalls.c,v 1.61 2005/04/19 17:54:42 dillon Exp $
+ * $DragonFly: src/sys/kern/vfs_syscalls.c,v 1.62 2005/06/06 15:02:28 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -3620,7 +3620,7 @@ extattr_delete_file(struct extattr_delete_file_args *uap)
 void
 vfs_bufstats(void)
 {
-        int s, i, j, count;
+        int i, j, count;
         struct buf *bp;
         struct bqueues *dp;
         int counts[(MAXBSIZE / PAGE_SIZE) + 1];
@@ -3630,12 +3630,12 @@ vfs_bufstats(void)
                 count = 0;
                 for (j = 0; j <= MAXBSIZE/PAGE_SIZE; j++)
                         counts[j] = 0;
-                s = splbio();
+               crit_enter();
                 TAILQ_FOREACH(bp, dp, b_freelist) {
                         counts[bp->b_bufsize/PAGE_SIZE]++;
                         count++;
                 }
-                splx(s);
+               crit_exit();
                 printf("%s: total-%d", bname[i], count);
                 for (j = 0; j <= MAXBSIZE/PAGE_SIZE; j++)
                         if (counts[j] != 0)
index a5e5efb..c625ed4 100644 (file)
@@ -35,7 +35,7 @@
  *
  *     from: @(#)autoconf.c    7.1 (Berkeley) 5/9/91
  * $FreeBSD: src/sys/i386/i386/autoconf.c,v 1.146.2.2 2001/06/07 06:05:58 dd Exp $
- * $DragonFly: src/sys/platform/pc32/i386/autoconf.c,v 1.15 2004/10/14 18:31:02 dillon Exp $
+ * $DragonFly: src/sys/platform/pc32/i386/autoconf.c,v 1.16 2005/06/06 15:02:26 dillon Exp $
  */
 
 /*
@@ -181,7 +181,7 @@ configure(dummy)
         * completely safe (since a panic may occur in a critical region
         * at splhigh()), but we want at least bio interrupts to work.
         */
-       safepri = curthread->td_cpl;
+       safepri = TDPRI_KERN_USER;
 }
 
 static void
index 04da286..1fa4e1c 100644 (file)
@@ -36,7 +36,7 @@
  *
  *     from: @(#)machdep.c     7.4 (Berkeley) 6/3/91
  * $FreeBSD: src/sys/i386/i386/machdep.c,v 1.385.2.30 2003/05/31 08:48:05 alc Exp $
- * $DragonFly: src/sys/platform/pc32/i386/machdep.c,v 1.72 2005/03/17 08:22:38 swildner Exp $
+ * $DragonFly: src/sys/platform/pc32/i386/machdep.c,v 1.73 2005/06/06 15:02:26 dillon Exp $
  */
 
 #include "use_apm.h"
@@ -1872,7 +1872,8 @@ init386(int first)
        thread0.td_flags |= TDF_RUNNING;
        thread0.td_proc = &proc0;
        thread0.td_switch = cpu_heavy_switch;   /* YYY eventually LWKT */
-       safepri = thread0.td_cpl = SWI_MASK | HWI_MASK;
+       thread0.td_cpl = 0;                     /* crit section protects us */
+       safepri = TDPRI_MAX;
 
        /* make ldt memory segments */
        /*
index b04eba9..17bcb65 100644 (file)
@@ -8,7 +8,7 @@
  *     on a different cpu will not be immediately scheduled by a yield() on
  *     this cpu.
  *
- * $DragonFly: src/sys/sys/thread2.h,v 1.18 2005/06/03 23:57:34 dillon Exp $
+ * $DragonFly: src/sys/sys/thread2.h,v 1.19 2005/06/06 15:02:24 dillon Exp $
  */
 
 #ifndef _SYS_THREAD2_H_
@@ -107,21 +107,6 @@ crit_exit_gd(globaldata_t mygd)
 }
 
 static __inline int
-crit_panic_save(void)
-{
-    thread_t td = curthread;
-    int pri = td->td_pri;
-    td->td_pri = td->td_pri & TDPRI_MASK;
-    return(pri);
-}
-
-static __inline void
-crit_panic_restore(int cpri)
-{
-    curthread->td_pri = cpri;
-}
-
-static __inline int
 crit_test(thread_t td)
 {
     return(td->td_pri >= TDPRI_CRIT);