Entirely remove the old kernel malloc and kmem_map code. The slab allocator
authorMatthew Dillon <dillon@dragonflybsd.org>
Sun, 19 Oct 2003 00:23:30 +0000 (00:23 +0000)
committerMatthew Dillon <dillon@dragonflybsd.org>
Sun, 19 Oct 2003 00:23:30 +0000 (00:23 +0000)
is now mandatory.  Also remove the related conf options, USE_KMEM_MAP and
NO_SLAB_ALLOCATOR.

15 files changed:
sys/conf/files
sys/conf/options
sys/i386/i386/machdep.c
sys/i386/include/vmparam.h
sys/kern/kern_malloc.c [deleted file]
sys/kern/kern_slaballoc.c
sys/platform/pc32/i386/machdep.c
sys/platform/pc32/include/vmparam.h
sys/sys/malloc.h
sys/vm/vm_kern.c
sys/vm/vm_kern.h
sys/vm/vm_map.c
sys/vm/vm_mmap.c
sys/vm/vm_object.c
sys/vm/vm_zone.c

index 71e2413..367680a 100644 (file)
@@ -1,5 +1,5 @@
 # $FreeBSD: src/sys/conf/files,v 1.340.2.137 2003/06/04 17:10:30 sam Exp $
-# $DragonFly: src/sys/conf/files,v 1.18 2003/10/15 16:48:03 hmp Exp $
+# $DragonFly: src/sys/conf/files,v 1.19 2003/10/19 00:23:20 dillon Exp $
 #
 # The long compile-with and dependency lines are required because of
 # limitations in config: backslash-newline doesn't work in strings, and
@@ -759,7 +759,6 @@ kern/kern_kthread.c standard
 kern/kern_ktrace.c     standard
 kern/kern_lock.c       standard
 kern/kern_lockf.c      standard
-kern/kern_malloc.c     standard
 kern/kern_mib.c                standard
 kern/kern_ntptime.c    standard
 kern/kern_physio.c     standard
index 5f766b7..d95fe40 100644 (file)
@@ -1,5 +1,5 @@
 # $FreeBSD: src/sys/conf/options,v 1.191.2.53 2003/06/04 17:56:58 sam Exp $
-# $DragonFly: src/sys/conf/options,v 1.8 2003/09/26 19:23:29 dillon Exp $
+# $DragonFly: src/sys/conf/options,v 1.9 2003/10/19 00:23:20 dillon Exp $
 #
 #        On the handling of kernel options
 #
@@ -402,8 +402,6 @@ SIMPLELOCK_DEBUG    opt_global.h
 VFS_BIO_DEBUG          opt_global.h
 
 # These are VM related options
-USE_KMEM_MAP           opt_global.h
-NO_SLAB_ALLOCATOR      opt_vm.h
 VM_KMEM_SIZE           opt_vm.h
 VM_KMEM_SIZE_SCALE     opt_vm.h
 VM_KMEM_SIZE_MAX       opt_vm.h
index 71c4c69..906b345 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.37 2003/10/02 19:26:35 dillon Exp $
+ * $DragonFly: src/sys/i386/i386/Attic/machdep.c,v 1.38 2003/10/19 00:23:21 dillon Exp $
  */
 
 #include "use_apm.h"
@@ -413,13 +413,8 @@ again:
                mb_map_size = roundup2(mb_map_size, max(MCLBYTES, PAGE_SIZE));
                mclrefcnt = malloc(mb_map_size / MCLBYTES, M_MBUF, M_NOWAIT);
                bzero(mclrefcnt, mb_map_size / MCLBYTES);
-#if defined(USE_KMEM_MAP)
-               mb_map = kmem_suballoc(kmem_map, (vm_offset_t *)&mbutl,
-                           &maxaddr, mb_map_size);
-#else
                mb_map = kmem_suballoc(kernel_map, (vm_offset_t *)&mbutl,
                            &maxaddr, mb_map_size);
-#endif
                mb_map->system_map = 1;
        }
 
