The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/sys/malloc.h

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    1 /*      $NetBSD: malloc.h,v 1.89 2003/08/07 16:34:07 agc Exp $  */
    2 
    3 /*
    4  * Copyright (c) 1987, 1993
    5  *      The Regents of the University of California.  All rights reserved.
    6  *
    7  * Redistribution and use in source and binary forms, with or without
    8  * modification, are permitted provided that the following conditions
    9  * are met:
   10  * 1. Redistributions of source code must retain the above copyright
   11  *    notice, this list of conditions and the following disclaimer.
   12  * 2. Redistributions in binary form must reproduce the above copyright
   13  *    notice, this list of conditions and the following disclaimer in the
   14  *    documentation and/or other materials provided with the distribution.
   15  * 3. Neither the name of the University nor the names of its contributors
   16  *    may be used to endorse or promote products derived from this software
   17  *    without specific prior written permission.
   18  *
   19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   29  * SUCH DAMAGE.
   30  *
   31  *      @(#)malloc.h    8.5 (Berkeley) 5/3/95
   32  */
   33 
   34 #ifndef _SYS_MALLOC_H_
   35 #define _SYS_MALLOC_H_
   36 
   37 #if defined(_KERNEL_OPT)
   38 #include "opt_kmemstats.h"
   39 #include "opt_malloclog.h"
   40 #include "opt_malloc_debug.h"
   41 #include "opt_lockdebug.h"
   42 #endif
   43 
   44 
   45 /*
   46  * flags to malloc
   47  */
   48 #define M_WAITOK        0x0000  /* can wait for resources */
   49 #define M_NOWAIT        0x0001  /* do not wait for resources */
   50 #define M_ZERO          0x0002  /* zero the allocation */
   51 #define M_CANFAIL       0x0004  /* can fail if requested memory can't ever
   52                                  * be allocated */
   53 #ifdef _KERNEL
   54 
   55 #include <sys/lock.h>
   56 #include <sys/mallocvar.h>
   57 /*
   58  * The following are standard, built-in malloc types that are
   59  * not specific to any one subsystem.
   60  */
   61 MALLOC_DECLARE(M_DEVBUF);
   62 MALLOC_DECLARE(M_DMAMAP);
   63 MALLOC_DECLARE(M_FREE);
   64 MALLOC_DECLARE(M_PCB);
   65 MALLOC_DECLARE(M_SOFTINTR);
   66 MALLOC_DECLARE(M_TEMP);
   67 
   68 /* XXX These should all be declared elsewhere. */
   69 MALLOC_DECLARE(M_RTABLE);
   70 MALLOC_DECLARE(M_FTABLE);
   71 MALLOC_DECLARE(M_UFSMNT);
   72 MALLOC_DECLARE(M_NETADDR);
   73 MALLOC_DECLARE(M_IPMOPTS);
   74 MALLOC_DECLARE(M_IPMADDR);
   75 MALLOC_DECLARE(M_MRTABLE);
   76 MALLOC_DECLARE(M_1394DATA);
   77 #endif /* _KERNEL */
   78 
   79 /*
   80  * Array of descriptors that describe the contents of each page
   81  */
   82 struct kmemusage {
   83         short ku_indx;          /* bucket index */
   84         union {
   85                 u_short freecnt;/* for small allocations, free pieces in page */
   86                 u_short pagecnt;/* for large allocations, pages alloced */
   87         } ku_un;
   88 };
   89 #define ku_freecnt ku_un.freecnt
   90 #define ku_pagecnt ku_un.pagecnt
   91 
   92 /*
   93  * Set of buckets for each size of memory block that is retained
   94  */
   95 struct kmembuckets {
   96         caddr_t kb_next;        /* list of free blocks */
   97         caddr_t kb_last;        /* last free block */
   98         long    kb_calls;       /* total calls to allocate this size */
   99         long    kb_total;       /* total number of blocks allocated */
  100         long    kb_totalfree;   /* # of free elements in this bucket */
  101         long    kb_elmpercl;    /* # of elements in this sized allocation */
  102         long    kb_highwat;     /* high water mark */
  103         long    kb_couldfree;   /* over high water mark and could free */
  104 };
  105 
  106 #ifdef _KERNEL
  107 #define MINALLOCSIZE    (1 << MINBUCKET)
  108 #define BUCKETINDX(size) \
  109         ((size) <= (MINALLOCSIZE * 128) \
  110                 ? (size) <= (MINALLOCSIZE * 8) \
  111                         ? (size) <= (MINALLOCSIZE * 2) \
  112                                 ? (size) <= (MINALLOCSIZE * 1) \
  113                                         ? (MINBUCKET + 0) \
  114                                         : (MINBUCKET + 1) \
  115                                 : (size) <= (MINALLOCSIZE * 4) \
  116                                         ? (MINBUCKET + 2) \
  117                                         : (MINBUCKET + 3) \
  118                         : (size) <= (MINALLOCSIZE* 32) \
  119                                 ? (size) <= (MINALLOCSIZE * 16) \
  120                                         ? (MINBUCKET + 4) \
  121                                         : (MINBUCKET + 5) \
  122                                 : (size) <= (MINALLOCSIZE * 64) \
  123                                         ? (MINBUCKET + 6) \
  124                                         : (MINBUCKET + 7) \
  125                 : (size) <= (MINALLOCSIZE * 2048) \
  126                         ? (size) <= (MINALLOCSIZE * 512) \
  127                                 ? (size) <= (MINALLOCSIZE * 256) \
  128                                         ? (MINBUCKET + 8) \
  129                                         : (MINBUCKET + 9) \
  130                                 : (size) <= (MINALLOCSIZE * 1024) \
  131                                         ? (MINBUCKET + 10) \
  132                                         : (MINBUCKET + 11) \
  133                         : (size) <= (MINALLOCSIZE * 8192) \
  134                                 ? (size) <= (MINALLOCSIZE * 4096) \
  135                                         ? (MINBUCKET + 12) \
  136                                         : (MINBUCKET + 13) \
  137                                 : (size) <= (MINALLOCSIZE * 16384) \
  138                                         ? (MINBUCKET + 14) \
  139                                         : (MINBUCKET + 15))
  140 
  141 /*
  142  * Turn virtual addresses into kmem map indicies
  143  */
  144 #define kmemxtob(alloc) (kmembase + (alloc) * NBPG)
  145 #define btokmemx(addr)  (((caddr_t)(addr) - kmembase) / NBPG)
  146 #define btokup(addr)    (&kmemusage[((caddr_t)(addr) - kmembase) >> PGSHIFT])
  147 
  148 extern struct simplelock malloc_slock;
  149 
  150 /*
  151  * Macro versions for the usual cases of malloc/free
  152  */
  153 #if defined(KMEMSTATS) || defined(DIAGNOSTIC) || defined(_LKM) || \
  154     defined(MALLOCLOG) || defined(LOCKDEBUG) || defined(MALLOC_NOINLINE)
  155 #define MALLOC(space, cast, size, type, flags) \
  156         (space) = (cast)malloc((u_long)(size), (type), (flags))
  157 #define FREE(addr, type) free((caddr_t)(addr), (type))
  158 
  159 #else /* do not collect statistics */
  160 #define MALLOC(space, cast, size, type, flags)                          \
  161 do {                                                                    \
  162         register struct kmembuckets *__kbp = &bucket[BUCKETINDX((size))]; \
  163         long __s = splvm();                                             \
  164         simple_lock(&malloc_slock);                                     \
  165         if (__kbp->kb_next == NULL) {                                   \
  166                 simple_unlock(&malloc_slock);                           \
  167                 (space) = (cast)malloc((u_long)(size), (type), (flags)); \
  168                 splx(__s);                                              \
  169         } else {                                                        \
  170                 (space) = (cast)__kbp->kb_next;                         \
  171                 __kbp->kb_next = *(caddr_t *)(space);                   \
  172                 simple_unlock(&malloc_slock);                           \
  173                 splx(__s);                                              \
  174                 if ((flags) & M_ZERO)                                   \
  175                         memset((space), 0, (size));                     \
  176         }                                                               \
  177 } while (/* CONSTCOND */ 0)
  178 
  179 #define FREE(addr, type)                                                \
  180 do {                                                                    \
  181         register struct kmembuckets *__kbp;                             \
  182         register struct kmemusage *__kup = btokup((addr));              \
  183         long __s = splvm();                                             \
  184         if (1 << __kup->ku_indx > MAXALLOCSAVE) {                       \
  185                 free((caddr_t)(addr), (type));                          \
  186         } else {                                                        \
  187                 simple_lock(&malloc_slock);                             \
  188                 __kbp = &bucket[__kup->ku_indx];                        \
  189                 if (__kbp->kb_next == NULL)                             \
  190                         __kbp->kb_next = (caddr_t)(addr);               \
  191                 else                                                    \
  192                         *(caddr_t *)(__kbp->kb_last) = (caddr_t)(addr); \
  193                 *(caddr_t *)(addr) = NULL;                              \
  194                 __kbp->kb_last = (caddr_t)(addr);                       \
  195                 simple_unlock(&malloc_slock);                           \
  196         }                                                               \
  197         splx(__s);                                                      \
  198 } while(/* CONSTCOND */ 0)
  199 #endif /* do not collect statistics */
  200 
  201 extern struct kmemusage         *kmemusage;
  202 extern char                     *kmembase;
  203 extern struct kmembuckets       bucket[];
  204 
  205 #ifdef MALLOCLOG
  206 void    *_malloc(unsigned long, struct malloc_type *, int, const char *, long);
  207 void    _free(void *, struct malloc_type *, const char *, long);
  208 #define malloc(size, type, flags) \
  209             _malloc((size), (type), (flags), __FILE__, __LINE__)
  210 #define free(addr, type) \
  211             _free((addr), (type), __FILE__, __LINE__)
  212 #else
  213 void    *malloc(unsigned long, struct malloc_type *, int);
  214 void    free(void *, struct malloc_type *);
  215 #endif /* MALLOCLOG */
  216 
  217 #ifdef MALLOC_DEBUG
  218 int     debug_malloc(unsigned long, struct malloc_type *, int, void **);
  219 int     debug_free(void *, struct malloc_type *);
  220 void    debug_malloc_init(void);
  221 
  222 void    debug_malloc_print(void);
  223 void    debug_malloc_printit(void (*)(const char *, ...), vaddr_t);
  224 #endif /* MALLOC_DEBUG */
  225 
  226 void    *realloc(void *, unsigned long, struct malloc_type *, int);
  227 unsigned long
  228         malloc_roundup(unsigned long);
  229 #endif /* _KERNEL */
  230 #endif /* !_SYS_MALLOC_H_ */

Cache object: 7ca260b8cba9a8229210625701081fc6


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.