usr/src/lib/libumem/common/vmem_sbrk.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 #pragma ident   "%Z%%M% %I%     %E% SMI"
  28
  29 /*
  30  * The structure of the sbrk backend:
  31  *
  32  * +-----------+
  33  * | sbrk_top  |
  34  * +-----------+
  35  *      | (vmem_sbrk_alloc(), vmem_free())
  36  *      |
  37  * +-----------+
  38  * | sbrk_heap |
  39  * +-----------+
  40  *   | | ... |  (vmem_alloc(), vmem_free())
  41  * <other arenas>
  42  *
  43  * The sbrk_top arena holds all controlled memory.  vmem_sbrk_alloc() handles
  44  * allocations from it, including growing the heap when we run low.
  45  *
  46  * Growing the heap is complicated by the fact that we have to extend the
  47  * sbrk_top arena (using _vmem_extend_alloc()), and that can fail.  Since
  48  * other threads may be actively allocating, we can't return the memory.
  49  *
  50  * Instead, we put it on a doubly-linked list, sbrk_fails, which we search
  51  * before calling sbrk().
  52  */
  53
  54 #include <errno.h>
  55 #include <limits.h>
  56 #include <sys/sysmacros.h>
  57 #include <sys/mman.h>
  58 #include <unistd.h>
  59
  60 #include "vmem_base.h"
  61
  62 #include "misc.h"
  63
  64 size_t vmem_sbrk_pagesize = 0; /* the preferred page size of the heap */
  65
  66 #define VMEM_SBRK_MINALLOC      (64 * 1024)
  67 size_t vmem_sbrk_minalloc = VMEM_SBRK_MINALLOC; /* minimum allocation */
  68
  69 static size_t real_pagesize;
  70 static vmem_t *sbrk_heap;
  71
  72 typedef struct sbrk_fail {
  73         struct sbrk_fail *sf_next;
  74         struct sbrk_fail *sf_prev;
  75         void *sf_base;                  /* == the sbrk_fail's address */
  76         size_t sf_size;                 /* the size of this buffer */
  77 } sbrk_fail_t;
  78
  79 static sbrk_fail_t sbrk_fails = {
  80         &sbrk_fails,
  81         &sbrk_fails,
  82         NULL,
  83         0
  84 };
  85
  86 static mutex_t sbrk_faillock = DEFAULTMUTEX;
  87
  88 /*
  89  * Try to extend src with [pos, pos + size).
  90  *
  91  * If it fails, add the block to the sbrk_fails list.
  92  */
  93 static void *
  94 vmem_sbrk_extend_alloc(vmem_t *src, void *pos, size_t size, size_t alloc,
  95     int vmflags)
  96 {
  97         sbrk_fail_t *fnext, *fprev, *fp;
  98         void *ret;
  99
 100         ret = _vmem_extend_alloc(src, pos, size, alloc, vmflags);
 101         if (ret != NULL)
 102                 return (ret);
 103
 104         fp = (sbrk_fail_t *)pos;
 105
 106         ASSERT(sizeof (sbrk_fail_t) <= size);
 107
 108         fp->sf_base = pos;
 109         fp->sf_size = size;
 110
 111         (void) mutex_lock(&sbrk_faillock);
 112         fp->sf_next = fnext = &sbrk_fails;
 113         fp->sf_prev = fprev = sbrk_fails.sf_prev;
 114         fnext->sf_prev = fp;
 115         fprev->sf_next = fp;
 116         (void) mutex_unlock(&sbrk_faillock);
 117
 118         return (NULL);
 119 }
 120
 121 /*
 122  * Try to add at least size bytes to src, using the sbrk_fails list
 123  */
 124 static void *
 125 vmem_sbrk_tryfail(vmem_t *src, size_t size, int vmflags)
 126 {
 127         sbrk_fail_t *fp;
 128
 129         (void) mutex_lock(&sbrk_faillock);
 130         for (fp = sbrk_fails.sf_next; fp != &sbrk_fails; fp = fp->sf_next) {
 131                 if (fp->sf_size >= size) {
 132                         fp->sf_next->sf_prev = fp->sf_prev;
 133                         fp->sf_prev->sf_next = fp->sf_next;
 134                         fp->sf_next = fp->sf_prev = NULL;
 135                         break;
 136                 }
 137         }
 138         (void) mutex_unlock(&sbrk_faillock);
 139
 140         if (fp != &sbrk_fails) {
 141                 ASSERT(fp->sf_base == (void *)fp);
 142                 return (vmem_sbrk_extend_alloc(src, fp, fp->sf_size, size,
 143                     vmflags));
 144         }
 145         /*
 146          * nothing of the right size on the freelist
 147          */
 148         return (NULL);
 149 }
 150
 151 static void *
 152 vmem_sbrk_alloc(vmem_t *src, size_t size, int vmflags)
 153 {
 154         extern void *_sbrk_grow_aligned(size_t min_size, size_t low_align,
 155             size_t high_align, size_t *actual_size);
 156
 157         void *ret;
 158         void *buf;
 159         size_t buf_size;
 160
 161         int old_errno = errno;
 162
 163         ret = vmem_alloc(src, size, VM_NOSLEEP);
 164         if (ret != NULL) {
 165                 errno = old_errno;
 166                 return (ret);
 167         }
 168
 169         /*
 170          * The allocation failed.  We need to grow the heap.
 171          *
 172          * First, try to use any buffers which failed earlier.
 173          */
 174         if (sbrk_fails.sf_next != &sbrk_fails &&
 175             (ret = vmem_sbrk_tryfail(src, size, vmflags)) != NULL)
 176                 return (ret);
 177
 178         buf_size = MAX(size, vmem_sbrk_minalloc);
 179
 180         /*
 181          * buf_size gets overwritten with the actual allocated size
 182          */
 183         buf = _sbrk_grow_aligned(buf_size, real_pagesize, vmem_sbrk_pagesize,
 184             &buf_size);
 185
 186         if (buf != MAP_FAILED) {
 187                 ret = vmem_sbrk_extend_alloc(src, buf, buf_size, size, vmflags);
 188                 if (ret != NULL) {
 189                         errno = old_errno;
 190                         return (ret);
 191                 }
 192         }
 193
 194         /*
 195          * Growing the heap failed. The vmem_alloc() above called umem_reap().
 196          */
 197         ASSERT((vmflags & VM_NOSLEEP) == VM_NOSLEEP);
 198
 199         errno = old_errno;
 200         return (NULL);
 201 }
 202
 203 /*
 204  * fork1() support
 205  */
 206 void
 207 vmem_sbrk_lockup(void)
 208 {
 209         (void) mutex_lock(&sbrk_faillock);
 210 }
 211
 212 void
 213 vmem_sbrk_release(void)
 214 {
 215         (void) mutex_unlock(&sbrk_faillock);
 216 }
 217
 218 vmem_t *
 219 vmem_sbrk_arena(vmem_alloc_t **a_out, vmem_free_t **f_out)
 220 {
 221         if (sbrk_heap == NULL) {
 222                 size_t heap_size;
 223
 224                 real_pagesize = sysconf(_SC_PAGESIZE);
 225
 226                 heap_size = vmem_sbrk_pagesize;
 227
 228                 if (issetugid()) {
 229                         heap_size = 0;
 230                 } else if (heap_size != 0 && !ISP2(heap_size)) {
 231                         heap_size = 0;
 232                         log_message("ignoring bad pagesize: 0x%p\n", heap_size);
 233                 }
 234                 if (heap_size <= real_pagesize) {
 235                         heap_size = real_pagesize;
 236                 } else {
 237                         struct memcntl_mha mha;
 238                         mha.mha_cmd = MHA_MAPSIZE_BSSBRK;
 239                         mha.mha_flags = 0;
 240                         mha.mha_pagesize = heap_size;
 241
 242                         if (memcntl(NULL, 0, MC_HAT_ADVISE, (char *)&mha, 0, 0)
 243                             == -1) {
 244                                 log_message("unable to set MAPSIZE_BSSBRK to "
 245                                     "0x%p\n", heap_size);
 246                                 heap_size = real_pagesize;
 247                         }
 248                 }
 249                 vmem_sbrk_pagesize = heap_size;
 250
 251                 /* validate vmem_sbrk_minalloc */
 252                 if (vmem_sbrk_minalloc < VMEM_SBRK_MINALLOC)
 253                         vmem_sbrk_minalloc = VMEM_SBRK_MINALLOC;
 254                 vmem_sbrk_minalloc = P2ROUNDUP(vmem_sbrk_minalloc, heap_size);
 255
 256                 sbrk_heap = vmem_init("sbrk_top", real_pagesize,
 257                     vmem_sbrk_alloc, vmem_free,
 258                     "sbrk_heap", NULL, 0, real_pagesize,
 259                     vmem_alloc, vmem_free);
 260         }
 261
 262         if (a_out != NULL)
 263                 *a_out = vmem_alloc;
 264         if (f_out != NULL)
 265                 *f_out = vmem_free;
 266
 267         return (sbrk_heap);
 268 }