index 6a9bef5..0fadd42 100644 (file)
@@ -37,7 +37,7 @@
  *
  *     from: @(#)vmparam.h     5.9 (Berkeley) 5/12/91
  * $FreeBSD: src/sys/i386/include/vmparam.h,v 1.32.2.1 2000/04/02 08:47:01 peter Exp $
- * $DragonFly: src/sys/i386/include/Attic/vmparam.h,v 1.4 2003/09/26 19:23:35 dillon Exp $
+ * $DragonFly: src/sys/i386/include/Attic/vmparam.h,v 1.5 2003/10/19 00:23:23 dillon Exp $
  */
 
 
 #define VM_MAX_ADDRESS         VADDR(PTDPTDI, PTDPTDI)
 #define VM_MIN_ADDRESS         ((vm_offset_t)0)
 
-#if defined(USE_KMEM_MAP)
-/* virtual sizes (bytes) for various kernel submaps */
-#ifndef VM_KMEM_SIZE
-#define VM_KMEM_SIZE           (12 * 1024 * 1024)
-#endif
-
-/*
- * How many physical pages per KVA page allocated.
- * min(max(VM_KMEM_SIZE, Physical memory/VM_KMEM_SIZE_SCALE), VM_KMEM_SIZE_MAX)
- * is the total KVA space allocated for kmem_map.
- */
-#ifndef VM_KMEM_SIZE_SCALE
-#define        VM_KMEM_SIZE_SCALE      (3)
-#endif
-
-/*
- * Ceiling on amount of kmem_map kva space.
- */
-#ifndef VM_KMEM_SIZE_MAX
-#define        VM_KMEM_SIZE_MAX        (200 * 1024 * 1024)
-#endif
-
-#endif
-
 /* initial pagein size of beginning of executable file */
 #ifndef VM_INITIAL_PAGEIN
 #define        VM_INITIAL_PAGEIN       16
diff --git a/sys/kern/kern_malloc.c b/sys/kern/kern_malloc.c
deleted file mode 100644 (file)
index fc969e3..0000000
+++ /dev/null
@@ -1,674 +0,0 @@
-/*
- * Copyright (c) 1987, 1991, 1993
- *     The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *     This product includes software developed by the University of
- *     California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *     @(#)kern_malloc.c       8.3 (Berkeley) 1/4/94
- * $FreeBSD: src/sys/kern/kern_malloc.c,v 1.64.2.5 2002/03/16 02:19:51 archie Exp $
- * $DragonFly: src/sys/kern/Attic/kern_malloc.c,v 1.13 2003/09/26 19:23:31 dillon Exp $
- */
-
-#include "opt_vm.h"
-
-#if defined(NO_SLAB_ALLOCATOR)
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/kernel.h>
-#include <sys/malloc.h>
-#include <sys/mbuf.h>
-#include <sys/vmmeter.h>
-#include <sys/lock.h>
-#include <sys/thread.h>
-#include <sys/globaldata.h>
-
-#include <vm/vm.h>
-#include <vm/vm_param.h>
-#include <vm/vm_kern.h>
-#include <vm/vm_extern.h>
-#include <vm/pmap.h>
-#include <vm/vm_map.h>
-
-#if defined(INVARIANTS) && defined(__i386__)
-#include <machine/cpu.h>
-#endif
-
-/*
- * When realloc() is called, if the new size is sufficiently smaller than
- * the old size, realloc() will allocate a new, smaller block to avoid
- * wasting memory. 'Sufficiently smaller' is defined as: newsize <=
- * oldsize / 2^n, where REALLOC_FRACTION defines the value of 'n'.
- */
-#ifndef REALLOC_FRACTION
-#define        REALLOC_FRACTION        1       /* new block if <= half the size */
-#endif
-
-MALLOC_DEFINE(M_CACHE, "cache", "Various Dynamically allocated caches");
-MALLOC_DEFINE(M_DEVBUF, "devbuf", "device driver memory");
-MALLOC_DEFINE(M_TEMP, "temp", "misc temporary data buffers");
-
-MALLOC_DEFINE(M_IP6OPT, "ip6opt", "IPv6 options");
-MALLOC_DEFINE(M_IP6NDP, "ip6ndp", "IPv6 Neighbor Discovery");
-
-static void kmeminit (void *);
-SYSINIT(kmem, SI_SUB_KMEM, SI_ORDER_FIRST, kmeminit, NULL)
-
-static MALLOC_DEFINE(M_FREE, "free", "should be on free list");
-
-static struct malloc_type *kmemstatistics;
-static struct kmembuckets bucket[MINBUCKET + 16];
-static struct kmemusage *kmemusage;
-#if defined(USE_KMEM_MAP)
-static char *kmembase;
-static char *kmemlimit;
-#else
-static const char *kmembase = (char *)VM_MIN_KERNEL_ADDRESS;
-static const char *kmemlimit = (char *)VM_MAX_KERNEL_ADDRESS;
-#endif
-
-#if defined(USE_KMEM_MAP)
-u_int vm_kmem_size;
-#endif
-
-#ifdef INVARIANTS
-/*
- * This structure provides a set of masks to catch unaligned frees.
- */
-static long addrmask[] = { 0,
-       0x00000001, 0x00000003, 0x00000007, 0x0000000f,
-       0x0000001f, 0x0000003f, 0x0000007f, 0x000000ff,
-       0x000001ff, 0x000003ff, 0x000007ff, 0x00000fff,
-       0x00001fff, 0x00003fff, 0x00007fff, 0x0000ffff,
-};
-
-/*
- * The WEIRD_ADDR is used as known text to copy into free objects so
- * that modifications after frees can be detected.
- */
-#define WEIRD_ADDR     0xdeadc0de
-#define MAX_COPY       64
-
-/*
- * Normally the first word of the structure is used to hold the list
- * pointer for free objects. However, when running with diagnostics,
- * we use the third and fourth fields, so as to catch modifications
- * in the most commonly trashed first two words.
- */
-struct freelist {
-       long    spare0;
-       struct malloc_type *type;
-       long    spare1;
-       caddr_t next;
-};
-#else /* !INVARIANTS */
-struct freelist {
-       caddr_t next;
-};
-#endif /* INVARIANTS */
-
-/*
- *     malloc:
- *
- *     Allocate a block of memory.
- *
- *     If M_NOWAIT is set, this routine will not block and return NULL if
- *     the allocation fails.
- */
-void *
-malloc(size, type, flags)
-       unsigned long size;
-       struct malloc_type *type;
-       int flags;
-{
-       struct kmembuckets *kbp;
-       struct kmemusage *kup;
-       struct freelist *freep;
-       long indx, npg, allocsize;
-       int s;
-       caddr_t va, cp, savedlist;
-#ifdef INVARIANTS
-       long *end, *lp;
-       int copysize;
-       const char *savedtype;
-#endif
-       struct malloc_type *ksp = type;
-
-#if defined(INVARIANTS)
-       if (mycpu->gd_intr_nesting_level)
-               printf("WARNING: malloc() called from FASTint or ipiq, from %p\n", ((int **)&size)[-1]);
-       if (flags == M_WAITOK) {
-               KASSERT(mycpu->gd_intr_nesting_level == 0,
-                  ("malloc(M_WAITOK) in interrupt context"));
-       }
-#endif
-       /*
-        * Must be at splmem() prior to initializing segment to handle
-        * potential initialization race.
-        */
-
-       s = splmem();
-
-       if (type->ks_limit == 0)
-               malloc_init(type);
-
-       indx = BUCKETINDX(size);
-       kbp = &bucket[indx];
-
-       restart:
-       while (ksp->ks_memuse >= ksp->ks_limit) {
-               if (flags & M_NOWAIT) {
-                       splx(s);
-                       return ((void *) NULL);
-               }
-               if (ksp->ks_limblocks < 65535)
-                       ksp->ks_limblocks++;
-               tsleep((caddr_t)ksp, 0, type->ks_shortdesc, 0);
-       }
-       ksp->ks_size |= 1 << indx;
-#ifdef INVARIANTS
-       copysize = 1 << indx < MAX_COPY ? 1 << indx : MAX_COPY;
-#endif
-       if (kbp->kb_next == NULL) {
-               kbp->kb_last = NULL;
-               if (size > MAXALLOCSAVE)
-                       allocsize = roundup(size, PAGE_SIZE);
-               else
-                       allocsize = 1 << indx;
-               npg = btoc(allocsize);
-#if defined(USE_KMEM_MAP)
-               va = (caddr_t) kmem_malloc(kmem_map,
-                                   (vm_size_t)ctob(npg), flags);
-#else
-               va = (caddr_t) kmem_malloc(kernel_map,
-                                   (vm_size_t)ctob(npg), flags);
-#endif
-               if (va == NULL) {
-                       splx(s);
-                       return ((void *) NULL);
-               }
-               kbp->kb_total += kbp->kb_elmpercl;
-               kup = btokup(va);
-               kup->ku_indx = indx;
-               if (allocsize > MAXALLOCSAVE) {
-                       if (npg > 65535)
-                               panic("malloc: allocation too large");
-                       kup->ku_pagecnt = npg;
-                       ksp->ks_memuse += allocsize;
-                       goto out;
-               }
-               kup->ku_freecnt = kbp->kb_elmpercl;
-               kbp->kb_totalfree += kbp->kb_elmpercl;
-               /*
-                * Just in case we blocked while allocating memory,
-                * and someone else also allocated memory for this
-                * bucket, don't assume the list is still empty.
-                */
-               savedlist = kbp->kb_next;
-               kbp->kb_next = cp = va + (npg * PAGE_SIZE) - allocsize;
-               for (;;) {
-                       freep = (struct freelist *)cp;
-#ifdef INVARIANTS
-                       /*
-                        * Copy in known text to detect modification
-                        * after freeing.
-                        */
-                       end = (long *)&cp[copysize];
-                       for (lp = (long *)cp; lp < end; lp++)
-                               *lp = WEIRD_ADDR;
-                       freep->type = M_FREE;
-#endif /* INVARIANTS */
-                       if (cp <= va)
-                               break;
-                       cp -= allocsize;
-                       freep->next = cp;
-               }
-               freep->next = savedlist;
-               if (kbp->kb_last == NULL)
-                       kbp->kb_last = (caddr_t)freep;
-       }
-       va = kbp->kb_next;
-       if (va == NULL) {
-               if (flags & M_NOWAIT) {
-                       splx(s);
-                       return ((void *) NULL);
-               }
-               goto restart;
-       }
-       kbp->kb_next = ((struct freelist *)va)->next;
-#ifdef INVARIANTS
-       freep = (struct freelist *)va;
-       savedtype = (const char *) freep->type->ks_shortdesc;
-#if BYTE_ORDER == BIG_ENDIAN
-       freep->type = (struct malloc_type *)WEIRD_ADDR >> 16;
-#endif
-#if BYTE_ORDER == LITTLE_ENDIAN
-       freep->type = (struct malloc_type *)WEIRD_ADDR;
-#endif
-       if ((intptr_t)(void *)&freep->next & 0x2)
-               freep->next = (caddr_t)((WEIRD_ADDR >> 16)|(WEIRD_ADDR << 16));
-       else
-               freep->next = (caddr_t)WEIRD_ADDR;
-       end = (long *)&va[copysize];
-       for (lp = (long *)va; lp < end; lp++) {
-               if (*lp == WEIRD_ADDR)
-                       continue;
-               printf("%s %ld of object %p size %lu %s %s (0x%lx != 0x%lx)\n",
-                       "Data modified on freelist: word",
-                       (long)(lp - (long *)va), (void *)va, size,
-                       "previous type", savedtype, *lp, (u_long)WEIRD_ADDR);
-               break;
-       }
-       freep->spare0 = 0;
-#endif /* INVARIANTS */
-       kup = btokup(va);
-       if (kup->ku_indx != indx)
-               panic("malloc: wrong bucket");
-       if (kup->ku_freecnt == 0)
-               panic("malloc: lost data");
-       kup->ku_freecnt--;
-       kbp->kb_totalfree--;
-       ksp->ks_memuse += 1 << indx;
-out:
-       kbp->kb_calls++;
-       ksp->ks_inuse++;
-       ksp->ks_calls++;
-       if (ksp->ks_memuse > ksp->ks_maxused)
-               ksp->ks_maxused = ksp->ks_memuse;
-       splx(s);
-       /* XXX: Do idle pre-zeroing.  */
-       if (va != NULL && (flags & M_ZERO))
-               bzero(va, size);
-       return ((void *) va);
-}
-
-/*
- *     free:
- *
- *     Free a block of memory allocated by malloc.
- *
- *     This routine may not block.
- */
-void
-free(addr, type)
-       void *addr;
-       struct malloc_type *type;
-{
-       struct kmembuckets *kbp;
-       struct kmemusage *kup;
-       struct freelist *freep;
-       long size;
-       int s;
-#ifdef INVARIANTS
-       struct freelist *fp;
-       long *end, *lp, alloc, copysize;
-#endif
-       struct malloc_type *ksp = type;
-
-       if (type->ks_limit == 0)
-               panic("freeing with unknown type (%s)", type->ks_shortdesc);
-
-       /* free(NULL, ...) does nothing */
-       if (addr == NULL)
-               return;
-
-       KASSERT(kmembase <= (char *)addr && (char *)addr < kmemlimit,
-           ("free: address %p out of range", (void *)addr));
-       kup = btokup(addr);
-       size = 1 << kup->ku_indx;
-       kbp = &bucket[kup->ku_indx];
-       s = splmem();
-#ifdef INVARIANTS
-       /*
-        * Check for returns of data that do not point to the
-        * beginning of the allocation.
-        */
-       if (size > PAGE_SIZE)
-               alloc = addrmask[BUCKETINDX(PAGE_SIZE)];
-       else
-               alloc = addrmask[kup->ku_indx];
-       if (((uintptr_t)(void *)addr & alloc) != 0)
-               panic("free: unaligned addr %p, size %ld, type %s, mask %ld",
-                   (void *)addr, size, type->ks_shortdesc, alloc);
-#endif /* INVARIANTS */
-       if (size > MAXALLOCSAVE) {
-#if defined(USE_KMEM_MAP)
-               kmem_free(kmem_map, (vm_offset_t)addr, ctob(kup->ku_pagecnt));
-#else
-               kmem_free(kernel_map, (vm_offset_t)addr, ctob(kup->ku_pagecnt));
-#endif
-               size = kup->ku_pagecnt << PAGE_SHIFT;
-               ksp->ks_memuse -= size;
-               kup->ku_indx = 0;
-               kup->ku_pagecnt = 0;
-               if (ksp->ks_memuse + size >= ksp->ks_limit &&
-                   ksp->ks_memuse < ksp->ks_limit)
-                       wakeup((caddr_t)ksp);
-               ksp->ks_inuse--;
-               kbp->kb_total -= 1;
-               splx(s);
-               return;
-       }
-       freep = (struct freelist *)addr;
-#ifdef INVARIANTS
-       /*
-        * Check for multiple frees. Use a quick check to see if
-        * it looks free before laboriously searching the freelist.
-        */
-       if (freep->spare0 == WEIRD_ADDR) {
-               fp = (struct freelist *)kbp->kb_next;
-               while (fp) {
-                       if (fp->spare0 != WEIRD_ADDR)
-                               panic("free: free item %p modified", fp);
-                       else if (addr == (caddr_t)fp)
-                               panic("free: multiple freed item %p", addr);
-                       fp = (struct freelist *)fp->next;
-               }
-       }
-       /*
-        * Copy in known text to detect modification after freeing
-        * and to make it look free. Also, save the type being freed
-        * so we can list likely culprit if modification is detected
-        * when the object is reallocated.
-        */
-       copysize = size < MAX_COPY ? size : MAX_COPY;
-       end = (long *)&((caddr_t)addr)[copysize];
-       for (lp = (long *)addr; lp < end; lp++)
-               *lp = WEIRD_ADDR;
-       freep->type = type;
-#endif /* INVARIANTS */
-       kup->ku_freecnt++;
-       if (kup->ku_freecnt >= kbp->kb_elmpercl) {
-               if (kup->ku_freecnt > kbp->kb_elmpercl)
-                       panic("free: multiple frees");
-               else if (kbp->kb_totalfree > kbp->kb_highwat)
-                       kbp->kb_couldfree++;
-       }
-       kbp->kb_totalfree++;
-       ksp->ks_memuse -= size;
-       if (ksp->ks_memuse + size >= ksp->ks_limit &&
-           ksp->ks_memuse < ksp->ks_limit)
-               wakeup((caddr_t)ksp);
-       ksp->ks_inuse--;
-#ifdef OLD_MALLOC_MEMORY_POLICY
-       if (kbp->kb_next == NULL)
-               kbp->kb_next = addr;
-       else
-               ((struct freelist *)kbp->kb_last)->next = addr;
-       freep->next = NULL;
-       kbp->kb_last = addr;
-#else
-       /*
-        * Return memory to the head of the queue for quick reuse.  This
-        * can improve performance by improving the probability of the
-        * item being in the cache when it is reused.
-        */
-       if (kbp->kb_next == NULL) {
-               kbp->kb_next = addr;
-               kbp->kb_last = addr;
-               freep->next = NULL;
-       } else {
-               freep->next = kbp->kb_next;
-               kbp->kb_next = addr;
-       }
-#endif
-       splx(s);
-}
-
-/*
- *     realloc: change the size of a memory block
- */
-void *
-realloc(addr, size, type, flags)
-       void *addr;
-       unsigned long size;
-       struct malloc_type *type;
-       int flags;
-{
-       struct kmemusage *kup;
-       unsigned long alloc;
-       void *newaddr;
-
-       /* realloc(NULL, ...) is equivalent to malloc(...) */
-       if (addr == NULL)
-               return (malloc(size, type, flags));
-
-       /* Sanity check */
-       KASSERT(kmembase <= (char *)addr && (char *)addr < kmemlimit,
-           ("realloc: address %p out of range", (void *)addr));
-
-       /* Get the size of the original block */
-       kup = btokup(addr);
-       alloc = 1 << kup->ku_indx;
-       if (alloc > MAXALLOCSAVE)
-               alloc = kup->ku_pagecnt << PAGE_SHIFT;
-
-       /* Reuse the original block if appropriate */
-       if (size <= alloc
-           && (size > (alloc >> REALLOC_FRACTION) || alloc == MINALLOCSIZE))
-               return (addr);
-
-       /* Allocate a new, bigger (or smaller) block */
-       if ((newaddr = malloc(size, type, flags)) == NULL)
-               return (NULL);
-
-       /* Copy over original contents */
-       bcopy(addr, newaddr, min(size, alloc));
-       free(addr, type);
-       return (newaddr);
-}
-
-/*
- *     reallocf: same as realloc() but free memory on failure.
- */
-void *
-reallocf(addr, size, type, flags)
-       void *addr;
-       unsigned long size;
-       struct malloc_type *type;
-       int flags;
-{
-       void *mem;
-
-       if ((mem = realloc(addr, size, type, flags)) == NULL)
-               free(addr, type);
-       return (mem);
-}
-
-/*
- * Initialize the kernel memory allocator
- */
-/* ARGSUSED*/
-static void
-kmeminit(dummy)
-       void *dummy;
-{
-       long indx;
-       u_long npg;
-       u_long mem_size;
-
-#if    ((MAXALLOCSAVE & (MAXALLOCSAVE - 1)) != 0)
-#error "kmeminit: MAXALLOCSAVE not power of 2"
-#endif
-#if    (MAXALLOCSAVE > MINALLOCSIZE * 32768)
-#error "kmeminit: MAXALLOCSAVE too big"
-#endif
-#if    (MAXALLOCSAVE < PAGE_SIZE)
-#error "kmeminit: MAXALLOCSAVE too small"
-#endif
-
-       /*
-        * Try to auto-tune the kernel memory size, so that it is
-        * more applicable for a wider range of machine sizes.
-        * On an X86, a VM_KMEM_SIZE_SCALE value of 4 is good, while
-        * a VM_KMEM_SIZE of 12MB is a fair compromise.  The
-        * VM_KMEM_SIZE_MAX is dependent on the maximum KVA space
-        * available, and on an X86 with a total KVA space of 256MB,
-        * try to keep VM_KMEM_SIZE_MAX at 80MB or below.
-        *
-        * Note that the kmem_map is also used by the zone allocator,
-        * so make sure that there is enough space.
-        */
-       mem_size = vmstats.v_page_count * PAGE_SIZE;
-
-#if defined(USE_KMEM_MAP)
-       vm_kmem_size = VM_KMEM_SIZE;
-#if defined(VM_KMEM_SIZE_SCALE)
-       if ((mem_size / VM_KMEM_SIZE_SCALE) > vm_kmem_size)
-               vm_kmem_size = mem_size / VM_KMEM_SIZE_SCALE;
-#endif
-
-#if defined(VM_KMEM_SIZE_MAX)
-       if (vm_kmem_size >= VM_KMEM_SIZE_MAX)
-               vm_kmem_size = VM_KMEM_SIZE_MAX;
-#endif
-
-       /* Allow final override from the kernel environment */
-       TUNABLE_INT_FETCH("kern.vm.kmem.size", &vm_kmem_size);
-
-       /*
-        * Limit kmem virtual size to twice the physical memory.
-        * This allows for kmem map sparseness, but limits the size
-        * to something sane. Be careful to not overflow the 32bit
-        * ints while doing the check.
-        */
-       if ((vm_kmem_size / 2) > (vmstats.v_page_count * PAGE_SIZE))
-               vm_kmem_size = 2 * vmstats.v_page_count * PAGE_SIZE;
-
-       npg = (nmbufs * MSIZE + nmbclusters * MCLBYTES + vm_kmem_size)
-               / PAGE_SIZE;
-
-       kmemusage = (struct kmemusage *) kmem_alloc(kernel_map,
-               (vm_size_t)(npg * sizeof(struct kmemusage)));
-       kmem_map = kmem_suballoc(kernel_map, (vm_offset_t *)&kmembase,
-               (vm_offset_t *)&kmemlimit, (vm_size_t)(npg * PAGE_SIZE));
-       kmem_map->system_map = 1;
-#else
-       npg = (VM_MAX_KERNEL_ADDRESS - VM_MIN_KERNEL_ADDRESS) / PAGE_SIZE;
-       kmemusage = (struct kmemusage *) kmem_alloc(kernel_map,
-               (vm_size_t)(npg * sizeof(struct kmemusage)));
-#endif
-       for (indx = 0; indx < MINBUCKET + 16; indx++) {
-               if (1 << indx >= PAGE_SIZE)
-                       bucket[indx].kb_elmpercl = 1;
-               else
-                       bucket[indx].kb_elmpercl = PAGE_SIZE / (1 << indx);
-               bucket[indx].kb_highwat = 5 * bucket[indx].kb_elmpercl;
-       }
-}
-
-void
-malloc_init(data)
-       void *data;
-{
-       struct malloc_type *type = (struct malloc_type *)data;
-#if !defined(USE_KMEM_MAP)
-       vm_poff_t limsize;
-#endif
-
-       if (type->ks_magic != M_MAGIC)
-               panic("malloc type lacks magic");
-
-       if (type->ks_limit != 0)
-               return;
-
-       if (vmstats.v_page_count == 0)
-               panic("malloc_init not allowed before vm init");
-
-       /*
-        * The default limits for each malloc region is 1/10 of available
-        * memory or 1/10 of our KVA space, whichever is lower.
-        */
-#if defined(USE_KMEM_MAP)
-       type->ks_limit = vm_kmem_size / 2;
-#else
-       limsize = (vm_poff_t)vmstats.v_page_count * PAGE_SIZE;
-       if (limsize > VM_MAX_KERNEL_ADDRESS - VM_MIN_KERNEL_ADDRESS)
-               limsize = VM_MAX_KERNEL_ADDRESS - VM_MIN_KERNEL_ADDRESS;
-       type->ks_limit = limsize / 10;
-#endif
-       type->ks_next = kmemstatistics; 
-       kmemstatistics = type;
-}
-
-void
-malloc_uninit(data)
-       void *data;
-{
-       struct malloc_type *type = (struct malloc_type *)data;
-       struct malloc_type *t;
-#ifdef INVARIANTS
-       struct kmembuckets *kbp;
-       struct freelist *freep;
-       long indx;
-       int s;
-#endif
-
-       if (type->ks_magic != M_MAGIC)
-               panic("malloc type lacks magic");
-
-       if (vmstats.v_page_count == 0)
-               panic("malloc_uninit not allowed before vm init");
-
-       if (type->ks_limit == 0)
-               panic("malloc_uninit on uninitialized type");
-
-#ifdef INVARIANTS
-       s = splmem();
-       for (indx = 0; indx < MINBUCKET + 16; indx++) {
-               kbp = bucket + indx;
-               freep = (struct freelist*)kbp->kb_next;
-               while (freep) {
-                       if (freep->type == type)
-                               freep->type = M_FREE;
-                       freep = (struct freelist*)freep->next;
-               }
-       }
-       splx(s);
-
-       if (type->ks_memuse != 0)
-               printf("malloc_uninit: %ld bytes of '%s' still allocated\n",
-                   type->ks_memuse, type->ks_shortdesc);
-#endif
-
-       if (type == kmemstatistics)
-               kmemstatistics = type->ks_next;
-       else {
-               for (t = kmemstatistics; t->ks_next != NULL; t = t->ks_next) {
-                       if (t->ks_next == type) {
-                               t->ks_next = type->ks_next;
-                               break;
-                       }
-               }
-       }
-       type->ks_next = NULL;
-       type->ks_limit = 0;
-}
-
-#endif
index 68bb7f7..d12f313 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.10 2003/10/18 23:59:58 dillon Exp $
+ * $DragonFly: src/sys/kern/kern_slaballoc.c,v 1.11 2003/10/19 00:23:24 dillon Exp $
  *
  * This module implements a slab allocator drop-in replacement for the
  * kernel malloc().
 
 #include "opt_vm.h"
 
-#if !defined(NO_SLAB_ALLOCATOR)
-
-#if defined(USE_KMEM_MAP)
-#error "If you define USE_KMEM_MAP you must also define NO_SLAB_ALLOCATOR"
-#endif
-
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
@@ -925,4 +919,3 @@ kmem_slab_free(void *ptr, vm_size_t size)
     crit_exit();
 }
 
