FreeBSD/Linux Kernel Cross Reference
sys/kern/subr_unit.c

     /*-
      * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
      *
      * Copyright (c) 2004 Poul-Henning Kamp
      * 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.
     *
     * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
     *
     * $FreeBSD$
     *
     *
     * Unit number allocation functions.
     *
     * These functions implement a mixed run-length/bitmap management of unit
     * number spaces in a very memory efficient manner.
     *
     * Allocation policy is always lowest free number first.
     *
     * A return value of -1 signals that no more unit numbers are available.
     *
     * There is no cost associated with the range of unitnumbers, so unless
     * the resource really is finite, specify INT_MAX to new_unrhdr() and
     * forget about checking the return value.
     *
     * If a mutex is not provided when the unit number space is created, a
     * default global mutex is used.  The advantage to passing a mutex in, is
     * that the alloc_unrl() function can be called with the mutex already
     * held (it will not be released by alloc_unrl()).
     *
     * The allocation function alloc_unr{l}() never sleeps (but it may block on
     * the mutex of course).
     *
     * Freeing a unit number may require allocating memory, and can therefore
     * sleep so the free_unr() function does not come in a pre-locked variant.
     *
     * A userland test program is included.
     *
     * Memory usage is a very complex function of the exact allocation
     * pattern, but always very compact:
     *    * For the very typical case where a single unbroken run of unit
     *      numbers are allocated 44 bytes are used on i386.
     *    * For a unit number space of 1000 units and the random pattern
     *      in the usermode test program included, the worst case usage
     *      was 252 bytes on i386 for 500 allocated and 500 free units.
     *    * For a unit number space of 10000 units and the random pattern
     *      in the usermode test program included, the worst case usage
     *      was 798 bytes on i386 for 5000 allocated and 5000 free units.
     *    * The worst case is where every other unit number is allocated and
     *      the rest are free.  In that case 44 + N/4 bytes are used where
     *      N is the number of the highest unit allocated.
     */
    
    #include <sys/param.h>
    #include <sys/types.h>
    #include <sys/_unrhdr.h>
    
    #ifdef _KERNEL
    
    #include <sys/bitstring.h>
    #include <sys/malloc.h>
    #include <sys/kernel.h>
    #include <sys/systm.h>
    #include <sys/limits.h>
    #include <sys/lock.h>
    #include <sys/mutex.h>
    
    /*
     * In theory it would be smarter to allocate the individual blocks
     * with the zone allocator, but at this time the expectation is that
     * there will typically not even be enough allocations to fill a single
     * page, so we stick with malloc for now.
     */
    static MALLOC_DEFINE(M_UNIT, "Unitno", "Unit number allocation");
    
    #define Malloc(foo) malloc(foo, M_UNIT, M_WAITOK | M_ZERO)
    #define Free(foo) free(foo, M_UNIT)
    
    static struct mtx unitmtx;
    
    MTX_SYSINIT(unit, &unitmtx, "unit# allocation", MTX_DEF);
   
   #ifdef UNR64_LOCKED
   uint64_t
   alloc_unr64(struct unrhdr64 *unr64)
   {
           uint64_t item;
   
           mtx_lock(&unitmtx);
           item = unr64->counter++;
           mtx_unlock(&unitmtx);
           return (item);
   }
   #endif
   
   #else /* ...USERLAND */
   
   #include <bitstring.h>
   #include <err.h>
   #include <errno.h>
   #include <getopt.h>
   #include <stdbool.h>
   #include <stdio.h>
   #include <stdlib.h>
   #include <string.h>
   
   #define KASSERT(cond, arg) \
           do { \
                   if (!(cond)) { \
                           printf arg; \
                           abort(); \
                   } \
           } while (0)
   
   static int no_alloc;
   #define Malloc(foo) _Malloc(foo, __LINE__)
   static void *
   _Malloc(size_t foo, int line)
   {
   
           KASSERT(no_alloc == 0, ("malloc in wrong place() line %d", line));
           return (calloc(foo, 1));
   }
   #define Free(foo) free(foo)
   
   struct unrhdr;
   
   struct mtx {
           int     state;
   } unitmtx;
   
   static void
   mtx_lock(struct mtx *mp)
   {
           KASSERT(mp->state == 0, ("mutex already locked"));
           mp->state = 1;
   }
   
   static void
   mtx_unlock(struct mtx *mp)
   {
           KASSERT(mp->state == 1, ("mutex not locked"));
           mp->state = 0;
   }
   
   #define MA_OWNED        9
   
   static void
   mtx_assert(struct mtx *mp, int flag)
   {
           if (flag == MA_OWNED) {
                   KASSERT(mp->state == 1, ("mtx_assert(MA_OWNED) not true"));
           }
   }
   
   #define CTASSERT(foo)
   #define WITNESS_WARN(flags, lock, fmt, ...)     (void)0
   
   #endif /* USERLAND */
   
   /*
    * This is our basic building block.
    *
    * It can be used in three different ways depending on the value of the ptr
    * element:
    *     If ptr is NULL, it represents a run of free items.
    *     If ptr points to the unrhdr it represents a run of allocated items.
    *     Otherwise it points to a bitstring of allocated items.
    *
    * For runs the len field is the length of the run.
    * For bitmaps the len field represents the number of allocated items.
    *
    * The bitmap is the same size as struct unr to optimize memory management.
    */
   struct unr {
           TAILQ_ENTRY(unr)        list;
           u_int                   len;
           void                    *ptr;
   };
   
   struct unrb {
           bitstr_t                map[sizeof(struct unr) / sizeof(bitstr_t)];
   };
   
   CTASSERT((sizeof(struct unr) % sizeof(bitstr_t)) == 0);
   
   /* Number of bits we can store in the bitmap */
   #define NBITS (8 * sizeof(((struct unrb*)NULL)->map))
   
   /* Is the unrb empty in at least the first len bits? */
   static inline bool
   ub_empty(struct unrb *ub, int len) {
           int first_set;
   
           bit_ffs(ub->map, len, &first_set);
           return (first_set == -1);
   }
   
   /* Is the unrb full?  That is, is the number of set elements equal to len? */
   static inline bool
   ub_full(struct unrb *ub, int len)
   {
           int first_clear;
   
           bit_ffc(ub->map, len, &first_clear);
           return (first_clear == -1);
   }
   
   #if defined(DIAGNOSTIC) || !defined(_KERNEL)
   /*
    * Consistency check function.
    *
    * Checks the internal consistency as well as we can.
    *
    * Called at all boundaries of this API.
    */
   static void
   check_unrhdr(struct unrhdr *uh, int line)
   {
           struct unr *up;
           struct unrb *ub;
           int w;
           u_int y, z;
   
           y = uh->first;
           z = 0;
           TAILQ_FOREACH(up, &uh->head, list) {
                   z++;
                   if (up->ptr != uh && up->ptr != NULL) {
                           ub = up->ptr;
                           KASSERT (up->len <= NBITS,
                               ("UNR inconsistency: len %u max %zd (line %d)\n",
                               up->len, NBITS, line));
                           z++;
                           w = 0;
                           bit_count(ub->map, 0, up->len, &w);
                           y += w;
                   } else if (up->ptr != NULL)
                           y += up->len;
           }
           KASSERT (y == uh->busy,
               ("UNR inconsistency: items %u found %u (line %d)\n",
               uh->busy, y, line));
           KASSERT (z == uh->alloc,
               ("UNR inconsistency: chunks %u found %u (line %d)\n",
               uh->alloc, z, line));
   }
   
   #else
   
   static __inline void
   check_unrhdr(struct unrhdr *uh __unused, int line __unused)
   {
   
   }
   
   #endif
   
   /*
    * Userland memory management.  Just use calloc and keep track of how
    * many elements we have allocated for check_unrhdr().
    */
   
   static __inline void *
   new_unr(struct unrhdr *uh, void **p1, void **p2)
   {
           void *p;
   
           uh->alloc++;
           KASSERT(*p1 != NULL || *p2 != NULL, ("Out of cached memory"));
           if (*p1 != NULL) {
                   p = *p1;
                   *p1 = NULL;
                   return (p);
           } else {
                   p = *p2;
                   *p2 = NULL;
                   return (p);
           }
   }
   
   static __inline void
   delete_unr(struct unrhdr *uh, void *ptr)
   {
           struct unr *up;
   
           uh->alloc--;
           up = ptr;
           TAILQ_INSERT_TAIL(&uh->ppfree, up, list);
   }
   
   void
   clean_unrhdrl(struct unrhdr *uh)
   {
           struct unr *up;
   
           mtx_assert(uh->mtx, MA_OWNED);
           while ((up = TAILQ_FIRST(&uh->ppfree)) != NULL) {
                   TAILQ_REMOVE(&uh->ppfree, up, list);
                   mtx_unlock(uh->mtx);
                   Free(up);
                   mtx_lock(uh->mtx);
           }
   
   }
   
   void
   clean_unrhdr(struct unrhdr *uh)
   {
   
           mtx_lock(uh->mtx);
           clean_unrhdrl(uh);
           mtx_unlock(uh->mtx);
   }
   
   void
   init_unrhdr(struct unrhdr *uh, int low, int high, struct mtx *mutex)
   {
   
           KASSERT(low >= 0 && low <= high,
               ("UNR: use error: new_unrhdr(%d, %d)", low, high));
           if (mutex != NULL)
                   uh->mtx = mutex;
           else
                   uh->mtx = &unitmtx;
           TAILQ_INIT(&uh->head);
           TAILQ_INIT(&uh->ppfree);
           uh->low = low;
           uh->high = high;
           uh->first = 0;
           uh->last = 1 + (high - low);
           check_unrhdr(uh, __LINE__);
   }
   
   /*
    * Allocate a new unrheader set.
    *
    * Highest and lowest valid values given as parameters.
    */
   
   struct unrhdr *
   new_unrhdr(int low, int high, struct mtx *mutex)
   {
           struct unrhdr *uh;
   
           uh = Malloc(sizeof *uh);
           init_unrhdr(uh, low, high, mutex);
           return (uh);
   }
   
   void
   delete_unrhdr(struct unrhdr *uh)
   {
   
           check_unrhdr(uh, __LINE__);
           KASSERT(uh->busy == 0, ("unrhdr has %u allocations", uh->busy));
           KASSERT(uh->alloc == 0, ("UNR memory leak in delete_unrhdr"));
           KASSERT(TAILQ_FIRST(&uh->ppfree) == NULL,
               ("unrhdr has postponed item for free"));
           Free(uh);
   }
   
   void
   clear_unrhdr(struct unrhdr *uh)
   {
           struct unr *up, *uq;
   
           KASSERT(TAILQ_EMPTY(&uh->ppfree),
               ("unrhdr has postponed item for free"));
           TAILQ_FOREACH_SAFE(up, &uh->head, list, uq) {
                   if (up->ptr != uh) {
                           Free(up->ptr);
                   }
                   Free(up);
           }
           uh->busy = 0;
           uh->alloc = 0;
           init_unrhdr(uh, uh->low, uh->high, uh->mtx);
   
           check_unrhdr(uh, __LINE__);
   }
   
   static __inline int
   is_bitmap(struct unrhdr *uh, struct unr *up)
   {
           return (up->ptr != uh && up->ptr != NULL);
   }
   
   /*
    * Look for sequence of items which can be combined into a bitmap, if
    * multiple are present, take the one which saves most memory.
    *
    * Return (1) if a sequence was found to indicate that another call
    * might be able to do more.  Return (0) if we found no suitable sequence.
    *
    * NB: called from alloc_unr(), no new memory allocation allowed.
    */
   static int
   optimize_unr(struct unrhdr *uh)
   {
           struct unr *up, *uf, *us;
           struct unrb *ub, *ubf;
           u_int a, l, ba;
   
           /*
            * Look for the run of items (if any) which when collapsed into
            * a bitmap would save most memory.
            */
           us = NULL;
           ba = 0;
           TAILQ_FOREACH(uf, &uh->head, list) {
                   if (uf->len >= NBITS)
                           continue;
                   a = 1;
                   if (is_bitmap(uh, uf))
                           a++;
                   l = uf->len;
                   up = uf;
                   while (1) {
                           up = TAILQ_NEXT(up, list);
                           if (up == NULL)
                                   break;
                           if ((up->len + l) > NBITS)
                                   break;
                           a++;
                           if (is_bitmap(uh, up))
                                   a++;
                           l += up->len;
                   }
                   if (a > ba) {
                           ba = a;
                           us = uf;
                   }
           }
           if (ba < 3)
                   return (0);
   
           /*
            * If the first element is not a bitmap, make it one.
            * Trying to do so without allocating more memory complicates things
            * a bit
            */
           if (!is_bitmap(uh, us)) {
                   uf = TAILQ_NEXT(us, list);
                   TAILQ_REMOVE(&uh->head, us, list);
                   a = us->len;
                   l = us->ptr == uh ? 1 : 0;
                   ub = (void *)us;
                   bit_nclear(ub->map, 0, NBITS - 1);
                   if (l)
                           bit_nset(ub->map, 0, a);
                   if (!is_bitmap(uh, uf)) {
                           if (uf->ptr == NULL)
                                   bit_nclear(ub->map, a, a + uf->len - 1);
                           else
                                   bit_nset(ub->map, a, a + uf->len - 1);
                           uf->ptr = ub;
                           uf->len += a;
                           us = uf;
                   } else {
                           ubf = uf->ptr;
                           for (l = 0; l < uf->len; l++, a++) {
                                   if (bit_test(ubf->map, l))
                                           bit_set(ub->map, a);
                                   else
                                           bit_clear(ub->map, a);
                           }
                           uf->len = a;
                           delete_unr(uh, uf->ptr);
                           uf->ptr = ub;
                           us = uf;
                   }
           }
           ub = us->ptr;
           while (1) {
                   uf = TAILQ_NEXT(us, list);
                   if (uf == NULL)
                           return (1);
                   if (uf->len + us->len > NBITS)
                           return (1);
                   if (uf->ptr == NULL) {
                           bit_nclear(ub->map, us->len, us->len + uf->len - 1);
                           us->len += uf->len;
                           TAILQ_REMOVE(&uh->head, uf, list);
                           delete_unr(uh, uf);
                   } else if (uf->ptr == uh) {
                           bit_nset(ub->map, us->len, us->len + uf->len - 1);
                           us->len += uf->len;
                           TAILQ_REMOVE(&uh->head, uf, list);
                           delete_unr(uh, uf);
                   } else {
                           ubf = uf->ptr;
                           for (l = 0; l < uf->len; l++, us->len++) {
                                   if (bit_test(ubf->map, l))
                                           bit_set(ub->map, us->len);
                                   else
                                           bit_clear(ub->map, us->len);
                           }
                           TAILQ_REMOVE(&uh->head, uf, list);
                           delete_unr(uh, ubf);
                           delete_unr(uh, uf);
                   }
           }
   }
   
   /*
    * See if a given unr should be collapsed with a neighbor.
    *
    * NB: called from alloc_unr(), no new memory allocation allowed.
    */
   static void
   collapse_unr(struct unrhdr *uh, struct unr *up)
   {
           struct unr *upp;
           struct unrb *ub;
   
           /* If bitmap is all set or clear, change it to runlength */
           if (is_bitmap(uh, up)) {
                   ub = up->ptr;
                   if (ub_full(ub, up->len)) {
                           delete_unr(uh, up->ptr);
                           up->ptr = uh;
                   } else if (ub_empty(ub, up->len)) {
                           delete_unr(uh, up->ptr);
                           up->ptr = NULL;
                   }
           }
   
           /* If nothing left in runlength, delete it */
           if (up->len == 0) {
                   upp = TAILQ_PREV(up, unrhd, list);
                   if (upp == NULL)
                           upp = TAILQ_NEXT(up, list);
                   TAILQ_REMOVE(&uh->head, up, list);
                   delete_unr(uh, up);
                   up = upp;
           }
   
           /* If we have "hot-spot" still, merge with neighbor if possible */
           if (up != NULL) {
                   upp = TAILQ_PREV(up, unrhd, list);
                   if (upp != NULL && up->ptr == upp->ptr) {
                           up->len += upp->len;
                           TAILQ_REMOVE(&uh->head, upp, list);
                           delete_unr(uh, upp);
                           }
                   upp = TAILQ_NEXT(up, list);
                   if (upp != NULL && up->ptr == upp->ptr) {
                           up->len += upp->len;
                           TAILQ_REMOVE(&uh->head, upp, list);
                           delete_unr(uh, upp);
                   }
           }
   
           /* Merge into ->first if possible */
           upp = TAILQ_FIRST(&uh->head);
           if (upp != NULL && upp->ptr == uh) {
                   uh->first += upp->len;
                   TAILQ_REMOVE(&uh->head, upp, list);
                   delete_unr(uh, upp);
                   if (up == upp)
                           up = NULL;
           }
   
           /* Merge into ->last if possible */
           upp = TAILQ_LAST(&uh->head, unrhd);
           if (upp != NULL && upp->ptr == NULL) {
                   uh->last += upp->len;
                   TAILQ_REMOVE(&uh->head, upp, list);
                   delete_unr(uh, upp);
                   if (up == upp)
                           up = NULL;
           }
   
           /* Try to make bitmaps */
           while (optimize_unr(uh))
                   continue;
   }
   
   /*
    * Allocate a free unr.
    */
   int
   alloc_unrl(struct unrhdr *uh)
   {
           struct unr *up;
           struct unrb *ub;
           u_int x;
           int y;
   
           mtx_assert(uh->mtx, MA_OWNED);
           check_unrhdr(uh, __LINE__);
           x = uh->low + uh->first;
   
           up = TAILQ_FIRST(&uh->head);
   
           /*
            * If we have an ideal split, just adjust the first+last
            */
           if (up == NULL && uh->last > 0) {
                   uh->first++;
                   uh->last--;
                   uh->busy++;
                   return (x);
           }
   
           /*
            * We can always allocate from the first list element, so if we have
            * nothing on the list, we must have run out of unit numbers.
            */
           if (up == NULL)
                   return (-1);
   
           KASSERT(up->ptr != uh, ("UNR first element is allocated"));
   
           if (up->ptr == NULL) {  /* free run */
                   uh->first++;
                   up->len--;
           } else {                /* bitmap */
                   ub = up->ptr;
                   bit_ffc(ub->map, up->len, &y);
                   KASSERT(y != -1, ("UNR corruption: No clear bit in bitmap."));
                   bit_set(ub->map, y);
                   x += y;
           }
           uh->busy++;
           collapse_unr(uh, up);
           return (x);
   }
   
   int
   alloc_unr(struct unrhdr *uh)
   {
           int i;
   
           mtx_lock(uh->mtx);
           i = alloc_unrl(uh);
           clean_unrhdrl(uh);
           mtx_unlock(uh->mtx);
           return (i);
   }
   
   static int
   alloc_unr_specificl(struct unrhdr *uh, u_int item, void **p1, void **p2)
   {
           struct unr *up, *upn;
           struct unrb *ub;
           u_int i, last, tl;
   
           mtx_assert(uh->mtx, MA_OWNED);
   
           if (item < uh->low + uh->first || item > uh->high)
                   return (-1);
   
           up = TAILQ_FIRST(&uh->head);
           /* Ideal split. */
           if (up == NULL && item - uh->low == uh->first) {
                   uh->first++;
                   uh->last--;
                   uh->busy++;
                   check_unrhdr(uh, __LINE__);
                   return (item);
           }
   
           i = item - uh->low - uh->first;
   
           if (up == NULL) {
                   up = new_unr(uh, p1, p2);
                   up->ptr = NULL;
                   up->len = i;
                   TAILQ_INSERT_TAIL(&uh->head, up, list);
                   up = new_unr(uh, p1, p2);
                   up->ptr = uh;
                   up->len = 1;
                   TAILQ_INSERT_TAIL(&uh->head, up, list);
                   uh->last = uh->high - uh->low - i;
                   uh->busy++;
                   check_unrhdr(uh, __LINE__);
                   return (item);
           } else {
                   /* Find the item which contains the unit we want to allocate. */
                   TAILQ_FOREACH(up, &uh->head, list) {
                           if (up->len > i)
                                   break;
                           i -= up->len;
                   }
           }
   
           if (up == NULL) {
                   if (i > 0) {
                           up = new_unr(uh, p1, p2);
                           up->ptr = NULL;
                           up->len = i;
                           TAILQ_INSERT_TAIL(&uh->head, up, list);
                   }
                   up = new_unr(uh, p1, p2);
                   up->ptr = uh;
                   up->len = 1;
                   TAILQ_INSERT_TAIL(&uh->head, up, list);
                   goto done;
           }
   
           if (is_bitmap(uh, up)) {
                   ub = up->ptr;
                   if (bit_test(ub->map, i) == 0) {
                           bit_set(ub->map, i);
                           goto done;
                   } else
                           return (-1);
           } else if (up->ptr == uh)
                   return (-1);
   
           KASSERT(up->ptr == NULL,
               ("alloc_unr_specificl: up->ptr != NULL (up=%p)", up));
   
           /* Split off the tail end, if any. */
           tl = up->len - (1 + i);
           if (tl > 0) {
                   upn = new_unr(uh, p1, p2);
                   upn->ptr = NULL;
                   upn->len = tl;
                   TAILQ_INSERT_AFTER(&uh->head, up, upn, list);
           }
   
           /* Split off head end, if any */
           if (i > 0) {
                   upn = new_unr(uh, p1, p2);
                   upn->len = i;
                   upn->ptr = NULL;
                   TAILQ_INSERT_BEFORE(up, upn, list);
           }
           up->len = 1;
           up->ptr = uh;
   
   done:
           last = uh->high - uh->low - (item - uh->low);
           if (uh->last > last)
                   uh->last = last;
           uh->busy++;
           collapse_unr(uh, up);
           check_unrhdr(uh, __LINE__);
           return (item);
   }
   
   int
   alloc_unr_specific(struct unrhdr *uh, u_int item)
   {
           void *p1, *p2;
           int i;
   
           WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL, "alloc_unr_specific");
   
           p1 = Malloc(sizeof(struct unr));
           p2 = Malloc(sizeof(struct unr));
   
           mtx_lock(uh->mtx);
           i = alloc_unr_specificl(uh, item, &p1, &p2);
           mtx_unlock(uh->mtx);
   
           if (p1 != NULL)
                   Free(p1);
           if (p2 != NULL)
                   Free(p2);
   
           return (i);
   }
   
   /*
    * Free a unr.
    *
    * If we can save unrs by using a bitmap, do so.
    */
   static void
   free_unrl(struct unrhdr *uh, u_int item, void **p1, void **p2)
   {
           struct unr *up, *upp, *upn;
           struct unrb *ub;
           u_int pl;
   
           KASSERT(item >= uh->low && item <= uh->high,
               ("UNR: free_unr(%u) out of range [%u...%u]",
                item, uh->low, uh->high));
           check_unrhdr(uh, __LINE__);
           item -= uh->low;
           upp = TAILQ_FIRST(&uh->head);
           /*
            * Freeing in the ideal split case
            */
           if (item + 1 == uh->first && upp == NULL) {
                   uh->last++;
                   uh->first--;
                   uh->busy--;
                   check_unrhdr(uh, __LINE__);
                   return;
           }
           /*
            * Freeing in the ->first section.  Create a run starting at the
            * freed item.  The code below will subdivide it.
            */
           if (item < uh->first) {
                   up = new_unr(uh, p1, p2);
                   up->ptr = uh;
                   up->len = uh->first - item;
                   TAILQ_INSERT_HEAD(&uh->head, up, list);
                   uh->first -= up->len;
           }
   
           item -= uh->first;
   
           /* Find the item which contains the unit we want to free */
           TAILQ_FOREACH(up, &uh->head, list) {
                   if (up->len > item)
                           break;
                   item -= up->len;
           }
   
           /* Handle bitmap items */
           if (is_bitmap(uh, up)) {
                   ub = up->ptr;
   
                   KASSERT(bit_test(ub->map, item) != 0,
                       ("UNR: Freeing free item %d (bitmap)\n", item));
                   bit_clear(ub->map, item);
                   uh->busy--;
                   collapse_unr(uh, up);
                   return;
           }
   
           KASSERT(up->ptr == uh, ("UNR Freeing free item %d (run))\n", item));
   
           /* Just this one left, reap it */
           if (up->len == 1) {
                   up->ptr = NULL;
                   uh->busy--;
                   collapse_unr(uh, up);
                   return;
           }
   
           /* Check if we can shift the item into the previous 'free' run */
           upp = TAILQ_PREV(up, unrhd, list);
           if (item == 0 && upp != NULL && upp->ptr == NULL) {
                   upp->len++;
                   up->len--;
                   uh->busy--;
                   collapse_unr(uh, up);
                   return;
           }
   
           /* Check if we can shift the item to the next 'free' run */
           upn = TAILQ_NEXT(up, list);
           if (item == up->len - 1 && upn != NULL && upn->ptr == NULL) {
                   upn->len++;
                   up->len--;
                   uh->busy--;
                   collapse_unr(uh, up);
                   return;
           }
   
           /* Split off the tail end, if any. */
           pl = up->len - (1 + item);
           if (pl > 0) {
                   upp = new_unr(uh, p1, p2);
                   upp->ptr = uh;
                   upp->len = pl;
                   TAILQ_INSERT_AFTER(&uh->head, up, upp, list);
           }
   
           /* Split off head end, if any */
           if (item > 0) {
                   upp = new_unr(uh, p1, p2);
                   upp->len = item;
                   upp->ptr = uh;
                   TAILQ_INSERT_BEFORE(up, upp, list);
           }
           up->len = 1;
           up->ptr = NULL;
           uh->busy--;
           collapse_unr(uh, up);
   }
   
   void
   free_unr(struct unrhdr *uh, u_int item)
   {
           void *p1, *p2;
   
           WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL, "free_unr");
           p1 = Malloc(sizeof(struct unr));
           p2 = Malloc(sizeof(struct unr));
           mtx_lock(uh->mtx);
           free_unrl(uh, item, &p1, &p2);
           clean_unrhdrl(uh);
           mtx_unlock(uh->mtx);
           if (p1 != NULL)
                   Free(p1);
           if (p2 != NULL)
                   Free(p2);
   }
   
   #ifndef _KERNEL /* USERLAND test driver */
   
   /*
    * Simple stochastic test driver for the above functions.  The code resides
    * here so that it can access static functions and structures.
    */
   
   static bool verbose;
   #define VPRINTF(...)    {if (verbose) printf(__VA_ARGS__);}
   
   static void
   print_unr(struct unrhdr *uh, struct unr *up)
   {
           u_int x;
           struct unrb *ub;
   
           printf("  %p len = %5u ", up, up->len);
           if (up->ptr == NULL)
                   printf("free\n");
           else if (up->ptr == uh)
                   printf("alloc\n");
           else {
                   ub = up->ptr;
                   printf("bitmap [");
                   for (x = 0; x < up->len; x++) {
                           if (bit_test(ub->map, x))
                                   printf("#");
                           else
                                   printf(" ");
                   }
                   printf("]\n");
           }
   }
   
   static void
   print_unrhdr(struct unrhdr *uh)
   {
           struct unr *up;
           u_int x;
   
           printf(
               "%p low = %u high = %u first = %u last = %u busy %u chunks = %u\n",
               uh, uh->low, uh->high, uh->first, uh->last, uh->busy, uh->alloc);
           x = uh->low + uh->first;
           TAILQ_FOREACH(up, &uh->head, list) {
                   printf("  from = %5u", x);
                   print_unr(uh, up);
                   if (up->ptr == NULL || up->ptr == uh)
                           x += up->len;
                   else
                           x += NBITS;
           }
   }
   
   static void
   test_alloc_unr(struct unrhdr *uh, u_int i, char a[])
   {
           int j;
   
           if (a[i]) {
                   VPRINTF("F %u\n", i);
                   free_unr(uh, i);
                   a[i] = 0;
           } else {
                   no_alloc = 1;
                   j = alloc_unr(uh);
                   if (j != -1) {
                           a[j] = 1;
                           VPRINTF("A %d\n", j);
                   }
                   no_alloc = 0;
           }
   }
   
   static void
   test_alloc_unr_specific(struct unrhdr *uh, u_int i, char a[])
   {
           int j;
   
           j = alloc_unr_specific(uh, i);
           if (j == -1) {
                   VPRINTF("F %u\n", i);
                   a[i] = 0;
                  free_unr(uh, i);
          } else {
                  a[i] = 1;
                  VPRINTF("A %d\n", j);
          }
  }
  
  static void
  usage(char** argv)
  {
          printf("%s [-h] [-r REPETITIONS] [-v]\n", argv[0]);
  }
  
  int
  main(int argc, char **argv)
  {
          struct unrhdr *uh;
          char *a;
          long count = 10000;     /* Number of unrs to test */
          long reps = 1, m;
          int ch;
          u_int i;
  
          verbose = false;
  
          while ((ch = getopt(argc, argv, "hr:v")) != -1) {
                  switch (ch) {
                  case 'r':
                          errno = 0;
                          reps = strtol(optarg, NULL, 0);
                          if (errno == ERANGE || errno == EINVAL) {
                                  usage(argv);
                                  exit(2);
                          }
  
                          break;
                  case 'v':
                          verbose = true;
                          break;
                  case 'h':
                  default:
                          usage(argv);
                          exit(2);
                  }
          }
  
          setbuf(stdout, NULL);
          uh = new_unrhdr(0, count - 1, NULL);
          print_unrhdr(uh);
  
          a = calloc(count, sizeof(char));
          if (a == NULL)
                  err(1, "calloc failed");
  
          printf("sizeof(struct unr) %zu\n", sizeof(struct unr));
          printf("sizeof(struct unrb) %zu\n", sizeof(struct unrb));
          printf("sizeof(struct unrhdr) %zu\n", sizeof(struct unrhdr));
          printf("NBITS %lu\n", (unsigned long)NBITS);
          for (m = 0; m < count * reps; m++) {
                  i = arc4random_uniform(count);
  #if 0
                  if (a[i] && (j & 1))
                          continue;
  #endif
                  if ((arc4random() & 1) != 0)
                          test_alloc_unr(uh, i, a);
                  else
                          test_alloc_unr_specific(uh, i, a);
  
                  if (verbose)
                          print_unrhdr(uh);
                  check_unrhdr(uh, __LINE__);
          }
          for (i = 0; i < (u_int)count; i++) {
                  if (a[i]) {
                          if (verbose) {
                                  printf("C %u\n", i);
                                  print_unrhdr(uh);
                          }
                          free_unr(uh, i);
                  }
          }
          print_unrhdr(uh);
          delete_unrhdr(uh);
          free(a);
          return (0);
  }
  #endif

Cache object: 7c6d96061de7a8fd8b6fbdd012864207