Fix a number of interrupt related issues.
authorMatthew Dillon <dillon@dragonflybsd.org>
Thu, 2 Oct 2003 22:27:00 +0000 (22:27 +0000)
committerMatthew Dillon <dillon@dragonflybsd.org>
Thu, 2 Oct 2003 22:27:00 +0000 (22:27 +0000)
* Don't access kernel_map in free(), defer such operations to malloc()

* Fix a slab allocator panic due to mishandling of malloc size slab
  limit checks on machines with small amounts of memory (the slab allocator
  reduces the size of the zone on low-memory machines but did not handle the
  reduced size properly).

* Add thread->td_nest_count to prevent splz recursions from underflowing
  the kernel stack.  This can occur because we drop the critical section
  when calling sched_ithd() in order to allow it to preempt.

* Properly adjust intr_nesting_level around FAST interrupts

* Adjust the debugging printf() in lockmgr to only complain about blockable
  lock requests from interrupts.

13 files changed:
sys/i386/i386/genassym.c
sys/i386/isa/ipl.s
sys/i386/isa/ipl_funcs.c
sys/kern/kern_lock.c
sys/kern/kern_slaballoc.c
sys/kern/lwkt_thread.c
sys/platform/pc32/i386/genassym.c
sys/platform/pc32/isa/ipl.s
sys/platform/pc32/isa/ipl_funcs.c
sys/platform/vkernel/i386/genassym.c
sys/sys/globaldata.h
sys/sys/slaballoc.h
sys/sys/thread.h

