source: rtems-libbsd/freebsd/sys/vm/uma.h @ 94b5368

5-freebsd-12
Last change on this file since 94b5368 was 0237319, checked in by Sebastian Huber <sebastian.huber@…>, on May 23, 2017 at 11:18:31 AM

Update due to Newlib 2017-06-07 changes

The following files are now provided by Newlib:

  • arpa/inet.h
  • net/if.h
  • netinet/in.h
  • netinet/tcp.h
  • sys/socket.h
  • sys/uio.h
  • sys/un.h

The <sys/param.h> and <sys/cpuset.h> are now compatible enough to be
used directly.

Update #2833.

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