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);
}