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/vm/uma.h

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
    3  *
    4  * Copyright (c) 2002, 2003, 2004, 2005 Jeffrey Roberson <jeff@FreeBSD.org>
    5  * Copyright (c) 2004, 2005 Bosko Milekic <bmilekic@FreeBSD.org>
    6  * All rights reserved.
    7  *
    8  * Redistribution and use in source and binary forms, with or without
    9  * modification, are permitted provided that the following conditions
   10  * are met:
   11  * 1. Redistributions of source code must retain the above copyright
   12  *    notice unmodified, this list of conditions, and the following
   13  *    disclaimer.
   14  * 2. Redistributions in binary form must reproduce the above copyright
   15  *    notice, this list of conditions and the following disclaimer in the
   16  *    documentation and/or other materials provided with the distribution.
   17  *
   18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   21  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   22  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   23  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   28  *
   29  * $FreeBSD$
   30  *
   31  */
   32 
   33 /*
   34  * uma.h - External definitions for the Universal Memory Allocator
   35  *
   36 */
   37 
   38 #ifndef _VM_UMA_H_
   39 #define _VM_UMA_H_
   40 
   41 #include <sys/param.h>          /* For NULL */
   42 #include <sys/malloc.h>         /* For M_* */
   43 #include <sys/_smr.h>
   44 
   45 /* User visible parameters */
   46 #define UMA_SMALLEST_UNIT       8 /* Smallest item allocated */
   47 
   48 /* Types and type defs */
   49 
   50 struct uma_zone;
   51 /* Opaque type used as a handle to the zone */
   52 typedef struct uma_zone * uma_zone_t;
   53 
   54 /*
   55  * Item constructor
   56  *
   57  * Arguments:
   58  *      item  A pointer to the memory which has been allocated.
   59  *      arg   The arg field passed to uma_zalloc_arg
   60  *      size  The size of the allocated item
   61  *      flags See zalloc flags
   62  *
   63  * Returns:
   64  *      0      on success
   65  *      errno  on failure
   66  *
   67  * Discussion:
   68  *      The constructor is called just before the memory is returned
   69  *      to the user. It may block if necessary.
   70  */
   71 typedef int (*uma_ctor)(void *mem, int size, void *arg, int flags);
   72 
   73 /*
   74  * Item destructor
   75  *
   76  * Arguments:
   77  *      item  A pointer to the memory which has been allocated.
   78  *      size  The size of the item being destructed.
   79  *      arg   Argument passed through uma_zfree_arg
   80  *
   81  * Returns:
   82  *      Nothing
   83  *
   84  * Discussion:
   85  *      The destructor may perform operations that differ from those performed
   86  *      by the initializer, but it must leave the object in the same state.
   87  *      This IS type stable storage.  This is called after EVERY zfree call.
   88  */
   89 typedef void (*uma_dtor)(void *mem, int size, void *arg);
   90 
   91 /*
   92  * Item initializer
   93  *
   94  * Arguments:
   95  *      item  A pointer to the memory which has been allocated.
   96  *      size  The size of the item being initialized.
   97  *      flags See zalloc flags
   98  *
   99  * Returns:
  100  *      0      on success
  101  *      errno  on failure
  102  *
  103  * Discussion:
  104  *      The initializer is called when the memory is cached in the uma zone.
  105  *      The initializer and the destructor should leave the object in the same
  106  *      state.
  107  */
  108 typedef int (*uma_init)(void *mem, int size, int flags);
  109 
  110 /*
  111  * Item discard function
  112  *
  113  * Arguments:
  114  *      item  A pointer to memory which has been 'freed' but has not left the
  115  *            zone's cache.
  116  *      size  The size of the item being discarded.
  117  *
  118  * Returns:
  119  *      Nothing
  120  *
  121  * Discussion:
  122  *      This routine is called when memory leaves a zone and is returned to the
  123  *      system for other uses.  It is the counter-part to the init function.
  124  */
  125 typedef void (*uma_fini)(void *mem, int size);
  126 
  127 /*
  128  * Import new memory into a cache zone.
  129  */
  130 typedef int (*uma_import)(void *arg, void **store, int count, int domain,
  131     int flags);
  132 
  133 /*
  134  * Free memory from a cache zone.
  135  */
  136 typedef void (*uma_release)(void *arg, void **store, int count);
  137 
  138 /*
  139  * What's the difference between initializing and constructing?
  140  *
  141  * The item is initialized when it is cached, and this is the state that the
  142  * object should be in when returned to the allocator. The purpose of this is
  143  * to remove some code which would otherwise be called on each allocation by
  144  * utilizing a known, stable state.  This differs from the constructor which
  145  * will be called on EVERY allocation.
  146  *
  147  * For example, in the initializer you may want to initialize embedded locks,
  148  * NULL list pointers, set up initial states, magic numbers, etc.  This way if
  149  * the object is held in the allocator and re-used it won't be necessary to
  150  * re-initialize it.
  151  *
  152  * The constructor may be used to lock a data structure, link it on to lists,
  153  * bump reference counts or total counts of outstanding structures, etc.
  154  *
  155  */
  156 
  157 /* Function proto types */
  158 
  159 /*
  160  * Create a new uma zone
  161  *
  162  * Arguments:
  163  *      name  The text name of the zone for debugging and stats. This memory
  164  *              should not be freed until the zone has been deallocated.
  165  *      size  The size of the object that is being created.
  166  *      ctor  The constructor that is called when the object is allocated.
  167  *      dtor  The destructor that is called when the object is freed.
  168  *      init  An initializer that sets up the initial state of the memory.
  169  *      fini  A discard function that undoes initialization done by init.
  170  *              ctor/dtor/init/fini may all be null, see notes above.
  171  *      align A bitmask that corresponds to the requested alignment
  172  *              eg 4 would be 0x3
  173  *      flags A set of parameters that control the behavior of the zone.
  174  *
  175  * Returns:
  176  *      A pointer to a structure which is intended to be opaque to users of
  177  *      the interface.  The value may be null if the wait flag is not set.
  178  */
  179 uma_zone_t uma_zcreate(const char *name, size_t size, uma_ctor ctor,
  180                     uma_dtor dtor, uma_init uminit, uma_fini fini,
  181                     int align, uint32_t flags);
  182 
  183 /*
  184  * Create a secondary uma zone
  185  *
  186  * Arguments:
  187  *      name  The text name of the zone for debugging and stats. This memory
  188  *              should not be freed until the zone has been deallocated.
  189  *      ctor  The constructor that is called when the object is allocated.
  190  *      dtor  The destructor that is called when the object is freed.
  191  *      zinit  An initializer that sets up the initial state of the memory
  192  *              as the object passes from the Keg's slab to the Zone's cache.
  193  *      zfini  A discard function that undoes initialization done by init
  194  *              as the object passes from the Zone's cache to the Keg's slab.
  195  *
  196  *              ctor/dtor/zinit/zfini may all be null, see notes above.
  197  *              Note that the zinit and zfini specified here are NOT
  198  *              exactly the same as the init/fini specified to uma_zcreate()
  199  *              when creating a primary zone.  These zinit/zfini are called
  200  *              on the TRANSITION from keg to zone (and vice-versa). Once
  201  *              these are set, the primary zone may alter its init/fini
  202  *              (which are called when the object passes from VM to keg)
  203  *              using uma_zone_set_init/fini()) as well as its own
  204  *              zinit/zfini (unset by default for primary zone) with
  205  *              uma_zone_set_zinit/zfini() (note subtle 'z' prefix).
  206  *
  207  *      primary A reference to this zone's Primary Zone which contains the
  208  *              backing Keg for the Secondary Zone being added.
  209  *
  210  * Returns:
  211  *      A pointer to a structure which is intended to be opaque to users of
  212  *      the interface.  The value may be null if the wait flag is not set.
  213  */
  214 uma_zone_t uma_zsecond_create(const char *name, uma_ctor ctor, uma_dtor dtor,
  215     uma_init zinit, uma_fini zfini, uma_zone_t primary);
  216 
  217 /*
  218  * Create cache-only zones.
  219  *
  220  * This allows uma's per-cpu cache facilities to handle arbitrary
  221  * pointers.  Consumers must specify the import and release functions to
  222  * fill and destroy caches.  UMA does not allocate any memory for these
  223  * zones.  The 'arg' parameter is passed to import/release and is caller
  224  * specific.
  225  */
  226 uma_zone_t uma_zcache_create(const char *name, int size, uma_ctor ctor,
  227     uma_dtor dtor, uma_init zinit, uma_fini zfini, uma_import zimport,
  228     uma_release zrelease, void *arg, int flags);
  229 
  230 /*
  231  * Definitions for uma_zcreate flags
  232  *
  233  * These flags share space with UMA_ZFLAGs in uma_int.h.  Be careful not to
  234  * overlap when adding new features.
  235  */
  236 #define UMA_ZONE_UNMANAGED      0x0001  /*
  237                                          * Don't regulate the cache size, even
  238                                          * under memory pressure.
  239                                          */
  240 #define UMA_ZONE_ZINIT          0x0002  /* Initialize with zeros */
  241 #define UMA_ZONE_CONTIG         0x0004  /*
  242                                          * Physical memory underlying an object
  243                                          * must be contiguous.
  244                                          */
  245 #define UMA_ZONE_NOTOUCH        0x0008  /* UMA may not access the memory */
  246 #define UMA_ZONE_MALLOC         0x0010  /* For use by malloc(9) only! */
  247 #define UMA_ZONE_NOFREE         0x0020  /* Do not free slabs of this type! */
  248 #define UMA_ZONE_MTXCLASS       0x0040  /* Create a new lock class */
  249 #define UMA_ZONE_VM             0x0080  /*
  250                                          * Used for internal vm datastructures
  251                                          * only.
  252                                          */
  253 #define UMA_ZONE_NOTPAGE        0x0100  /* allocf memory not vm pages */
  254 #define UMA_ZONE_SECONDARY      0x0200  /* Zone is a Secondary Zone */
  255 #define UMA_ZONE_NOBUCKET       0x0400  /* Do not use buckets. */
  256 #define UMA_ZONE_MAXBUCKET      0x0800  /* Use largest buckets. */
  257 #define UMA_ZONE_CACHESPREAD    0x2000  /*
  258                                          * Spread memory start locations across
  259                                          * all possible cache lines.  May
  260                                          * require many virtually contiguous
  261                                          * backend pages and can fail early.
  262                                          */
  263 #define UMA_ZONE_NODUMP         0x4000  /*
  264                                          * Zone's pages will not be included in
  265                                          * mini-dumps.
  266                                          */
  267 #define UMA_ZONE_PCPU           0x8000  /*
  268                                          * Allocates mp_maxid + 1 slabs of
  269                                          * PAGE_SIZE
  270                                          */
  271 #define UMA_ZONE_FIRSTTOUCH     0x10000 /* First touch NUMA policy */
  272 #define UMA_ZONE_ROUNDROBIN     0x20000 /* Round-robin NUMA policy. */
  273 #define UMA_ZONE_SMR            0x40000 /*
  274                                          * Safe memory reclamation defers
  275                                          * frees until all read sections
  276                                          * have exited.  This flag creates
  277                                          * a unique SMR context for this
  278                                          * zone.  To share contexts see
  279                                          * uma_zone_set_smr() below.
  280                                          *
  281                                          * See sys/smr.h for more details.
  282                                          */
  283 #define UMA_ZONE_NOKASAN        0x80000 /*
  284                                          * Disable KASAN verification.  This is
  285                                          * implied by NOFREE.  Cache zones are
  286                                          * not verified by default.
  287                                          */
  288 /* In use by UMA_ZFLAGs:        0xffe00000 */
  289 
  290 /*
  291  * These flags are shared between the keg and zone.  Some are determined
  292  * based on physical parameters of the request and may not be provided by
  293  * the consumer.
  294  */
  295 #define UMA_ZONE_INHERIT                                                \
  296     (UMA_ZONE_NOTOUCH | UMA_ZONE_MALLOC | UMA_ZONE_NOFREE |             \
  297      UMA_ZONE_VM | UMA_ZONE_NOTPAGE | UMA_ZONE_PCPU |                   \
  298      UMA_ZONE_FIRSTTOUCH | UMA_ZONE_ROUNDROBIN | UMA_ZONE_NOKASAN)
  299 
  300 /* Definitions for align */
  301 #define UMA_ALIGN_PTR   (sizeof(void *) - 1)    /* Alignment fit for ptr */
  302 #define UMA_ALIGN_LONG  (sizeof(long) - 1)      /* "" long */
  303 #define UMA_ALIGN_INT   (sizeof(int) - 1)       /* "" int */
  304 #define UMA_ALIGN_SHORT (sizeof(short) - 1)     /* "" short */
  305 #define UMA_ALIGN_CHAR  (sizeof(char) - 1)      /* "" char */
  306 #define UMA_ALIGN_CACHE (0 - 1)                 /* Cache line size align */
  307 #define UMA_ALIGNOF(type) (_Alignof(type) - 1)  /* Alignment fit for 'type' */
  308 
  309 #define UMA_ANYDOMAIN   -1      /* Special value for domain search. */
  310 
  311 /*
  312  * Destroys an empty uma zone.  If the zone is not empty uma complains loudly.
  313  *
  314  * Arguments:
  315  *      zone  The zone we want to destroy.
  316  *
  317  */
  318 void uma_zdestroy(uma_zone_t zone);
  319 
  320 /*
  321  * Allocates an item out of a zone
  322  *
  323  * Arguments:
  324  *      zone  The zone we are allocating from
  325  *      arg   This data is passed to the ctor function
  326  *      flags See sys/malloc.h for available flags.
  327  *
  328  * Returns:
  329  *      A non-null pointer to an initialized element from the zone is
  330  *      guaranteed if the wait flag is M_WAITOK.  Otherwise a null pointer
  331  *      may be returned if the zone is empty or the ctor failed.
  332  */
  333 
  334 void *uma_zalloc_arg(uma_zone_t zone, void *arg, int flags);
  335 
  336 /* Allocate per-cpu data.  Access the correct data with zpcpu_get(). */
  337 void *uma_zalloc_pcpu_arg(uma_zone_t zone, void *arg, int flags);
  338 
  339 /* Use with SMR zones. */
  340 void *uma_zalloc_smr(uma_zone_t zone, int flags);
  341 
  342 /*
  343  * Allocate an item from a specific NUMA domain.  This uses a slow path in
  344  * the allocator but is guaranteed to allocate memory from the requested
  345  * domain if M_WAITOK is set.
  346  *
  347  * Arguments:
  348  *      zone  The zone we are allocating from
  349  *      arg   This data is passed to the ctor function
  350  *      domain The domain to allocate from.
  351  *      flags See sys/malloc.h for available flags.
  352  */
  353 void *uma_zalloc_domain(uma_zone_t zone, void *arg, int domain, int flags);
  354 
  355 /*
  356  * Allocates an item out of a zone without supplying an argument
  357  *
  358  * This is just a wrapper for uma_zalloc_arg for convenience.
  359  *
  360  */
  361 static __inline void *uma_zalloc(uma_zone_t zone, int flags);
  362 static __inline void *uma_zalloc_pcpu(uma_zone_t zone, int flags);
  363 
  364 static __inline void *
  365 uma_zalloc(uma_zone_t zone, int flags)
  366 {
  367         return uma_zalloc_arg(zone, NULL, flags);
  368 }
  369 
  370 static __inline void *
  371 uma_zalloc_pcpu(uma_zone_t zone, int flags)
  372 {
  373         return uma_zalloc_pcpu_arg(zone, NULL, flags);
  374 }
  375 
  376 /*
  377  * Frees an item back into the specified zone.
  378  *
  379  * Arguments:
  380  *      zone  The zone the item was originally allocated out of.
  381  *      item  The memory to be freed.
  382  *      arg   Argument passed to the destructor
  383  *
  384  * Returns:
  385  *      Nothing.
  386  */
  387 
  388 void uma_zfree_arg(uma_zone_t zone, void *item, void *arg);
  389 
  390 /* Use with PCPU zones. */
  391 void uma_zfree_pcpu_arg(uma_zone_t zone, void *item, void *arg);
  392 
  393 /* Use with SMR zones. */
  394 void uma_zfree_smr(uma_zone_t zone, void *item);
  395 
  396 /*
  397  * Frees an item back to a zone without supplying an argument
  398  *
  399  * This is just a wrapper for uma_zfree_arg for convenience.
  400  *
  401  */
  402 static __inline void uma_zfree(uma_zone_t zone, void *item);
  403 static __inline void uma_zfree_pcpu(uma_zone_t zone, void *item);
  404 
  405 static __inline void
  406 uma_zfree(uma_zone_t zone, void *item)
  407 {
  408         uma_zfree_arg(zone, item, NULL);
  409 }
  410 
  411 static __inline void
  412 uma_zfree_pcpu(uma_zone_t zone, void *item)
  413 {
  414         uma_zfree_pcpu_arg(zone, item, NULL);
  415 }
  416 
  417 /*
  418  * Wait until the specified zone can allocate an item.
  419  */
  420 void uma_zwait(uma_zone_t zone);
  421 
  422 /*
  423  * Backend page supplier routines
  424  *
  425  * Arguments:
  426  *      zone  The zone that is requesting pages.
  427  *      size  The number of bytes being requested.
  428  *      pflag Flags for these memory pages, see below.
  429  *      domain The NUMA domain that we prefer for this allocation.
  430  *      wait  Indicates our willingness to block.
  431  *
  432  * Returns:
  433  *      A pointer to the allocated memory or NULL on failure.
  434  */
  435 
  436 typedef void *(*uma_alloc)(uma_zone_t zone, vm_size_t size, int domain,
  437     uint8_t *pflag, int wait);
  438 
  439 /*
  440  * Backend page free routines
  441  *
  442  * Arguments:
  443  *      item  A pointer to the previously allocated pages.
  444  *      size  The original size of the allocation.
  445  *      pflag The flags for the slab.  See UMA_SLAB_* below.
  446  *
  447  * Returns:
  448  *      None
  449  */
  450 typedef void (*uma_free)(void *item, vm_size_t size, uint8_t pflag);
  451 
  452 /*
  453  * Reclaims unused memory.  If no NUMA domain is specified, memory from all
  454  * domains is reclaimed.
  455  *
  456  * Arguments:
  457  *      req    Reclamation request type.
  458  *      domain The target NUMA domain.
  459  * Returns:
  460  *      None
  461  */
  462 #define UMA_RECLAIM_DRAIN       1       /* release bucket cache */
  463 #define UMA_RECLAIM_DRAIN_CPU   2       /* release bucket and per-CPU caches */
  464 #define UMA_RECLAIM_TRIM        3       /* trim bucket cache to WSS */
  465 void uma_reclaim(int req);
  466 void uma_reclaim_domain(int req, int domain);
  467 void uma_zone_reclaim(uma_zone_t, int req);
  468 void uma_zone_reclaim_domain(uma_zone_t, int req, int domain);
  469 
  470 /*
  471  * Sets the alignment mask to be used for all zones requesting cache
  472  * alignment.  Should be called by MD boot code prior to starting VM/UMA.
  473  *
  474  * Arguments:
  475  *      align The alignment mask
  476  *
  477  * Returns:
  478  *      Nothing
  479  */
  480 void uma_set_align(int align);
  481 
  482 /*
  483  * Set a reserved number of items to hold for M_USE_RESERVE allocations.  All
  484  * other requests must allocate new backing pages.
  485  */
  486 void uma_zone_reserve(uma_zone_t zone, int nitems);
  487 
  488 /*
  489  * Reserves the maximum KVA space required by the zone and configures the zone
  490  * to use a backend that allocates physical memory and maps it using the
  491  * reserved KVA. 
  492  *
  493  * Arguments:
  494  *      zone  The zone to update.
  495  *      nitems  The upper limit on the number of items that can be allocated.
  496  *
  497  * Returns:
  498  *      0  if KVA space can not be allocated
  499  *      1  if successful
  500  *
  501  * Discussion:
  502  *      When the machine supports a direct map and the zone's items are smaller
  503  *      than a page, the zone will use the direct map instead of allocating KVA
  504  *      space.
  505  */
  506 int uma_zone_reserve_kva(uma_zone_t zone, int nitems);
  507 
  508 /*
  509  * Sets an upper limit on the number of items allocated from a zone
  510  *
  511  * Arguments:
  512  *      zone  The zone to limit
  513  *      nitems  The requested upper limit on the number of items allowed
  514  *
  515  * Returns:
  516  *      int  The effective value of nitems
  517  */
  518 int uma_zone_set_max(uma_zone_t zone, int nitems);
  519 
  520 /*
  521  * Sets an upper limit on the number of items allowed in zone's caches
  522  *
  523  * Arguments:
  524  *      zone  The zone to limit
  525  *      nitems  The requested upper limit on the number of items allowed
  526  */
  527 void uma_zone_set_maxcache(uma_zone_t zone, int nitems);
  528 
  529 /*
  530  * Obtains the effective limit on the number of items in a zone
  531  *
  532  * Arguments:
  533  *      zone  The zone to obtain the effective limit from
  534  *
  535  * Return:
  536  *      0  No limit
  537  *      int  The effective limit of the zone
  538  */
  539 int uma_zone_get_max(uma_zone_t zone);
  540 
  541 /*
  542  * Sets a warning to be printed when limit is reached
  543  *
  544  * Arguments:
  545  *      zone  The zone we will warn about
  546  *      warning  Warning content
  547  *
  548  * Returns:
  549  *      Nothing
  550  */
  551 void uma_zone_set_warning(uma_zone_t zone, const char *warning);
  552 
  553 /*
  554  * Sets a function to run when limit is reached
  555  *
  556  * Arguments:
  557  *      zone  The zone to which this applies
  558  *      fx  The function ro run
  559  *
  560  * Returns:
  561  *      Nothing
  562  */
  563 typedef void (*uma_maxaction_t)(uma_zone_t, int);
  564 void uma_zone_set_maxaction(uma_zone_t zone, uma_maxaction_t);
  565 
  566 /*
  567  * Obtains the approximate current number of items allocated from a zone
  568  *
  569  * Arguments:
  570  *      zone  The zone to obtain the current allocation count from
  571  *
  572  * Return:
  573  *      int  The approximate current number of items allocated from the zone
  574  */
  575 int uma_zone_get_cur(uma_zone_t zone);
  576 
  577 /*
  578  * The following two routines (uma_zone_set_init/fini)
  579  * are used to set the backend init/fini pair which acts on an
  580  * object as it becomes allocated and is placed in a slab within
  581  * the specified zone's backing keg.  These should probably not
  582  * be changed once allocations have already begun, but only be set
  583  * immediately upon zone creation.
  584  */
  585 void uma_zone_set_init(uma_zone_t zone, uma_init uminit);
  586 void uma_zone_set_fini(uma_zone_t zone, uma_fini fini);
  587 
  588 /*
  589  * The following two routines (uma_zone_set_zinit/zfini) are
  590  * used to set the zinit/zfini pair which acts on an object as
  591  * it passes from the backing Keg's slab cache to the
  592  * specified Zone's bucket cache.  These should probably not
  593  * be changed once allocations have already begun, but only be set
  594  * immediately upon zone creation.
  595  */
  596 void uma_zone_set_zinit(uma_zone_t zone, uma_init zinit);
  597 void uma_zone_set_zfini(uma_zone_t zone, uma_fini zfini);
  598 
  599 /*
  600  * Replaces the standard backend allocator for this zone.
  601  *
  602  * Arguments:
  603  *      zone   The zone whose backend allocator is being changed.
  604  *      allocf A pointer to the allocation function
  605  *
  606  * Returns:
  607  *      Nothing
  608  *
  609  * Discussion:
  610  *      This could be used to implement pageable allocation, or perhaps
  611  *      even DMA allocators if used in conjunction with the OFFPAGE
  612  *      zone flag.
  613  */
  614 
  615 void uma_zone_set_allocf(uma_zone_t zone, uma_alloc allocf);
  616 
  617 /*
  618  * Used for freeing memory provided by the allocf above
  619  *
  620  * Arguments:
  621  *      zone  The zone that intends to use this free routine.
  622  *      freef The page freeing routine.
  623  *
  624  * Returns:
  625  *      Nothing
  626  */
  627 
  628 void uma_zone_set_freef(uma_zone_t zone, uma_free freef);
  629 
  630 /*
  631  * Associate a zone with a smr context that is allocated after creation
  632  * so that multiple zones may share the same context.
  633  */
  634 void uma_zone_set_smr(uma_zone_t zone, smr_t smr);
  635 
  636 /*
  637  * Fetch the smr context that was set or made in uma_zcreate().
  638  */
  639 smr_t uma_zone_get_smr(uma_zone_t zone);
  640 
  641 /*
  642  * These flags are setable in the allocf and visible in the freef.
  643  */
  644 #define UMA_SLAB_BOOT   0x01            /* Slab alloced from boot pages */
  645 #define UMA_SLAB_KERNEL 0x04            /* Slab alloced from kmem */
  646 #define UMA_SLAB_PRIV   0x08            /* Slab alloced from priv allocator */
  647 /* 0x02, 0x10, 0x40, and 0x80 are available */
  648 
  649 /*
  650  * Used to pre-fill a zone with some number of items
  651  *
  652  * Arguments:
  653  *      zone    The zone to fill
  654  *      itemcnt The number of items to reserve
  655  *
  656  * Returns:
  657  *      Nothing
  658  *
  659  * NOTE: This is blocking and should only be done at startup
  660  */
  661 void uma_prealloc(uma_zone_t zone, int itemcnt);
  662 
  663 /*
  664  * Used to determine if a fixed-size zone is exhausted.
  665  *
  666  * Arguments:
  667  *      zone    The zone to check
  668  *
  669  * Returns:
  670  *      Non-zero if zone is exhausted.
  671  */
  672 int uma_zone_exhausted(uma_zone_t zone);
  673 
  674 /*
  675  * Returns the bytes of memory consumed by the zone.
  676  */
  677 size_t uma_zone_memory(uma_zone_t zone);
  678 
  679 /*
  680  * Common UMA_ZONE_PCPU zones.
  681  */
  682 extern uma_zone_t pcpu_zone_4;
  683 extern uma_zone_t pcpu_zone_8;
  684 extern uma_zone_t pcpu_zone_16;
  685 extern uma_zone_t pcpu_zone_32;
  686 extern uma_zone_t pcpu_zone_64;
  687 
  688 /*
  689  * Exported statistics structures to be used by user space monitoring tools.
  690  * Statistics stream consists of a uma_stream_header, followed by a series of
  691  * alternative uma_type_header and uma_type_stat structures.
  692  */
  693 #define UMA_STREAM_VERSION      0x00000001
  694 struct uma_stream_header {
  695         uint32_t        ush_version;    /* Stream format version. */
  696         uint32_t        ush_maxcpus;    /* Value of MAXCPU for stream. */
  697         uint32_t        ush_count;      /* Number of records. */
  698         uint32_t        _ush_pad;       /* Pad/reserved field. */
  699 };
  700 
  701 #define UTH_MAX_NAME    32
  702 #define UTH_ZONE_SECONDARY      0x00000001
  703 struct uma_type_header {
  704         /*
  705          * Static per-zone data, some extracted from the supporting keg.
  706          */
  707         char            uth_name[UTH_MAX_NAME];
  708         uint32_t        uth_align;      /* Keg: alignment. */
  709         uint32_t        uth_size;       /* Keg: requested size of item. */
  710         uint32_t        uth_rsize;      /* Keg: real size of item. */
  711         uint32_t        uth_maxpages;   /* Keg: maximum number of pages. */
  712         uint32_t        uth_limit;      /* Keg: max items to allocate. */
  713 
  714         /*
  715          * Current dynamic zone/keg-derived statistics.
  716          */
  717         uint32_t        uth_pages;      /* Keg: pages allocated. */
  718         uint32_t        uth_keg_free;   /* Keg: items free. */
  719         uint32_t        uth_zone_free;  /* Zone: items free. */
  720         uint32_t        uth_bucketsize; /* Zone: desired bucket size. */
  721         uint32_t        uth_zone_flags; /* Zone: flags. */
  722         uint64_t        uth_allocs;     /* Zone: number of allocations. */
  723         uint64_t        uth_frees;      /* Zone: number of frees. */
  724         uint64_t        uth_fails;      /* Zone: number of alloc failures. */
  725         uint64_t        uth_sleeps;     /* Zone: number of alloc sleeps. */
  726         uint64_t        uth_xdomain;    /* Zone: Number of cross domain frees. */
  727         uint64_t        _uth_reserved1[1];      /* Reserved. */
  728 };
  729 
  730 struct uma_percpu_stat {
  731         uint64_t        ups_allocs;     /* Cache: number of allocations. */
  732         uint64_t        ups_frees;      /* Cache: number of frees. */
  733         uint64_t        ups_cache_free; /* Cache: free items in cache. */
  734         uint64_t        _ups_reserved[5];       /* Reserved. */
  735 };
  736 
  737 void uma_reclaim_wakeup(void);
  738 void uma_reclaim_worker(void *);
  739 
  740 unsigned long uma_limit(void);
  741 
  742 /* Return the amount of memory managed by UMA. */
  743 unsigned long uma_size(void);
  744 
  745 /* Return the amount of memory remaining.  May be negative. */
  746 long uma_avail(void);
  747 
  748 #endif  /* _VM_UMA_H_ */

Cache object: 0330a8271389546d0d191f15893eb2f6


[ 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.