root/trunk/vmem_stand.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident   "@(#)vmem_stand.c       1.4     05/06/08 SMI"

/*
 * Standalone-specific vmem routines
 *
 * The standalone allocator operates on a pre-existing blob of memory, the
 * location and dimensions of which are set using vmem_stand_setsize().  We
 * then hand out CHUNKSIZE-sized pieces of this blob, until we run out.
 */

#define DEF_CHUNKSIZE   (64 * 1024)     /* 64K */

#define DEF_NREGIONS    2

#include <errno.h>
#include <limits.h>
#include <sys/sysmacros.h>
#include <sys/mman.h>
#include <unistd.h>
#include <strings.h>

#include "vmem_base.h"
#include "misc.h"

static vmem_t *stand_heap;

static size_t stand_chunksize;

typedef struct stand_region {
        caddr_t sr_base;
        caddr_t sr_curtop;
        size_t sr_left;
} stand_region_t;

static stand_region_t stand_regions[DEF_NREGIONS];
static int stand_nregions;

extern void membar_producer(void);

void
vmem_stand_init(void)
{
        stand_chunksize = MAX(DEF_CHUNKSIZE, pagesize);

        stand_nregions = 0;
}

int
vmem_stand_add(caddr_t base, size_t len)
{
        stand_region_t *sr = &stand_regions[stand_nregions];

        ASSERT(pagesize != 0);

        if (stand_nregions == DEF_NREGIONS) {
                errno = ENOSPC;
                return (-1); /* we don't have room -- throw it back */
        }

        /*
         * We guarantee that only one call to `vmem_stand_add' will be
         * active at a time, but we can't ensure that the allocator won't be
         * in use while this function is being called.  As such, we have to
         * ensure that sr is populated and visible to other processors before
         * allowing the allocator to access the new region.
         */
        sr->sr_base = base;
        sr->sr_curtop = (caddr_t)P2ROUNDUP((ulong_t)base, stand_chunksize);
        sr->sr_left = P2ALIGN(len - (size_t)(sr->sr_curtop - sr->sr_base),
            stand_chunksize);
        membar_producer();

        stand_nregions++;

        return (0);
}

static void *
stand_parent_alloc(vmem_t *src, size_t size, int vmflags)
{
        int old_errno = errno;
        stand_region_t *sr;
        size_t chksize;
        void *ret;
        int i;

        if ((ret = vmem_alloc(src, size, VM_NOSLEEP)) != NULL) {
                errno = old_errno;
                return (ret);
        }

        /* We need to allocate another chunk */
        chksize = roundup(size, stand_chunksize);

        for (sr = stand_regions, i = 0; i < stand_nregions; i++, sr++) {
                if (sr->sr_left >= chksize)
                        break;
        }

        if (i == stand_nregions) {
                /*
                 * We don't have enough in any of our regions to satisfy the
                 * request.
                 */
                errno = old_errno;
                return (NULL);
        }

        if ((ret = _vmem_extend_alloc(src, sr->sr_curtop, chksize, size,
            vmflags)) == NULL) {
                errno = old_errno;
                return (NULL);
        }

        bzero(sr->sr_curtop, chksize);

        sr->sr_curtop += chksize;
        sr->sr_left -= chksize;

        return (ret);
}

vmem_t *
vmem_stand_arena(vmem_alloc_t **a_out, vmem_free_t **f_out)
{
        ASSERT(stand_nregions == 1);

        stand_heap = vmem_init("stand_parent", stand_chunksize,
            stand_parent_alloc, vmem_free,
            "stand_heap", NULL, 0, pagesize, vmem_alloc, vmem_free);

        if (a_out != NULL)
                *a_out = vmem_alloc;
        if (f_out != NULL)
                *f_out = vmem_free;

        return (stand_heap);
}