2N/A/*
2N/A * CDDL HEADER START
2N/A *
2N/A * The contents of this file are subject to the terms of the
2N/A * Common Development and Distribution License (the "License").
2N/A * You may not use this file except in compliance with the License.
2N/A *
2N/A * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
2N/A * or http://www.opensolaris.org/os/licensing.
2N/A * See the License for the specific language governing permissions
2N/A * and limitations under the License.
2N/A *
2N/A * When distributing Covered Code, include this CDDL HEADER in each
2N/A * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
2N/A * If applicable, add the following below this CDDL HEADER, with the
2N/A * fields enclosed by brackets "[]" replaced with your own identifying
2N/A * information: Portions Copyright [yyyy] [name of copyright owner]
2N/A *
2N/A * CDDL HEADER END
2N/A */
2N/A
2N/A/*
2N/A * Copyright (c) 2002, 2012, Oracle and/or its affiliates. All rights reserved.
2N/A */
2N/A
2N/A
2N/A/*
2N/A * The structure of the sbrk backend:
2N/A *
2N/A * +-----------+
2N/A * | sbrk_top |
2N/A * +-----------+
2N/A * | (vmem_sbrk_alloc(), vmem_free())
2N/A * |
2N/A * +-----------+
2N/A * | sbrk_heap |
2N/A * +-----------+
2N/A * | | ... | (vmem_alloc(), vmem_free())
2N/A * <other arenas>
2N/A *
2N/A * The sbrk_top arena holds all controlled memory. vmem_sbrk_alloc() handles
2N/A * allocations from it, including growing the heap when we run low.
2N/A *
2N/A * Growing the heap is complicated by the fact that we have to extend the
2N/A * sbrk_top arena (using _vmem_extend_alloc()), and that can fail. Since
2N/A * other threads may be actively allocating, we can't return the memory.
2N/A *
2N/A * Instead, we put it on a doubly-linked list, sbrk_fails, which we search
2N/A * before calling sbrk().
2N/A */
2N/A
2N/A#include <errno.h>
2N/A#include <limits.h>
2N/A#include <sys/sysmacros.h>
2N/A#include <sys/mman.h>
2N/A#include <unistd.h>
2N/A
2N/A#include "vmem_base.h"
2N/A
2N/A#include "misc.h"
2N/A
2N/Asize_t vmem_sbrk_pagesize = 0; /* the preferred page size of the heap */
2N/A
2N/A#define VMEM_SBRK_MINALLOC (64 * 1024)
2N/Asize_t vmem_sbrk_minalloc = VMEM_SBRK_MINALLOC; /* minimum allocation */
2N/A
2N/Astatic size_t real_pagesize;
2N/Astatic vmem_t *sbrk_heap;
2N/A
2N/Atypedef struct sbrk_fail {
2N/A struct sbrk_fail *sf_next;
2N/A struct sbrk_fail *sf_prev;
2N/A void *sf_base; /* == the sbrk_fail's address */
2N/A size_t sf_size; /* the size of this buffer */
2N/A} sbrk_fail_t;
2N/A
2N/Astatic sbrk_fail_t sbrk_fails = {
2N/A &sbrk_fails,
2N/A &sbrk_fails,
2N/A NULL,
2N/A 0
2N/A};
2N/A
2N/Astatic mutex_t sbrk_faillock = DEFAULTMUTEX;
2N/A
2N/A/*
2N/A * Try to extend src with [pos, pos + size).
2N/A *
2N/A * If it fails, add the block to the sbrk_fails list.
2N/A */
2N/Astatic void *
2N/Avmem_sbrk_extend_alloc(vmem_t *src, void *pos, size_t size, size_t alloc,
2N/A int vmflags)
2N/A{
2N/A sbrk_fail_t *fnext, *fprev, *fp;
2N/A void *ret;
2N/A
2N/A ret = _vmem_extend_alloc(src, pos, size, alloc, vmflags);
2N/A if (ret != NULL)
2N/A return (ret);
2N/A
2N/A fp = (sbrk_fail_t *)pos;
2N/A
2N/A ASSERT(sizeof (sbrk_fail_t) <= size);
2N/A
2N/A fp->sf_base = pos;
2N/A fp->sf_size = size;
2N/A
2N/A (void) mutex_lock(&sbrk_faillock);
2N/A fp->sf_next = fnext = &sbrk_fails;
2N/A fp->sf_prev = fprev = sbrk_fails.sf_prev;
2N/A fnext->sf_prev = fp;
2N/A fprev->sf_next = fp;
2N/A (void) mutex_unlock(&sbrk_faillock);
2N/A
2N/A return (NULL);
2N/A}
2N/A
2N/A/*
2N/A * Try to add at least size bytes to src, using the sbrk_fails list
2N/A */
2N/Astatic void *
2N/Avmem_sbrk_tryfail(vmem_t *src, size_t size, int vmflags)
2N/A{
2N/A sbrk_fail_t *fp;
2N/A
2N/A (void) mutex_lock(&sbrk_faillock);
2N/A for (fp = sbrk_fails.sf_next; fp != &sbrk_fails; fp = fp->sf_next) {
2N/A if (fp->sf_size >= size) {
2N/A fp->sf_next->sf_prev = fp->sf_prev;
2N/A fp->sf_prev->sf_next = fp->sf_next;
2N/A fp->sf_next = fp->sf_prev = NULL;
2N/A break;
2N/A }
2N/A }
2N/A (void) mutex_unlock(&sbrk_faillock);
2N/A
2N/A if (fp != &sbrk_fails) {
2N/A ASSERT(fp->sf_base == (void *)fp);
2N/A return (vmem_sbrk_extend_alloc(src, fp, fp->sf_size, size,
2N/A vmflags));
2N/A }
2N/A /*
2N/A * nothing of the right size on the freelist
2N/A */
2N/A return (NULL);
2N/A}
2N/A
2N/Astatic void *
2N/Avmem_sbrk_alloc(vmem_t *src, size_t size, int vmflags)
2N/A{
2N/A extern void *_sbrk_grow_aligned(size_t min_size, size_t low_align,
2N/A size_t high_align, size_t *actual_size);
2N/A
2N/A void *ret;
2N/A void *buf;
2N/A size_t buf_size;
2N/A
2N/A int old_errno = errno;
2N/A
2N/A ret = vmem_alloc(src, size, VM_NOSLEEP | vmem_extra_flags);
2N/A if (ret != NULL) {
2N/A errno = old_errno;
2N/A return (ret);
2N/A }
2N/A
2N/A /*
2N/A * The allocation failed. We need to grow the heap.
2N/A *
2N/A * First, try to use any buffers which failed earlier.
2N/A */
2N/A if (sbrk_fails.sf_next != &sbrk_fails &&
2N/A (ret = vmem_sbrk_tryfail(src, size, vmflags)) != NULL)
2N/A return (ret);
2N/A
2N/A buf_size = MAX(size, vmem_sbrk_minalloc);
2N/A
2N/A /*
2N/A * buf_size gets overwritten with the actual allocated size
2N/A */
2N/A buf = _sbrk_grow_aligned(buf_size, real_pagesize, vmem_sbrk_pagesize,
2N/A &buf_size);
2N/A
2N/A if (buf != MAP_FAILED) {
2N/A ret = vmem_sbrk_extend_alloc(src, buf, buf_size, size, vmflags);
2N/A if (ret != NULL) {
2N/A errno = old_errno;
2N/A return (ret);
2N/A }
2N/A }
2N/A
2N/A /*
2N/A * Growing the heap failed. The vmem_alloc() above called umem_reap().
2N/A */
2N/A ASSERT((vmflags & VM_NOSLEEP) == VM_NOSLEEP);
2N/A
2N/A errno = old_errno;
2N/A return (NULL);
2N/A}
2N/A
2N/A/*
2N/A * fork1() support
2N/A */
2N/Avoid
2N/Avmem_sbrk_lockup(void)
2N/A{
2N/A (void) mutex_lock(&sbrk_faillock);
2N/A}
2N/A
2N/Avoid
2N/Avmem_sbrk_release(void)
2N/A{
2N/A (void) mutex_unlock(&sbrk_faillock);
2N/A}
2N/A
2N/Avmem_t *
2N/Avmem_sbrk_arena(vmem_alloc_t **a_out, vmem_free_t **f_out)
2N/A{
2N/A if (sbrk_heap == NULL) {
2N/A size_t heap_size;
2N/A
2N/A real_pagesize = sysconf(_SC_PAGESIZE);
2N/A
2N/A heap_size = vmem_sbrk_pagesize;
2N/A
2N/A if (issetugid()) {
2N/A heap_size = 0;
2N/A } else if (heap_size != 0 && !ISP2(heap_size)) {
2N/A heap_size = 0;
2N/A log_message("ignoring bad pagesize: 0x%p\n", heap_size);
2N/A }
2N/A if (heap_size <= real_pagesize) {
2N/A heap_size = real_pagesize;
2N/A } else {
2N/A struct memcntl_mha mha;
2N/A mha.mha_cmd = MHA_MAPSIZE_BSSBRK;
2N/A mha.mha_flags = 0;
2N/A mha.mha_pagesize = heap_size;
2N/A
2N/A if (memcntl(NULL, 0, MC_HAT_ADVISE, (char *)&mha, 0, 0)
2N/A == -1) {
2N/A log_message("unable to set MAPSIZE_BSSBRK to "
2N/A "0x%p\n", heap_size);
2N/A heap_size = real_pagesize;
2N/A }
2N/A }
2N/A vmem_sbrk_pagesize = heap_size;
2N/A
2N/A /* validate vmem_sbrk_minalloc */
2N/A if (vmem_sbrk_minalloc < VMEM_SBRK_MINALLOC)
2N/A vmem_sbrk_minalloc = VMEM_SBRK_MINALLOC;
2N/A vmem_sbrk_minalloc = P2ROUNDUP(vmem_sbrk_minalloc, heap_size);
2N/A
2N/A sbrk_heap = vmem_init("sbrk_top", real_pagesize,
2N/A vmem_sbrk_alloc, vmem_free,
2N/A "sbrk_heap", NULL, 0, real_pagesize,
2N/A vmem_alloc, vmem_free);
2N/A }
2N/A
2N/A if (a_out != NULL)
2N/A *a_out = vmem_alloc;
2N/A if (f_out != NULL)
2N/A *f_out = vmem_free;
2N/A
2N/A return (sbrk_heap);
2N/A}