index 5ea3076..d803606 100644 (file)
@@ -35,7 +35,7 @@
  *
  *     from: @(#)genassym.c    5.11 (Berkeley) 5/10/91
  * $FreeBSD: src/sys/i386/i386/genassym.c,v 1.86.2.3 2002/03/03 05:42:49 nyan Exp $
- * $DragonFly: src/sys/i386/i386/Attic/genassym.c,v 1.29 2003/09/16 20:03:35 dillon Exp $
+ * $DragonFly: src/sys/i386/i386/Attic/genassym.c,v 1.30 2003/10/02 22:26:56 dillon Exp $
  */
 
 #include "opt_user_ldt.h"
@@ -86,6 +86,7 @@ ASSYM(TD_SP, offsetof(struct thread, td_sp));
 ASSYM(TD_PRI, offsetof(struct thread, td_pri));
 ASSYM(TD_MACH, offsetof(struct thread, td_mach));
 ASSYM(TD_WCHAN, offsetof(struct thread, td_wchan));
+ASSYM(TD_NEST_COUNT, offsetof(struct thread, td_nest_count));
 #ifdef SMP
 ASSYM(TD_MPCOUNT, offsetof(struct thread, td_mpcount));
 #endif
index 2a60b39..f9bf86b 100644 (file)
@@ -37,7 +37,7 @@
  *     @(#)ipl.s
  *
  * $FreeBSD: src/sys/i386/isa/ipl.s,v 1.32.2.3 2002/05/16 16:03:56 bde Exp $
- * $DragonFly: src/sys/i386/isa/Attic/ipl.s,v 1.13 2003/09/25 23:49:08 dillon Exp $
+ * $DragonFly: src/sys/i386/isa/Attic/ipl.s,v 1.14 2003/10/02 22:26:59 dillon Exp $
  */
 
 
@@ -70,6 +70,26 @@ softnet_imask:       .long   SWI_NET_MASK
 softtty_imask: .long   SWI_TTY_MASK
 
        .text
+       /*
+        * GENERAL NOTES
+        *
+        *      - fast interrupts are always called with a critical section
+        *        held
+        *
+        *      - we release our critical section when scheduling interrupt
+        *        or softinterrupt threads in order so they can preempt
+        *        (unless we are called manually from a critical section, in
+        *        which case there will still be a critical section and
+        *        they won't preempt anyway).
+        *
+        *      - TD_NEST_COUNT prevents splz from nesting too deeply within
+        *        itself.  It is *not* actually an interrupt nesting count.
+        *        PCPU(intr_nesting_level) is an interrupt nesting count.
+        *
+        *      - We have to be careful in regards to local interrupts
+        *        occuring simultaniously with our doreti and splz 
+        *        processing.
+        */
 
        /*
         * DORETI
@@ -80,6 +100,7 @@ softtty_imask:       .long   SWI_TTY_MASK
         *
         * If we are in a critical section we cannot run any pending ints
         * nor can be play with mp_lock.
+        *
         */
        SUPERALIGN_TEXT
        .type   doreti,@function
@@ -203,8 +224,9 @@ doreti_fast:
        /*
         *  INTR interrupt pending
         *
-        *  Temporarily back-out our critical section to allow the interrupt
-        *  preempt us.
+        *  Temporarily back-out our critical section to allow an interrupt
+        *  preempt us when we schedule it.  Bump intr_nesting_level to
+        *  prevent the switch code from recursing via splz too deeply.
         */
        ALIGN_TEXT
 doreti_intr:
@@ -214,9 +236,11 @@ doreti_intr:
        jnc     doreti_next
        pushl   %eax
        pushl   %ecx
+       incl    TD_NEST_COUNT(%ebx)     /* prevent doreti/splz nesting */
        subl    $TDPRI_CRIT,TD_PRI(%ebx) /* so we can preempt */
        call    sched_ithd              /* YYY must pull in imasks */
        addl    $TDPRI_CRIT,TD_PRI(%ebx)
+       decl    TD_NEST_COUNT(%ebx)
        addl    $4,%esp
        popl    %eax
        jmp     doreti_next
@@ -320,7 +344,9 @@ splz_fast:
        testl   %eax,%eax
        jz      1f
 #endif
+       incl    PCPU(intr_nesting_level)
        call    *fastunpend(,%ecx,4)
+       decl    PCPU(intr_nesting_level)
 #ifdef SMP
        call    rel_mplock
 #endif
@@ -348,8 +374,10 @@ splz_intr:
        pushl   %eax
        pushl   %ecx
        subl    $TDPRI_CRIT,TD_PRI(%ebx)
+       incl    TD_NEST_COUNT(%ebx)     /* prevent doreti/splz nesting */
        call    sched_ithd              /* YYY must pull in imasks */
        addl    $TDPRI_CRIT,TD_PRI(%ebx)
+       decl    TD_NEST_COUNT(%ebx)     /* prevent doreti/splz nesting */
        addl    $4,%esp
        popl    %eax
        jmp     splz_next
index e5d29e2..856c7a1 100644 (file)
@@ -24,7 +24,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/i386/isa/ipl_funcs.c,v 1.32.2.5 2002/12/17 18:04:02 sam Exp $
- * $DragonFly: src/sys/i386/isa/Attic/ipl_funcs.c,v 1.7 2003/07/12 17:54:35 dillon Exp $
+ * $DragonFly: src/sys/i386/isa/Attic/ipl_funcs.c,v 1.8 2003/10/02 22:26:59 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -166,6 +166,10 @@ unsigned NAME(void)                                \
        return (x);                             \
 }
 
+/*
+ * Note: we do not have to check td->td_nest_count in these functions, only
+ * whether we are in a critical section or not.
+ */
 void
 spl0(void)
 {
index 88bbecb..ad62c35 100644 (file)
  *
  *     @(#)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.7 2003/09/25 23:52:28 dillon Exp $
+ * $DragonFly: src/sys/kern/kern_lock.c,v 1.8 2003/10/02 22:27:00 dillon Exp $
  */
 
 #include "opt_lint.h"
 
 #include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
 #include <sys/proc.h>
 #include <sys/lock.h>
-#include <sys/systm.h>
+#include <sys/sysctl.h>
+
+/*
+ * 0: no warnings, 1: warnings, 2: panic
+ */
+static int lockmgr_from_int = 1;
+SYSCTL_INT(_debug, OID_AUTO, lockmgr_from_int, CTLFLAG_RW, &lockmgr_from_int, 0, "");
 
 /*
  * Locking primitives implementation.
@@ -160,19 +168,33 @@ debuglockmgr(struct lock *lkp, u_int flags, struct lwkt_token *interlkp,
 
        error = 0;
 
-       if ((flags & LK_NOWAIT) == 0 && (flags & LK_TYPE_MASK) != LK_RELEASE && didpanic == 0) {
+       if (lockmgr_from_int && mycpu->gd_intr_nesting_level &&
+           (flags & LK_NOWAIT) == 0 && 
+           (flags & LK_TYPE_MASK) != LK_RELEASE && didpanic == 0) {
 #ifndef DEBUG_LOCKS
-               if (mycpu->gd_intr_nesting_level) {
-                       /* didpanic = 1; printf below will be a panic soon */
-                       printf("lockmgr %s from %p: called from FASTint\n",
-                           lkp->lk_wmesg, ((int **)&lkp)[-1]);
-               }
+                   if (lockmgr_from_int == 2) {
+                           didpanic = 1;
+                           panic(
+                               "lockmgr %s from %p: called from interrupt",
+                               lkp->lk_wmesg, ((int **)&lkp)[-1]);
+                           didpanic = 0;
+                   } else {
+                           printf(
+                               "lockmgr %s from %p: called from interrupt\n",
+                               lkp->lk_wmesg, ((int **)&lkp)[-1]);
+                   }
 #else
-               if (mycpu->gd_intr_nesting_level) {
-                       /* didpanic = 1; printf below will be a panic soon */
-                       printf("lockmgr %s from %s:%d: called from FASTint\n",
-                           lkp->lk_wmesg, file, line);
-               }
+                   if (lockmgr_from_int == 2) {
+                           didpanic = 1;
+                           panic("
+                               lockmgr %s from %s:%d: called from interrupt",
+                               lkp->lk_wmesg, file, line);
+                           didpanic = 0;
+                   } else {
+                           printf("
+                               lockmgr %s from %s:%d: called from interrupt\n",
+                               lkp->lk_wmesg, file, line);
+                   }
 #endif
        }
 
index a87fe8a..05486c8 100644 (file)
@@ -25,7 +25,7 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- * $DragonFly: src/sys/kern/kern_slaballoc.c,v 1.6 2003/09/26 19:23:31 dillon Exp $
+ * $DragonFly: src/sys/kern/kern_slaballoc.c,v 1.7 2003/10/02 22:27:00 dillon Exp $
  *
  * This module implements a slab allocator drop-in replacement for the
  * kernel malloc().
@@ -68,7 +68,7 @@
  *     16384-32767     2048            8
  *     (if PAGE_SIZE is 4K the maximum zone allocation is 16383)
  *
- *     Allocations >= ZALLOC_ZONE_LIMIT go directly to kmem.
+ *     Allocations >= ZoneLimit go directly to kmem.
  *
  *                     API REQUIREMENTS AND SIDE EFFECTS
  *
  * Fixed globals (not per-cpu)
  */
 static int ZoneSize;
+static int ZoneLimit;
 static int ZonePageCount;
 static int ZonePageLimit;
 static int ZoneMask;
@@ -187,6 +188,9 @@ kmeminit(void *dummy)
     ZoneSize = ZALLOC_MIN_ZONE_SIZE;
     while (ZoneSize < ZALLOC_MAX_ZONE_SIZE && (ZoneSize << 1) < usesize)
        ZoneSize <<= 1;
+    ZoneLimit = ZoneSize / 4;
+    if (ZoneLimit > ZALLOC_ZONE_LIMIT)
+       ZoneLimit = ZALLOC_ZONE_LIMIT;
     ZoneMask = ZoneSize - 1;
     ZonePageLimit = PAGE_SIZE * 4;
     ZonePageCount = ZoneSize / PAGE_SIZE;
@@ -376,14 +380,26 @@ malloc(unsigned long size, struct malloc_type *type, int flags)
      * being called via an IPI message or from sensitive interrupt code.
      */
     while (slgd->NFreeZones > ZONE_RELS_THRESH && (flags & M_NOWAIT) == 0) {
-           crit_enter();
-           if (slgd->NFreeZones > ZONE_RELS_THRESH) {  /* crit sect race */
-                   z = slgd->FreeZones;
-                   slgd->FreeZones = z->z_Next;
-                   --slgd->NFreeZones;
-                   kmem_slab_free(z, ZoneSize);        /* may block */
-           }
-           crit_exit();
+       crit_enter();
+       if (slgd->NFreeZones > ZONE_RELS_THRESH) {      /* crit sect race */
+           z = slgd->FreeZones;
+           slgd->FreeZones = z->z_Next;
+           --slgd->NFreeZones;
+           kmem_slab_free(z, ZoneSize);        /* may block */
+       }
+       crit_exit();
+    }
+    /*
+     * XXX handle oversized frees that were queued from free().
+     */
+    while (slgd->FreeOvZones && (flags & M_NOWAIT) == 0) {
+       crit_enter();
+       if ((z = slgd->FreeOvZones) != NULL) {
+           KKASSERT(z->z_Magic == ZALLOC_OVSZ_MAGIC);
+           slgd->FreeOvZones = z->z_Next;
+           kmem_slab_free(z, z->z_ChunkSize);  /* may block */
+       }
+       crit_exit();
     }
 
     /*
@@ -392,7 +408,7 @@ malloc(unsigned long size, struct malloc_type *type, int flags)
      *
      * Guarentee page alignment for allocations in multiples of PAGE_SIZE
      */
-    if (size >= ZALLOC_ZONE_LIMIT || (size & PAGE_MASK) == 0) {
+    if (size >= ZoneLimit || (size & PAGE_MASK) == 0) {
        struct kmemusage *kup;
 
        size = round_page(size);
@@ -645,7 +661,17 @@ free(void *ptr, struct malloc_type *type)
            KKASSERT(sizeof(weirdary) <= size);
            bcopy(weirdary, ptr, sizeof(weirdary));
 #endif
-           kmem_slab_free(ptr, size);  /* may block */
+           if (mycpu->gd_intr_nesting_level) {
+               crit_enter();
+               z = (SLZone *)ptr;
+               z->z_Magic = ZALLOC_OVSZ_MAGIC;
+               z->z_Next = slgd->FreeOvZones;
+               z->z_ChunkSize = size;
+               slgd->FreeOvZones = z;
+               crit_exit();
+           } else {
+               kmem_slab_free(ptr, size);      /* may block */
+           }
            return;
        }
     }
index 24af0e9..34023a7 100644 (file)
@@ -28,7 +28,7 @@
  *     to use a critical section to avoid problems.  Foreign thread 
  *     scheduling is queued via (async) IPIs.
  *
- * $DragonFly: src/sys/kern/lwkt_thread.c,v 1.33 2003/10/01 22:53:44 dillon Exp $
+ * $DragonFly: src/sys/kern/lwkt_thread.c,v 1.34 2003/10/02 22:27:00 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -302,9 +302,11 @@ lwkt_switch(void)
     int mpheld;
 #endif
 
-    if (mycpu->gd_intr_nesting_level && 
-       td->td_preempted == NULL && panicstr == NULL
-    ) {
+    /*
+     * Switching from within a 'fast' (non thread switched) interrupt is
+     * illegal.
+     */
+    if (mycpu->gd_intr_nesting_level && panicstr == NULL) {
        panic("lwkt_switch: cannot switch from within a fast interrupt, yet\n");
     }
 
@@ -494,7 +496,8 @@ lwkt_maybe_switch()
 void
 lwkt_preempt(thread_t ntd, int critpri)
 {
-    thread_t td = curthread;
+    struct globaldata *gd = mycpu;
+    thread_t td = gd->gd_curthread;
 #ifdef SMP
     int mpheld;
     int savecnt;
@@ -521,7 +524,7 @@ lwkt_preempt(thread_t ntd, int critpri)
        return;
     }
 #ifdef SMP
-    if (ntd->td_gd != mycpu) {
+    if (ntd->td_gd != gd) {
        ++preempt_miss;
        return;
     }
@@ -577,7 +580,7 @@ lwkt_preempt(thread_t ntd, int critpri)
  *
  * This function will not generally yield to equal priority threads but it
  * can occur as a side effect.  Note that lwkt_switch() is called from
- * inside the critical section to pervent its own crit_exit() from reentering
+ * inside the critical section to prevent its own crit_exit() from reentering
  * lwkt_yield_quick().
  *
  * gd_reqflags indicates that *something* changed, e.g. an interrupt or softint
@@ -595,13 +598,17 @@ lwkt_yield_quick(void)
      * gd_reqflags is cleared in splz if the cpl is 0.  If we were to clear
      * it with a non-zero cpl then we might not wind up calling splz after
      * a task switch when the critical section is exited even though the
-     * new task could accept the interrupt.  YYY alternative is to have
-     * lwkt_switch() just call splz unconditionally.
+     * new task could accept the interrupt.
      *
      * XXX from crit_exit() only called after last crit section is released.
      * If called directly will run splz() even if in a critical section.
+     *
+     * td_nest_count prevent deep nesting via splz() or doreti().  Note that
+     * except for this special case, we MUST call splz() here to handle any
+     * pending ints, particularly after we switch, or we might accidently
+     * halt the cpu with interrupts pending.
      */
-    if (gd->gd_reqflags)
+    if (gd->gd_reqflags && td->td_nest_count < 2)
        splz();
 
     /*
@@ -610,7 +617,9 @@ lwkt_yield_quick(void)
      * preemption and MP without actually doing preemption or MP, because a
      * lot of code assumes that wakeup() does not block.
      */
-    if (untimely_switch && gd->gd_intr_nesting_level == 0) {
+    if (untimely_switch && td->td_nest_count == 0 &&
+       gd->gd_intr_nesting_level == 0
+    ) {
        crit_enter();
        /*
         * YYY temporary hacks until we disassociate the userland scheduler
@@ -1271,6 +1280,9 @@ kthread_exit(void)
  * IPIQ while waiting for it to empty or we may deadlock with another cpu.
  * Create a CPU_*() function to do this!
  *
+ * We can safely bump gd_intr_nesting_level because our crit_exit() at the
+ * end will take care of any pending interrupts.
+ *
  * Must be called from a critical section.
  */
 int
index 45b18b9..d4bf1a7 100644 (file)
@@ -35,7 +35,7 @@
  *
  *     from: @(#)genassym.c    5.11 (Berkeley) 5/10/91
  * $FreeBSD: src/sys/i386/i386/genassym.c,v 1.86.2.3 2002/03/03 05:42:49 nyan Exp $
- * $DragonFly: src/sys/platform/pc32/i386/genassym.c,v 1.29 2003/09/16 20:03:35 dillon Exp $
+ * $DragonFly: src/sys/platform/pc32/i386/genassym.c,v 1.30 2003/10/02 22:26:56 dillon Exp $
  */
 
 #include "opt_user_ldt.h"
@@ -86,6 +86,7 @@ ASSYM(TD_SP, offsetof(struct thread, td_sp));
 ASSYM(TD_PRI, offsetof(struct thread, td_pri));
 ASSYM(TD_MACH, offsetof(struct thread, td_mach));
 ASSYM(TD_WCHAN, offsetof(struct thread, td_wchan));
+ASSYM(TD_NEST_COUNT, offsetof(struct thread, td_nest_count));
 #ifdef SMP
 ASSYM(TD_MPCOUNT, offsetof(struct thread, td_mpcount));
 #endif
index 76fd90d..a2831c6 100644 (file)
@@ -37,7 +37,7 @@
  *     @(#)ipl.s
  *
  * $FreeBSD: src/sys/i386/isa/ipl.s,v 1.32.2.3 2002/05/16 16:03:56 bde Exp $
- * $DragonFly: src/sys/platform/pc32/isa/ipl.s,v 1.13 2003/09/25 23:49:08 dillon Exp $
+ * $DragonFly: src/sys/platform/pc32/isa/ipl.s,v 1.14 2003/10/02 22:26:59 dillon Exp $
  */
 
 
@@ -70,6 +70,26 @@ softnet_imask:       .long   SWI_NET_MASK
 softtty_imask: .long   SWI_TTY_MASK
 
        .text
+       /*
+        * GENERAL NOTES
+        *
+        *      - fast interrupts are always called with a critical section
+        *        held
+        *
+        *      - we release our critical section when scheduling interrupt
+        *        or softinterrupt threads in order so they can preempt
+        *        (unless we are called manually from a critical section, in
+        *        which case there will still be a critical section and
+        *        they won't preempt anyway).
+        *
+        *      - TD_NEST_COUNT prevents splz from nesting too deeply within
+        *        itself.  It is *not* actually an interrupt nesting count.
+        *        PCPU(intr_nesting_level) is an interrupt nesting count.
+        *
+        *      - We have to be careful in regards to local interrupts
+        *        occuring simultaniously with our doreti and splz 
+        *        processing.
+        */
 
        /*
         * DORETI
@@ -80,6 +100,7 @@ softtty_imask:       .long   SWI_TTY_MASK
         *
         * If we are in a critical section we cannot run any pending ints
         * nor can be play with mp_lock.
+        *
         */
        SUPERALIGN_TEXT
        .type   doreti,@function
@@ -203,8 +224,9 @@ doreti_fast:
        /*
         *  INTR interrupt pending
         *
-        *  Temporarily back-out our critical section to allow the interrupt
-        *  preempt us.
+        *  Temporarily back-out our critical section to allow an interrupt
+        *  preempt us when we schedule it.  Bump intr_nesting_level to
+        *  prevent the switch code from recursing via splz too deeply.
         */
        ALIGN_TEXT
 doreti_intr:
@@ -214,9 +236,11 @@ doreti_intr:
        jnc     doreti_next
        pushl   %eax
        pushl   %ecx
+       incl    TD_NEST_COUNT(%ebx)     /* prevent doreti/splz nesting */
        subl    $TDPRI_CRIT,TD_PRI(%ebx) /* so we can preempt */
        call    sched_ithd              /* YYY must pull in imasks */
        addl    $TDPRI_CRIT,TD_PRI(%ebx)
+       decl    TD_NEST_COUNT(%ebx)
        addl    $4,%esp
        popl    %eax
        jmp     doreti_next
@@ -320,7 +344,9 @@ splz_fast:
        testl   %eax,%eax
        jz      1f
 #endif
+       incl    PCPU(intr_nesting_level)
        call    *fastunpend(,%ecx,4)
+       decl    PCPU(intr_nesting_level)
 #ifdef SMP
        call    rel_mplock
 #endif
@@ -348,8 +374,10 @@ splz_intr:
        pushl   %eax
        pushl   %ecx
        subl    $TDPRI_CRIT,TD_PRI(%ebx)
+       incl    TD_NEST_COUNT(%ebx)     /* prevent doreti/splz nesting */
        call    sched_ithd              /* YYY must pull in imasks */
        addl    $TDPRI_CRIT,TD_PRI(%ebx)
+       decl    TD_NEST_COUNT(%ebx)     /* prevent doreti/splz nesting */
        addl    $4,%esp
        popl    %eax
        jmp     splz_next
index 50e027e..97e7af1 100644 (file)
@@ -24,7 +24,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/i386/isa/ipl_funcs.c,v 1.32.2.5 2002/12/17 18:04:02 sam Exp $
- * $DragonFly: src/sys/platform/pc32/isa/ipl_funcs.c,v 1.7 2003/07/12 17:54:35 dillon Exp $
+ * $DragonFly: src/sys/platform/pc32/isa/ipl_funcs.c,v 1.8 2003/10/02 22:26:59 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -166,6 +166,10 @@ unsigned NAME(void)                                \
        return (x);                             \
 }
 
+/*
+ * Note: we do not have to check td->td_nest_count in these functions, only
+ * whether we are in a critical section or not.
+ */
 void
 spl0(void)
 {
index 48dd9a4..991e040 100644 (file)
@@ -35,7 +35,7 @@
  *
  *     from: @(#)genassym.c    5.11 (Berkeley) 5/10/91
  * $FreeBSD: src/sys/i386/i386/genassym.c,v 1.86.2.3 2002/03/03 05:42:49 nyan Exp $
- * $DragonFly: src/sys/platform/vkernel/i386/genassym.c,v 1.29 2003/09/16 20:03:35 dillon Exp $
+ * $DragonFly: src/sys/platform/vkernel/i386/genassym.c,v 1.30 2003/10/02 22:26:56 dillon Exp $
  */
 
 #include "opt_user_ldt.h"
@@ -86,6 +86,7 @@ ASSYM(TD_SP, offsetof(struct thread, td_sp));
 ASSYM(TD_PRI, offsetof(struct thread, td_pri));
 ASSYM(TD_MACH, offsetof(struct thread, td_mach));
 ASSYM(TD_WCHAN, offsetof(struct thread, td_wchan));
+ASSYM(TD_NEST_COUNT, offsetof(struct thread, td_nest_count));
 #ifdef SMP
 ASSYM(TD_MPCOUNT, offsetof(struct thread, td_mpcount));
 #endif
index 00eda3d..706181c 100644 (file)
@@ -24,7 +24,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/i386/include/globaldata.h,v 1.11.2.1 2000/05/16 06:58:10 dillon Exp $
- * $DragonFly: src/sys/sys/globaldata.h,v 1.16 2003/08/27 01:43:07 dillon Exp $
+ * $DragonFly: src/sys/sys/globaldata.h,v 1.17 2003/10/02 22:27:00 dillon Exp $
  */
 
 #ifndef _SYS_GLOBALDATA_H_
@@ -89,7 +89,7 @@ struct globaldata {
        u_int           gd_cpuid;
        u_int           gd_other_cpus;          /* mask of 'other' cpus */
        struct timeval  gd_stattv;
-       int             gd_intr_nesting_level;  /* (for fast interrupts) */
+       int             gd_intr_nesting_level;  /* (for interrupts) */
        int             gd_psticks;             /* profile kern/kern_clock.c */
        int             gd_psdiv;               /* profile kern/kern_clock.c */
        struct vmmeter  gd_cnt;
index 4508a4c..138e124 100644 (file)
@@ -25,7 +25,7 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- * $DragonFly: src/sys/sys/slaballoc.h,v 1.3 2003/08/28 17:24:36 dillon Exp $
+ * $DragonFly: src/sys/sys/slaballoc.h,v 1.4 2003/10/02 22:27:00 dillon Exp $
  */
 
 #ifndef _SYS_SLABALLOC_H_
@@ -45,6 +45,7 @@
 #define ZALLOC_MIN_ZONE_SIZE   (32 * 1024)     /* minimum zone size */
 #define ZALLOC_MAX_ZONE_SIZE   (128 * 1024)    /* maximum zone size */
 #define ZALLOC_SLAB_MAGIC      0x736c6162      /* magic sanity */
+#define ZALLOC_OVSZ_MAGIC      0x736c6163      /* magic sanity */
 #define ZALLOC_SLAB_SLIDE      20
 
 
@@ -87,6 +88,7 @@ typedef struct SLZone {
 typedef struct SLGlobalData {
     SLZone     *ZoneAry[NZONES];       /* linked list of zones NFree > 0 */
     SLZone     *FreeZones;             /* whole zones that have become free */
+    SLZone     *FreeOvZones;           /* oversized zones */
     int                NFreeZones;             /* free zone count */
     int                JunkIndex;
     struct malloc_type ZoneInfo;       /* stats on meta-zones allocated */
index d859cb3..03e50a7 100644 (file)
@@ -4,7 +4,7 @@
  *     Implements the architecture independant portion of the LWKT 
  *     subsystem.
  * 
- * $DragonFly: src/sys/sys/thread.h,v 1.32 2003/09/24 18:37:51 dillon Exp $
+ * $DragonFly: src/sys/sys/thread.h,v 1.33 2003/10/02 22:27:00 dillon Exp $
  */
 
 #ifndef _SYS_THREAD_H_
@@ -149,6 +149,7 @@ struct thread {
     u_int64_t  td_iticks;      /* Statclock hits processing intr (uS) */
     int                td_locks;       /* lockmgr lock debugging YYY */
     int                td_refs;        /* hold position in gd_tdallq / hold free */
+    int                td_nest_count;  /* prevent splz nesting */
 #ifdef SMP
     int                td_mpcount;     /* MP lock held (count) */
 #else