-#endif
index 512a264..17efab2 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.37 2003/10/02 19:26:35 dillon Exp $
+ * $DragonFly: src/sys/platform/pc32/i386/machdep.c,v 1.38 2003/10/19 00:23:21 dillon Exp $
  */
 
 #include "use_apm.h"
@@ -413,13 +413,8 @@ again:
                mb_map_size = roundup2(mb_map_size, max(MCLBYTES, PAGE_SIZE));
                mclrefcnt = malloc(mb_map_size / MCLBYTES, M_MBUF, M_NOWAIT);
                bzero(mclrefcnt, mb_map_size / MCLBYTES);
-#if defined(USE_KMEM_MAP)
-               mb_map = kmem_suballoc(kmem_map, (vm_offset_t *)&mbutl,
-                           &maxaddr, mb_map_size);
-#else
                mb_map = kmem_suballoc(kernel_map, (vm_offset_t *)&mbutl,
                            &maxaddr, mb_map_size);
-#endif
                mb_map->system_map = 1;
        }
 
index e8c6665..b5ff14c 100644 (file)
@@ -37,7 +37,7 @@
  *
  *     from: @(#)vmparam.h     5.9 (Berkeley) 5/12/91
  * $FreeBSD: src/sys/i386/include/vmparam.h,v 1.32.2.1 2000/04/02 08:47:01 peter Exp $
- * $DragonFly: src/sys/platform/pc32/include/vmparam.h,v 1.4 2003/09/26 19:23:35 dillon Exp $
+ * $DragonFly: src/sys/platform/pc32/include/vmparam.h,v 1.5 2003/10/19 00:23:23 dillon Exp $
  */
 
 
 #define VM_MAX_ADDRESS         VADDR(PTDPTDI, PTDPTDI)
 #define VM_MIN_ADDRESS         ((vm_offset_t)0)
 
-#if defined(USE_KMEM_MAP)
-/* virtual sizes (bytes) for various kernel submaps */
-#ifndef VM_KMEM_SIZE
-#define VM_KMEM_SIZE           (12 * 1024 * 1024)
-#endif
-
-/*
- * How many physical pages per KVA page allocated.
- * min(max(VM_KMEM_SIZE, Physical memory/VM_KMEM_SIZE_SCALE), VM_KMEM_SIZE_MAX)
- * is the total KVA space allocated for kmem_map.
- */
-#ifndef VM_KMEM_SIZE_SCALE
-#define        VM_KMEM_SIZE_SCALE      (3)
-#endif
-
-/*
- * Ceiling on amount of kmem_map kva space.
- */
-#ifndef VM_KMEM_SIZE_MAX
-#define        VM_KMEM_SIZE_MAX        (200 * 1024 * 1024)
-#endif
-
-#endif
-
 /* initial pagein size of beginning of executable file */
 #ifndef VM_INITIAL_PAGEIN
 #define        VM_INITIAL_PAGEIN       16
index 3b2bbd5..970ef00 100644 (file)
@@ -32,7 +32,7 @@
  *
  *     @(#)malloc.h    8.5 (Berkeley) 5/3/95
  * $FreeBSD: src/sys/sys/malloc.h,v 1.48.2.2 2002/03/16 02:19:16 archie Exp $
- * $DragonFly: src/sys/sys/malloc.h,v 1.10 2003/10/18 20:07:32 dillon Exp $
+ * $DragonFly: src/sys/sys/malloc.h,v 1.11 2003/10/19 00:23:28 dillon Exp $
  */
 
 #ifndef _SYS_MALLOC_H_
@@ -117,11 +117,7 @@ MALLOC_DECLARE(M_IP6NDP); /* for INET6 */
  * Array of descriptors that describe the contents of each page
  */
 struct kmemusage {
-#ifdef NO_SLAB_ALLOCATOR
-       short ku_indx;          /* bucket index */
-#else
        short ku_cpu;           /* cpu index */
-#endif
        union {
                u_short freecnt;/* for small allocations, free pieces in page */
                u_short pagecnt;/* for large allocations, pages alloced */
@@ -185,13 +181,7 @@ struct kmembuckets {
 /*
  * Turn virtual addresses into kmem map indices
  */
-#if defined(USE_KMEM_MAP)
-#define kmemxtob(alloc)        (kmembase + (alloc) * PAGE_SIZE)
-#define btokmemx(addr) (((caddr_t)(addr) - kmembase) / PAGE_SIZE)
-#define btokup(addr)   (&kmemusage[((caddr_t)(addr) - kmembase) >> PAGE_SHIFT])
-#else
 #define btokup(addr)   (&kmemusage[((caddr_t)(addr) - (caddr_t)VM_MIN_KERNEL_ADDRESS) >> PAGE_SHIFT])
-#endif
 
 /*
  * Deprecated macro versions of not-quite-malloc() and free().
index 1f7dedc..a2e64fd 100644 (file)
@@ -62,7 +62,7 @@
  * rights to redistribute these changes.
  *
  * $FreeBSD: src/sys/vm/vm_kern.c,v 1.61.2.2 2002/03/12 18:25:26 tegge Exp $
- * $DragonFly: src/sys/vm/vm_kern.c,v 1.10 2003/10/02 21:00:20 hmp Exp $
+ * $DragonFly: src/sys/vm/vm_kern.c,v 1.11 2003/10/19 00:23:30 dillon Exp $
  */
 
 /*
@@ -85,9 +85,6 @@
 #include <vm/vm_extern.h>
 
 vm_map_t kernel_map=0;
-#if defined(USE_KMEM_MAP)
-vm_map_t kmem_map=0;
-#endif
 vm_map_t exec_map=0;
 vm_map_t clean_map=0;
 vm_map_t buffer_map=0;
@@ -309,13 +306,8 @@ kmem_malloc(vm_map_t map, vm_size_t size, int flags)
        vm_page_t m;
        int count;
 
-#if defined(USE_KMEM_MAP)
-       if (map != kmem_map && map != mb_map)
-               panic("kmem_malloc: map != {kmem,mb}_map");
-#else
        if (map != kernel_map && map != mb_map)
                panic("kmem_malloc: map != {kmem,mb}_map");
-#endif
 
        size = round_page(size);
        addr = vm_map_min(map);
@@ -335,13 +327,8 @@ kmem_malloc(vm_map_t map, vm_size_t size, int flags)
                        printf("Out of mbuf clusters - adjust NMBCLUSTERS or increase maxusers!\n");
                        return (0);
                }
-#if defined(USE_KMEM_MAP)
-               if ((flags & M_NOWAIT) == 0)
-                       panic("kmem_malloc(%ld): kmem_map too small: %ld total allocated",
-#else
                if ((flags & M_NOWAIT) == 0)
                        panic("kmem_malloc(%ld): kernel_map too small: %ld total allocated",
-#endif
                                (long)size, (long)map->size);
                return (0);
        }
index 6ace1c8..548351e 100644 (file)
@@ -62,7 +62,7 @@
  * rights to redistribute these changes.
  *
  * $FreeBSD: src/sys/vm/vm_kern.h,v 1.22 2000/02/16 21:11:31 dillon Exp $
- * $DragonFly: src/sys/vm/vm_kern.h,v 1.5 2003/10/15 16:48:04 hmp Exp $
+ * $DragonFly: src/sys/vm/vm_kern.h,v 1.6 2003/10/19 00:23:30 dillon Exp $
  */
 
 #ifndef _VM_VM_KERN_H_
@@ -71,9 +71,6 @@
 /* Kernel memory management definitions. */
 extern vm_map_t buffer_map;
 extern vm_map_t kernel_map;
-#if defined(USE_KMEM_MAP)
-extern vm_map_t kmem_map;
-#endif
 extern vm_map_t mb_map;
 extern int mb_map_full;
 extern vm_map_t clean_map;
index 7c567f2..d64aeb1 100644 (file)
@@ -62,7 +62,7 @@
  * rights to redistribute these changes.
  *
  * $FreeBSD: src/sys/vm/vm_map.c,v 1.187.2.19 2003/05/27 00:47:02 alc Exp $
- * $DragonFly: src/sys/vm/vm_map.c,v 1.13 2003/10/02 21:00:20 hmp Exp $
+ * $DragonFly: src/sys/vm/vm_map.c,v 1.14 2003/10/19 00:23:30 dillon Exp $
  */
 
 /*
@@ -876,27 +876,15 @@ vm_map_find(vm_map_t map, vm_object_t object, vm_ooffset_t offset,
        vm_offset_t start;
        int result;
        int count;
-#if defined(USE_KMEM_MAP)
-       int s = 0;
-#endif
 
        start = *addr;
 
-#if defined(USE_KMEM_MAP)
-       if (map == kmem_map || map == mb_map)
-               s = splvm();
-#endif
-
        count = vm_map_entry_reserve(MAP_RESERVE_COUNT);
        vm_map_lock(map);
        if (find_space) {
                if (vm_map_findspace(map, start, length, 1, addr)) {
                        vm_map_unlock(map);
                        vm_map_entry_release(count);
-#if defined(USE_KMEM_MAP)
-                       if (map == kmem_map || map == mb_map)
-                               splx(s);
-#endif
                        return (KERN_NO_SPACE);
                }
                start = *addr;
@@ -906,11 +894,6 @@ vm_map_find(vm_map_t map, vm_object_t object, vm_ooffset_t offset,
        vm_map_unlock(map);
        vm_map_entry_release(count);
 
-#if defined(USE_KMEM_MAP)
-       if (map == kmem_map || map == mb_map)
-               splx(s);
-#endif
-
        return (result);
 }
 
@@ -1866,10 +1849,6 @@ vm_map_wire(vm_map_t map, vm_offset_t start,
 
        if (map == kernel_map)
                count = vm_map_entry_kreserve(MAP_RESERVE_COUNT);
-#if defined(USE_KMEM_MAP)
-       else if (map == kmem_map)
-               count = vm_map_entry_kreserve(MAP_RESERVE_COUNT);
-#endif
        else
                count = vm_map_entry_reserve(MAP_RESERVE_COUNT);
        vm_map_lock(map);
@@ -2062,10 +2041,6 @@ done:
 failure:
        if (map == kernel_map)
                vm_map_entry_krelease(count);
-#if defined(USE_KMEM_MAP)
-       else if (map == kmem_map)
-               vm_map_entry_krelease(count);
-#endif
        else
                vm_map_entry_release(count);
        return (rv);
@@ -2385,14 +2360,7 @@ vm_map_remove(vm_map_t map, vm_offset_t start, vm_offset_t end)
 {
        int result;
        int count;
-#if defined(USE_KMEM_MAP)
-       int s = 0;
-#endif
 
-#if defined(USE_KMEM_MAP)
-       if (map == kmem_map || map == mb_map)
-               s = splvm();
-#endif
        count = vm_map_entry_reserve(MAP_RESERVE_COUNT);
        vm_map_lock(map);
        VM_MAP_RANGE_CHECK(map, start, end);
@@ -2400,11 +2368,6 @@ vm_map_remove(vm_map_t map, vm_offset_t start, vm_offset_t end)
        vm_map_unlock(map);
        vm_map_entry_release(count);
 
-#if defined(USE_KMEM_MAP)
-       if (map == kmem_map || map == mb_map)
-               splx(s);
-#endif
-
        return (result);
 }
 
index f09cdd4..297bb5f 100644 (file)
@@ -39,7 +39,7 @@
  *
  *     @(#)vm_mmap.c   8.4 (Berkeley) 1/12/94
  * $FreeBSD: src/sys/vm/vm_mmap.c,v 1.108.2.6 2002/07/02 20:06:19 dillon Exp $
- * $DragonFly: src/sys/vm/vm_mmap.c,v 1.14 2003/10/02 21:00:20 hmp Exp $
+ * $DragonFly: src/sys/vm/vm_mmap.c,v 1.15 2003/10/19 00:23:30 dillon Exp $
  */
 
 /*
@@ -99,14 +99,9 @@ static void
 vmmapentry_rsrc_init(dummy)
         void *dummy;
 {
-#if defined(USE_KMEM_MAP)
-    max_proc_mmap = vm_kmem_size / sizeof(struct vm_map_entry);
-    max_proc_mmap /= 100;
-#else
     max_proc_mmap = (VM_MAX_KERNEL_ADDRESS - VM_MIN_KERNEL_ADDRESS) /
                        sizeof(struct vm_map_entry);
     max_proc_mmap /= 100;
-#endif
 }
 
 /* ARGSUSED */
index b0bf5a6..b9c15f8 100644 (file)
@@ -62,7 +62,7 @@
  * rights to redistribute these changes.
  *
  * $FreeBSD: src/sys/vm/vm_object.c,v 1.171.2.8 2003/05/26 19:17:56 alc Exp $
- * $DragonFly: src/sys/vm/vm_object.c,v 1.9 2003/09/26 19:23:34 dillon Exp $
+ * $DragonFly: src/sys/vm/vm_object.c,v 1.10 2003/10/19 00:23:30 dillon Exp $
  */
 
 /*
@@ -1785,10 +1785,6 @@ vm_object_in_map( object)
        }
        if( _vm_object_in_map( kernel_map, object, 0))
                return 1;
-#if defined(USE_KMEM_MAP)
-       if( _vm_object_in_map( kmem_map, object, 0))
-               return 1;
-#endif
        if( _vm_object_in_map( pager_map, object, 0))
                return 1;
        if( _vm_object_in_map( buffer_map, object, 0))
index 85c1e58..3f585e3 100644 (file)
@@ -12,7 +12,7 @@
  *     John S. Dyson.
  *
  * $FreeBSD: src/sys/vm/vm_zone.c,v 1.30.2.6 2002/10/10 19:50:16 dillon Exp $
- * $DragonFly: src/sys/vm/vm_zone.c,v 1.10 2003/09/26 19:23:34 dillon Exp $
+ * $DragonFly: src/sys/vm/vm_zone.c,v 1.11 2003/10/19 00:23:30 dillon Exp $
  */
 
 #include <sys/param.h>
@@ -329,31 +329,6 @@ zget(vm_zone_t z)
        } else {
                nbytes = z->zalloc * PAGE_SIZE;
 
-#if defined(USE_KMEM_MAP)
-               /*
-                * Check to see if the kernel map is already locked. 
-                * We could allow for recursive locks, but that eliminates
-                * a valuable debugging mechanism, and opens up the kernel
-                * map for potential corruption by inconsistent data structure
-                * manipulation.  We could also use the interrupt allocation
-                * mechanism, but that has size limitations.   Luckily, we
-                * have kmem_map that is a submap of kernel map available
-                * for memory allocation, and manipulation of that map doesn't
-                * affect the kernel map structures themselves.
-                *
-                * We can wait, so just do normal map allocation in the
-                * appropriate map.
-                */
-               if (lockstatus(&kernel_map->lock, NULL)) {
-                       int s;
-                       s = splvm();
-                       item = (void *) kmem_malloc(kmem_map, nbytes, M_WAITOK);
-                       lwkt_regettoken(&z->zlock);
-                       if (item != NULL)
-                               zone_kmem_pages += z->zalloc;
-                       splx(s);
-               } else
-#endif
                {
                        item = (void *) kmem_alloc(kernel_map, nbytes);
                        lwkt_regettoken(&z->zlock);