Archive-Team
/
zfs
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 103 Wiki Activity

Remove libumem, we will try and remove this dependency entirely. If we can't then the best move will simply be to use the official library, or build it as a convenience library

This commit is contained in:
Brian Behlendorf 2008-12-10 12:43:20 -08:00
parent 5e97ed8493
commit 9e8b1e836c
27 changed files with 0 additions and 9425 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
scripts/update-zfs.sh
View File

@ -72,13 +72,6 @@ cp ${SRC_LIB}/libnvpair/libnvpair.h ${DST_LIB}/libnvpair/include/
cp ${SRC_UCM}/sys/nvpair.h ${DST_LIB}/libnvpair/include/sys/
cp ${SRC_UCM}/sys/nvpair_impl.h ${DST_LIB}/libnvpair/include/sys/
echo "* zfs/lib/libumem"
mkdir -p ${DST_LIB}/libumem/include/sys/
cp ${SRC_LIB}/libumem/common/*.c ${DST_LIB}/libumem/
cp ${SRC_LIB}/libumem/common/*.h ${DST_LIB}/libumem/include/
cp ${SRC_LIB}/libumem/common/sys/*.h ${DST_LIB}/libumem/include/sys/
cp ${SRC_UCM}/sys/vmem.h ${DST_LIB}/libumem/include/sys/
echo "* zfs/lib/libuutil"
mkdir -p ${DST_LIB}/libuutil/include/
cp ${SRC_LIB}/libuutil/common/*.c ${DST_LIB}/libuutil/

746
zfs/lib/libumem/envvar.c
View File

@ -1,746 +0,0 @@
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (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 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#include <ctype.h>
#include <errno.h>
#include <limits.h>
#include <stdlib.h>
#include <string.h>
#include <dlfcn.h>
#include "umem_base.h"
#include "vmem_base.h"
/*
* A umem environment variable, like UMEM_DEBUG, is set to a series
* of items, seperated by ',':
*
* UMEM_DEBUG="audit=10,guards,firewall=512"
*
* This structure describes items. Each item has a name, type, and
* description. During processing, an item read from the user may
* be either "valid" or "invalid".
*
* A valid item has an argument, if required, and it is of the right
* form (doesn't overflow, doesn't contain any unexpected characters).
*
* If the item is valid, item_flag_target != NULL, and:
* type is not CLEARFLAG, then (*item_flag_target) |= item_flag_value
* type is CLEARFLAG, then (*item_flag_target) &= ~item_flag_value
*/
#define UMEM_ENV_ITEM_MAX 512
struct umem_env_item;
typedef int arg_process_t(const struct umem_env_item *item, const char *value);
#define ARG_SUCCESS 0 /* processing successful */
#define ARG_BAD 1 /* argument had a bad value */
typedef struct umem_env_item {
const char *item_name; /* tag in environment variable */
const char *item_interface_stability;
enum {
ITEM_INVALID,
ITEM_FLAG, /* only a flag. No argument allowed */
ITEM_CLEARFLAG, /* only a flag, but clear instead of set */
ITEM_OPTUINT, /* optional integer argument */
ITEM_UINT, /* required integer argument */
ITEM_OPTSIZE, /* optional size_t argument */
ITEM_SIZE, /* required size_t argument */
ITEM_SPECIAL /* special argument processing */
} item_type;
const char *item_description;
uint_t *item_flag_target; /* the variable containing the flag */
uint_t item_flag_value; /* the value to OR in */
uint_t *item_uint_target; /* the variable to hold the integer */
size_t *item_size_target;
arg_process_t *item_special; /* callback for special handling */
} umem_env_item_t;
#ifndef UMEM_STANDALONE
static arg_process_t umem_backend_process;
#endif
static arg_process_t umem_log_process;
static size_t umem_size_tempval;
static arg_process_t umem_size_process;
const char *____umem_environ_msg_options = "-- UMEM_OPTIONS --";
static umem_env_item_t umem_options_items[] = {
#ifndef UMEM_STANDALONE
{ "backend", "Evolving", ITEM_SPECIAL,
"=sbrk for sbrk(2), =mmap for mmap(2)",
NULL, 0, NULL, NULL,
&umem_backend_process
},
#endif
{ "concurrency", "Private", ITEM_UINT,
"Max concurrency",
NULL, 0, &umem_max_ncpus
},
{ "max_contention", "Private", ITEM_UINT,
"Maximum contention in a reap interval before the depot is "
"resized.",
NULL, 0, &umem_depot_contention
},
{ "nomagazines", "Private", ITEM_FLAG,
"no caches will be multithreaded, and no caching will occur.",
&umem_flags, UMF_NOMAGAZINE
},
{ "reap_interval", "Private", ITEM_UINT,
"Minimum time between reaps and updates, in seconds.",
NULL, 0, &umem_reap_interval
},
{ "size_add", "Private", ITEM_SPECIAL,
"add a size to the cache size table",
NULL, 0, NULL,
&umem_size_tempval, &umem_size_process
},
{ "size_clear", "Private", ITEM_SPECIAL,
"clear all but the largest size from the cache size table",
NULL, 0, NULL,
&umem_size_tempval, &umem_size_process
},
{ "size_remove", "Private", ITEM_SPECIAL,
"remove a size from the cache size table",
NULL, 0, NULL,
&umem_size_tempval, &umem_size_process
},
#ifndef UMEM_STANDALONE
{ "sbrk_minalloc", "Private", ITEM_SIZE,
"The minimum allocation chunk for the sbrk(2) heap.",
NULL, 0, NULL, &vmem_sbrk_minalloc
},
{ "sbrk_pagesize", "Private", ITEM_SIZE,
"The preferred page size for the sbrk(2) heap.",
NULL, 0, NULL, &vmem_sbrk_pagesize
},
#endif
{ NULL, "-- end of UMEM_OPTIONS --", ITEM_INVALID }
};
const char *____umem_environ_msg_debug = "-- UMEM_DEBUG --";
static umem_env_item_t umem_debug_items[] = {
{ "default", "Unstable", ITEM_FLAG,
"audit,contents,guards",
&umem_flags,
UMF_AUDIT | UMF_CONTENTS | UMF_DEADBEEF | UMF_REDZONE
},
{ "audit", "Unstable", ITEM_OPTUINT,
"Enable auditing. optionally =frames to set the number of "
"stored stack frames",
&umem_flags, UMF_AUDIT, &umem_stack_depth
},
{ "contents", "Unstable", ITEM_OPTSIZE,
"Enable contents storing. UMEM_LOGGING=contents also "
"required. optionally =bytes to set the number of stored "
"bytes",
&umem_flags, UMF_CONTENTS, NULL, &umem_content_maxsave
},
{ "guards", "Unstable", ITEM_FLAG,
"Enables guards and special patterns",
&umem_flags, UMF_DEADBEEF | UMF_REDZONE
},
{ "verbose", "Unstable", ITEM_FLAG,
"Enables writing error messages to stderr",
&umem_output, 1
},
{ "nosignal", "Private", ITEM_FLAG,
"Abort if called from a signal handler. Turns on 'audit'. "
"Note that this is not always a bug.",
&umem_flags, UMF_AUDIT | UMF_CHECKSIGNAL
},
{ "firewall", "Private", ITEM_SIZE,
"=minbytes. Every object >= minbytes in size will have its "
"end against an unmapped page",
&umem_flags, UMF_FIREWALL, NULL, &umem_minfirewall
},
{ "lite", "Private", ITEM_FLAG,
"debugging-lite",
&umem_flags, UMF_LITE
},
{ "maxverify", "Private", ITEM_SIZE,
"=maxbytes, Maximum bytes to check when 'guards' is active. "
"Normally all bytes are checked.",
NULL, 0, NULL, &umem_maxverify
},
{ "noabort", "Private", ITEM_CLEARFLAG,
"umem will not abort when a recoverable error occurs "
"(i.e. double frees, certain kinds of corruption)",
&umem_abort, 1
},
{ "mtbf", "Private", ITEM_UINT,
"=mtbf, the mean time between injected failures. Works best "
"if prime.\n",
NULL, 0, &umem_mtbf
},
{ "random", "Private", ITEM_FLAG,
"randomize flags on a per-cache basis",
&umem_flags, UMF_RANDOMIZE
},
{ "allverbose", "Private", ITEM_FLAG,
"Enables writing all logged messages to stderr",
&umem_output, 2
},
{ NULL, "-- end of UMEM_DEBUG --", ITEM_INVALID }
};
const char *____umem_environ_msg_logging = "-- UMEM_LOGGING --";
static umem_env_item_t umem_logging_items[] = {
{ "transaction", "Unstable", ITEM_SPECIAL,
"If 'audit' is set in UMEM_DEBUG, the audit structures "
"from previous transactions are entered into this log.",
NULL, 0, NULL,
&umem_transaction_log_size, &umem_log_process
},
{ "contents", "Unstable", ITEM_SPECIAL,
"If 'audit' is set in UMEM_DEBUG, the contents of objects "
"are recorded in this log as they are freed. If the "
"'contents' option is not set in UMEM_DEBUG, the first "
"256 bytes of each freed buffer will be saved.",
&umem_flags, UMF_CONTENTS, NULL,
&umem_content_log_size, &umem_log_process
},
{ "fail", "Unstable", ITEM_SPECIAL,
"Records are entered into this log for every failed "
"allocation.",
NULL, 0, NULL,
&umem_failure_log_size, &umem_log_process
},
{ "slab", "Private", ITEM_SPECIAL,
"Every slab created will be entered into this log.",
NULL, 0, NULL,
&umem_slab_log_size, &umem_log_process
},
{ NULL, "-- end of UMEM_LOGGING --", ITEM_INVALID }
};
typedef struct umem_envvar {
const char *env_name;
const char *env_func;
umem_env_item_t *env_item_list;
const char *env_getenv_result;
const char *env_func_result;
} umem_envvar_t;
static umem_envvar_t umem_envvars[] = {
{ "UMEM_DEBUG", "_umem_debug_init", umem_debug_items },
{ "UMEM_OPTIONS", "_umem_options_init", umem_options_items },
{ "UMEM_LOGGING", "_umem_logging_init", umem_logging_items },
{ NULL, NULL, NULL }
};
static umem_envvar_t *env_current;
#define CURRENT (env_current->env_name)
static int
empty(const char *str)
{
char c;
while ((c = *str) != '\0' && isspace(c))
str++;
return (*str == '\0');
}
static int
item_uint_process(const umem_env_item_t *item, const char *item_arg)
{
ulong_t result;
char *endptr = "";
int olderrno;
olderrno = errno;
errno = 0;
if (empty(item_arg)) {
goto badnumber;
}
result = strtoul(item_arg, &endptr, 10);
if (result == ULONG_MAX && errno == ERANGE) {
errno = olderrno;
goto overflow;
}
errno = olderrno;
if (*endptr != '\0')
goto badnumber;
if ((uint_t)result != result)
goto overflow;
(*item->item_uint_target) = (uint_t)result;
return (ARG_SUCCESS);
badnumber:
log_message("%s: %s: not a number\n", CURRENT, item->item_name);
return (ARG_BAD);
overflow:
log_message("%s: %s: overflowed\n", CURRENT, item->item_name);
return (ARG_BAD);
}
static int
item_size_process(const umem_env_item_t *item, const char *item_arg)
{
ulong_t result;
ulong_t result_arg;
char *endptr = "";
int olderrno;
if (empty(item_arg))
goto badnumber;
olderrno = errno;
errno = 0;
result_arg = strtoul(item_arg, &endptr, 10);
if (result_arg == ULONG_MAX && errno == ERANGE) {
errno = olderrno;
goto overflow;
}
errno = olderrno;
result = result_arg;
switch (*endptr) {
case 't':
case 'T':
result *= 1024;
if (result < result_arg)
goto overflow;
/*FALLTHRU*/
case 'g':
case 'G':
result *= 1024;
if (result < result_arg)
goto overflow;
/*FALLTHRU*/
case 'm':
case 'M':
result *= 1024;
if (result < result_arg)
goto overflow;
/*FALLTHRU*/
case 'k':
case 'K':
result *= 1024;
if (result < result_arg)
goto overflow;
endptr++; /* skip over the size character */
break;
default:
break; /* handled later */
}
if (*endptr != '\0')
goto badnumber;
(*item->item_size_target) = result;
return (ARG_SUCCESS);
badnumber:
log_message("%s: %s: not a number\n", CURRENT, item->item_name);
return (ARG_BAD);
overflow:
log_message("%s: %s: overflowed\n", CURRENT, item->item_name);
return (ARG_BAD);
}
static int
umem_log_process(const umem_env_item_t *item, const char *item_arg)
{
if (item_arg != NULL) {
int ret;
ret = item_size_process(item, item_arg);
if (ret != ARG_SUCCESS)
return (ret);
if (*item->item_size_target == 0)
return (ARG_SUCCESS);
} else
*item->item_size_target = 64*1024;
umem_logging = 1;
return (ARG_SUCCESS);
}
static int
umem_size_process(const umem_env_item_t *item, const char *item_arg)
{
const char *name = item->item_name;
void (*action_func)(size_t);
size_t result;
int ret;
if (strcmp(name, "size_clear") == 0) {
if (item_arg != NULL) {
log_message("%s: %s: does not take a value. ignored\n",
CURRENT, name);
return (ARG_BAD);
}
umem_alloc_sizes_clear();
return (ARG_SUCCESS);
} else if (strcmp(name, "size_add") == 0) {
action_func = umem_alloc_sizes_add;
} else if (strcmp(name, "size_remove") == 0) {
action_func = umem_alloc_sizes_remove;
} else {
log_message("%s: %s: internally unrecognized\n",
CURRENT, name, name, name);
return (ARG_BAD);
}
if (item_arg == NULL) {
log_message("%s: %s: requires a value. ignored\n",
CURRENT, name);
return (ARG_BAD);
}
ret = item_size_process(item, item_arg);
if (ret != ARG_SUCCESS)
return (ret);
result = *item->item_size_target;
action_func(result);
return (ARG_SUCCESS);
}
#ifndef UMEM_STANDALONE
static int
umem_backend_process(const umem_env_item_t *item, const char *item_arg)
{
const char *name = item->item_name;
if (item_arg == NULL)
goto fail;
if (strcmp(item_arg, "sbrk") == 0)
vmem_backend |= VMEM_BACKEND_SBRK;
else if (strcmp(item_arg, "mmap") == 0)
vmem_backend |= VMEM_BACKEND_MMAP;
else
goto fail;
return (ARG_SUCCESS);
fail:
log_message("%s: %s: must be %s=sbrk or %s=mmap\n",
CURRENT, name, name, name);
return (ARG_BAD);
}
#endif
static int
process_item(const umem_env_item_t *item, const char *item_arg)
{
int arg_required = 0;
arg_process_t *processor;
switch (item->item_type) {
case ITEM_FLAG:
case ITEM_CLEARFLAG:
case ITEM_OPTUINT:
case ITEM_OPTSIZE:
case ITEM_SPECIAL:
arg_required = 0;
break;
case ITEM_UINT:
case ITEM_SIZE:
arg_required = 1;
break;
}
switch (item->item_type) {
case ITEM_FLAG:
case ITEM_CLEARFLAG:
if (item_arg != NULL) {
log_message("%s: %s: does not take a value. ignored\n",
CURRENT, item->item_name);
return (1);
}
processor = NULL;
break;
case ITEM_UINT:
case ITEM_OPTUINT:
processor = item_uint_process;
break;
case ITEM_SIZE:
case ITEM_OPTSIZE:
processor = item_size_process;
break;
case ITEM_SPECIAL:
processor = item->item_special;
break;
default:
log_message("%s: %s: Invalid type. Ignored\n",
CURRENT, item->item_name);
return (1);
}
if (arg_required && item_arg == NULL) {
log_message("%s: %s: Required value missing\n",
CURRENT, item->item_name);
goto invalid;
}
if (item_arg != NULL || item->item_type == ITEM_SPECIAL) {
if (processor(item, item_arg) != ARG_SUCCESS)
goto invalid;
}
if (item->item_flag_target) {
if (item->item_type == ITEM_CLEARFLAG)
(*item->item_flag_target) &= ~item->item_flag_value;
else
(*item->item_flag_target) |= item->item_flag_value;
}
return (0);
invalid:
return (1);
}
#define ENV_SHORT_BYTES 10 /* bytes to print on error */
void
umem_process_value(umem_env_item_t *item_list, const char *beg, const char *end)
{
char buf[UMEM_ENV_ITEM_MAX];
char *argptr;
size_t count;
while (beg < end && isspace(*beg))
beg++;
while (beg < end && isspace(*(end - 1)))
end--;
if (beg >= end) {
log_message("%s: empty option\n", CURRENT);
return;
}
count = end - beg;
if (count + 1 > sizeof (buf)) {
char outbuf[ENV_SHORT_BYTES + 1];
/*
* Have to do this, since sprintf("%10s",...) calls malloc()
*/
(void) strncpy(outbuf, beg, ENV_SHORT_BYTES);
outbuf[ENV_SHORT_BYTES] = 0;
log_message("%s: argument \"%s...\" too long\n", CURRENT,
outbuf);
return;
}
(void) strncpy(buf, beg, count);
buf[count] = 0;
argptr = strchr(buf, '=');
if (argptr != NULL)
*argptr++ = 0;
for (; item_list->item_name != NULL; item_list++) {
if (strcmp(buf, item_list->item_name) == 0) {
(void) process_item(item_list, argptr);
return;
}
}
log_message("%s: '%s' not recognized\n", CURRENT, buf);
}
/*ARGSUSED*/
void
umem_setup_envvars(int invalid)
{
umem_envvar_t *cur_env;
static volatile enum {
STATE_START,
STATE_GETENV,
STATE_DLOPEN,
STATE_DLSYM,
STATE_FUNC,
STATE_DONE
} state = STATE_START;
#ifndef UMEM_STANDALONE
void *h;
#endif
if (invalid) {
const char *where;
/*
* One of the calls below invoked malloc() recursively. We
* remove any partial results and return.
*/
switch (state) {
case STATE_START:
where = "before getenv(3C) calls -- "
"getenv(3C) results ignored.";
break;
case STATE_GETENV:
where = "during getenv(3C) calls -- "
"getenv(3C) results ignored.";
break;
case STATE_DLOPEN:
where = "during dlopen(3C) call -- "
"_umem_*() results ignored.";
break;
case STATE_DLSYM:
where = "during dlsym(3C) call -- "
"_umem_*() results ignored.";
break;
case STATE_FUNC:
where = "during _umem_*() call -- "
"_umem_*() results ignored.";
break;
case STATE_DONE:
where = "after dlsym() or _umem_*() calls.";
break;
default:
where = "at unknown point -- "
"_umem_*() results ignored.";
break;
}
log_message("recursive allocation %s\n", where);
for (cur_env = umem_envvars; cur_env->env_name != NULL;
cur_env++) {
if (state == STATE_GETENV)
cur_env->env_getenv_result = NULL;
if (state != STATE_DONE)
cur_env->env_func_result = NULL;
}
state = STATE_DONE;
return;
}
state = STATE_GETENV;
for (cur_env = umem_envvars; cur_env->env_name != NULL; cur_env++) {
cur_env->env_getenv_result = getenv(cur_env->env_name);
if (state == STATE_DONE)
return; /* recursed */
}
#ifndef UMEM_STANDALONE
state = STATE_DLOPEN;
/* get a handle to the "a.out" object */
if ((h = dlopen(0, RTLD_FIRST | RTLD_LAZY)) != NULL) {
for (cur_env = umem_envvars; cur_env->env_name != NULL;
cur_env++) {
const char *(*func)(void);
const char *value;
state = STATE_DLSYM;
func = (const char *(*)(void))dlsym(h,
cur_env->env_func);
if (state == STATE_DONE)
break; /* recursed */
state = STATE_FUNC;
if (func != NULL) {
value = func();
if (state == STATE_DONE)
break; /* recursed */
cur_env->env_func_result = value;
}
}
(void) dlclose(h);
} else {
(void) dlerror(); /* snarf dlerror() */
}
#endif /* UMEM_STANDALONE */
state = STATE_DONE;
}
/*
* Process the environment variables.
*/
void
umem_process_envvars(void)
{
const char *value;
const char *end, *next;
umem_envvar_t *cur_env;
for (cur_env = umem_envvars; cur_env->env_name != NULL; cur_env++) {
env_current = cur_env;
value = cur_env->env_getenv_result;
if (value == NULL)
value = cur_env->env_func_result;
/* ignore if missing or empty */
if (value == NULL)
continue;
for (end = value; *end != '\0'; value = next) {
end = strchr(value, ',');
if (end != NULL)
next = end + 1; /* skip the comma */
else
next = end = value + strlen(value);
umem_process_value(cur_env->env_item_list, value, end);
}
}
}

188
zfs/lib/libumem/getpcstack.c
View File

@ -1,188 +0,0 @@
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (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 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#include "misc.h"
#include <ucontext.h>
#include <sys/frame.h>
#include <sys/stack.h>
#include <stdio.h>
#if defined(__sparc) || defined(__sparcv9)
extern void flush_windows(void);
#define UMEM_FRAMESIZE MINFRAME
#elif defined(__i386) || defined(__amd64)
/*
* On x86, MINFRAME is defined to be 0, but we want to be sure we can
* dereference the entire frame structure.
*/
#define UMEM_FRAMESIZE (sizeof (struct frame))
#else
#error needs update for new architecture
#endif
/*
* Get a pc-only stacktrace. Used for kmem_alloc() buffer ownership tracking.
* Returns MIN(current stack depth, pcstack_limit).
*/
/*ARGSUSED*/
int
getpcstack(uintptr_t *pcstack, int pcstack_limit, int check_signal)
{
struct frame *fp;
struct frame *nextfp, *minfp;
int depth = 0;
uintptr_t base = 0;
size_t size = 0;
#ifndef UMEM_STANDALONE
int on_altstack = 0;
uintptr_t sigbase = 0;
size_t sigsize = 0;
stack_t st;
if (stack_getbounds(&st) != 0) {
if (thr_stksegment(&st) != 0 ||
(uintptr_t)st.ss_sp < st.ss_size) {
return (0); /* unable to get stack bounds */
}
/*
* thr_stksegment(3C) has a slightly different interface than
* stack_getbounds(3C) -- correct it
*/
st.ss_sp = (void *)(((uintptr_t)st.ss_sp) - st.ss_size);
st.ss_flags = 0; /* can't be on-stack */
}
on_altstack = (st.ss_flags & SS_ONSTACK);
if (st.ss_size != 0) {
base = (uintptr_t)st.ss_sp;
size = st.ss_size;
} else {
/*
* If size == 0, then ss_sp is the *top* of the stack.
*
* Since we only allow increasing frame pointers, and we
* know our caller set his up correctly, we can treat ss_sp
* as an upper bound safely.
*/
base = 0;
size = (uintptr_t)st.ss_sp;
}
if (check_signal != 0) {
void (*sigfunc)() = NULL;
int sigfuncsize = 0;
extern void thr_sighndlrinfo(void (**)(), int *);
thr_sighndlrinfo(&sigfunc, &sigfuncsize);
sigbase = (uintptr_t)sigfunc;
sigsize = sigfuncsize;
}
#else /* UMEM_STANDALONE */
base = (uintptr_t)umem_min_stack;
size = umem_max_stack - umem_min_stack;
#endif
/*
* shorten size so that fr_savfp and fr_savpc will be within the stack
* bounds.
*/
if (size >= UMEM_FRAMESIZE - 1)
size -= (UMEM_FRAMESIZE - 1);
else
size = 0;
#if defined(__sparc) || defined(__sparcv9)
flush_windows();
#endif
/* LINTED alignment */
fp = (struct frame *)((caddr_t)getfp() + STACK_BIAS);
minfp = fp;
if (((uintptr_t)fp - base) >= size)
return (0); /* the frame pointer isn't in our stack */
while (depth < pcstack_limit) {
uintptr_t tmp;
/* LINTED alignment */
nextfp = (struct frame *)((caddr_t)fp->fr_savfp + STACK_BIAS);
tmp = (uintptr_t)nextfp;
/*
* Check nextfp for validity. It must be properly aligned,
* increasing compared to the last %fp (or the top of the
* stack we just switched to), and it must be inside
* [base, base + size).
*/
if (tmp != SA(tmp))
break;
else if (nextfp <= minfp || (tmp - base) >= size) {
#ifndef UMEM_STANDALONE
if (tmp == NULL || !on_altstack)
break;
/*
* If we're on an alternate signal stack, try jumping
* to the main thread stack.
*
* If the main thread stack has an unlimited size, we
* punt, since we don't know where the frame pointer's
* been.
*
* (thr_stksegment() returns the *top of stack*
* in ss_sp, not the bottom)
*/
if (thr_stksegment(&st) == 0) {
if (st.ss_size >= (uintptr_t)st.ss_sp ||
st.ss_size < UMEM_FRAMESIZE - 1)
break;
on_altstack = 0;
base = (uintptr_t)st.ss_sp - st.ss_size;
size = st.ss_size - (UMEM_FRAMESIZE - 1);
minfp = (struct frame *)base;
continue; /* try again */
}
#endif
break;
}
#ifndef UMEM_STANDALONE
if (check_signal && (fp->fr_savpc - sigbase) <= sigsize)
umem_panic("called from signal handler");
#endif
pcstack[depth++] = fp->fr_savpc;
fp = nextfp;
minfp = fp;
}
return (depth);
}

141
zfs/lib/libumem/include/misc.h
View File

@ -1,141 +0,0 @@
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (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 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#ifndef _MISC_H
#define _MISC_H
#pragma ident "%Z%%M% %I% %E% SMI"
#include <sys/types.h>
#include <sys/time.h>
#include <thread.h>
#include <pthread.h>
#include <stdarg.h>
#ifdef __cplusplus
extern "C" {
#endif
extern uint_t umem_abort; /* abort when errors occur */
extern uint_t umem_output; /* output error messages to stderr */
extern caddr_t umem_min_stack; /* max stack address for audit log */
extern caddr_t umem_max_stack; /* min stack address for audit log */
/*
* various utility functions
* These are globally implemented.
*/
#undef offsetof
#define offsetof(s, m) ((size_t)(&(((s *)0)->m)))
/*
* a safe printf -- do not use for error messages.
*/
void debug_printf(const char *format, ...);
/*
* adds a message to the log without writing it out.
*/
void log_message(const char *format, ...);
/*
* returns the index of the (high/low) bit + 1
*/
int highbit(ulong_t);
int lowbit(ulong_t);
#pragma no_side_effect(highbit, lowbit)
/*
* Converts a hrtime_t to a timestruc_t
*/
void hrt2ts(hrtime_t hrt, timestruc_t *tsp);
/*
* tries to print out the symbol and offset of a pointer using umem_error_info
*/
int print_sym(void *pointer);
/*
* Information about the current error. Can be called multiple times, should
* be followed eventually with a call to umem_err or umem_err_recoverable.
*/
void umem_printf(const char *format, ...);
void umem_vprintf(const char *format, va_list);
void umem_printf_warn(void *ignored, const char *format, ...);
void umem_error_enter(const char *);
/*
* prints error message and stack trace, then aborts. Cannot return.
*/
void umem_panic(const char *format, ...) __NORETURN;
#pragma does_not_return(umem_panic)
#pragma rarely_called(umem_panic)
/*
* like umem_err, but only aborts if umem_abort > 0
*/
void umem_err_recoverable(const char *format, ...);
/*
* We define our own assertion handling since libc's assert() calls malloc()
*/
#ifdef NDEBUG
#define ASSERT(assertion) (void)0
#else
#define ASSERT(assertion) (void)((assertion) || \
__umem_assert_failed(#assertion, __FILE__, __LINE__))
#endif
int __umem_assert_failed(const char *assertion, const char *file, int line);
#pragma does_not_return(__umem_assert_failed)
#pragma rarely_called(__umem_assert_failed)
/*
* These have architecture-specific implementations.
*/
/*
* Returns the current function's frame pointer.
*/
extern void *getfp(void);
/*
* puts a pc-only stack trace of up to pcstack_limit frames into pcstack.
* Returns the number of stacks written.
*
* if check_sighandler != 0, and we are in a signal context, calls
* umem_err_recoverable.
*/
extern int getpcstack(uintptr_t *pcstack, int pcstack_limit,
int check_sighandler);
#ifdef __cplusplus
}
#endif
#endif /* _MISC_H */

145
zfs/lib/libumem/include/sys/vmem.h
View File

@ -1,145 +0,0 @@
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (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 2007 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#ifndef _SYS_VMEM_H
#define _SYS_VMEM_H
#pragma ident "%Z%%M% %I% %E% SMI"
#include <sys/types.h>
#ifdef __cplusplus
extern "C" {
#endif
/*
* Per-allocation flags
*/
#define VM_SLEEP 0x00000000 /* same as KM_SLEEP */
#define VM_NOSLEEP 0x00000001 /* same as KM_NOSLEEP */
#define VM_PANIC 0x00000002 /* same as KM_PANIC */
#define VM_PUSHPAGE 0x00000004 /* same as KM_PUSHPAGE */
#define VM_KMFLAGS 0x000000ff /* flags that must match KM_* flags */
#define VM_BESTFIT 0x00000100
#define VM_FIRSTFIT 0x00000200
#define VM_NEXTFIT 0x00000400
/*
* The following flags are restricted for use only within the kernel.
* VM_MEMLOAD is for use by the HAT to avoid infinite recursion.
* VM_NORELOC is used by the kernel when static VA->PA mappings are required.
*/
#define VM_MEMLOAD 0x00000800
#define VM_NORELOC 0x00001000
/*
* VM_ABORT requests that vmem_alloc() *ignore* the VM_SLEEP/VM_NOSLEEP flags
* and forgo reaping if the allocation or attempted import, fails. This
* flag is a segkmem-specific flag, and should not be used by anyone else.
*/
#define VM_ABORT 0x00002000
#define VM_FLAGS 0x0000FFFF
/*
* Arena creation flags
*/
#define VMC_POPULATOR 0x00010000
#define VMC_NO_QCACHE 0x00020000 /* cannot use quantum caches */
#define VMC_IDENTIFIER 0x00040000 /* not backed by memory */
/*
* internal use only; the import function uses the vmem_ximport_t interface
* and may increase the request size if it so desires.
* VMC_XALIGN, for use with vmem_xcreate, specifies that
* the address returned by the import function will be
* aligned according to the alignment argument.
*/
#define VMC_XALLOC 0x00080000
#define VMC_XALIGN 0x00100000
#define VMC_FLAGS 0xFFFF0000
/*
* Public segment types
*/
#define VMEM_ALLOC 0x01
#define VMEM_FREE 0x02
/*
* Implementation-private segment types
*/
#define VMEM_SPAN 0x10
#define VMEM_ROTOR 0x20
#define VMEM_WALKER 0x40
/*
* VMEM_REENTRANT indicates to vmem_walk() that the callback routine may
* call back into the arena being walked, so vmem_walk() must drop the
* arena lock before each callback. The caveat is that since the arena
* isn't locked, its state can change. Therefore it is up to the callback
* routine to handle cases where the segment isn't of the expected type.
* For example, we use this to walk heap_arena when generating a crash dump;
* see segkmem_dump() for sample usage.
*/
#define VMEM_REENTRANT 0x80000000
typedef struct vmem vmem_t;
typedef void *(vmem_alloc_t)(vmem_t *, size_t, int);
typedef void (vmem_free_t)(vmem_t *, void *, size_t);
/*
* Alternate import style; the requested size is passed in a pointer,
* which can be increased by the import function if desired.
*/
typedef void *(vmem_ximport_t)(vmem_t *, size_t *, size_t, int);
#ifdef _KERNEL
extern vmem_t *vmem_init(const char *, void *, size_t, size_t,
vmem_alloc_t *, vmem_free_t *);
extern void vmem_update(void *);
extern int vmem_is_populator();
extern size_t vmem_seg_size;
#endif
extern vmem_t *vmem_create(const char *, void *, size_t, size_t,
vmem_alloc_t *, vmem_free_t *, vmem_t *, size_t, int);
extern vmem_t *vmem_xcreate(const char *, void *, size_t, size_t,
vmem_ximport_t *, vmem_free_t *, vmem_t *, size_t, int);
extern void vmem_destroy(vmem_t *);
extern void *vmem_alloc(vmem_t *, size_t, int);
extern void *vmem_xalloc(vmem_t *, size_t, size_t, size_t, size_t,
void *, void *, int);
extern void vmem_free(vmem_t *, void *, size_t);
extern void vmem_xfree(vmem_t *, void *, size_t);
extern void *vmem_add(vmem_t *, void *, size_t, int);
extern int vmem_contains(vmem_t *, void *, size_t);
extern void vmem_walk(vmem_t *, int, void (*)(void *, void *, size_t), void *);
extern size_t vmem_size(vmem_t *, int);
#ifdef __cplusplus
}
#endif
#endif /* _SYS_VMEM_H */

152
zfs/lib/libumem/include/sys/vmem_impl_user.h
View File

@ -1,152 +0,0 @@
/*
* 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 1999-2002 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#ifndef _SYS_VMEM_IMPL_USER_H
#define _SYS_VMEM_IMPL_USER_H
#pragma ident "%Z%%M% %I% %E% SMI"
#include <sys/kstat.h>
#include <sys/time.h>
#include <sys/vmem.h>
#include <thread.h>
#include <synch.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef struct vmem_seg vmem_seg_t;
#define VMEM_STACK_DEPTH 20
struct vmem_seg {
/*
* The first four fields must match vmem_freelist_t exactly.
*/
uintptr_t vs_start; /* start of segment (inclusive) */
uintptr_t vs_end; /* end of segment (exclusive) */
vmem_seg_t *vs_knext; /* next of kin (alloc, free, span) */
vmem_seg_t *vs_kprev; /* prev of kin */
vmem_seg_t *vs_anext; /* next in arena */
vmem_seg_t *vs_aprev; /* prev in arena */
uint8_t vs_type; /* alloc, free, span */
uint8_t vs_import; /* non-zero if segment was imported */
uint8_t vs_depth; /* stack depth if UMF_AUDIT active */
/*
* The following fields are present only when UMF_AUDIT is set.
*/
thread_t vs_thread;
hrtime_t vs_timestamp;
uintptr_t vs_stack[VMEM_STACK_DEPTH];
};
typedef struct vmem_freelist {
uintptr_t vs_start; /* always zero */
uintptr_t vs_end; /* segment size */
vmem_seg_t *vs_knext; /* next of kin */
vmem_seg_t *vs_kprev; /* prev of kin */
} vmem_freelist_t;
#define VS_SIZE(vsp) ((vsp)->vs_end - (vsp)->vs_start)
/*
* Segment hashing
*/
#define VMEM_HASH_INDEX(a, s, q, m) \
((((a) + ((a) >> (s)) + ((a) >> ((s) << 1))) >> (q)) & (m))
#define VMEM_HASH(vmp, addr) \
(&(vmp)->vm_hash_table[VMEM_HASH_INDEX(addr, \
(vmp)->vm_hash_shift, (vmp)->vm_qshift, (vmp)->vm_hash_mask)])
#define VMEM_NAMELEN 30
#define VMEM_HASH_INITIAL 16
#define VMEM_NQCACHE_MAX 16
#define VMEM_FREELISTS (sizeof (void *) * 8)
typedef struct vmem_kstat {
uint64_t vk_mem_inuse; /* memory in use */
uint64_t vk_mem_import; /* memory imported */
uint64_t vk_mem_total; /* total memory in arena */
uint32_t vk_source_id; /* vmem id of vmem source */
uint64_t vk_alloc; /* number of allocations */
uint64_t vk_free; /* number of frees */
uint64_t vk_wait; /* number of allocations that waited */
uint64_t vk_fail; /* number of allocations that failed */
uint64_t vk_lookup; /* hash lookup count */
uint64_t vk_search; /* freelist search count */
uint64_t vk_populate_wait; /* populates that waited */
uint64_t vk_populate_fail; /* populates that failed */
uint64_t vk_contains; /* vmem_contains() calls */
uint64_t vk_contains_search; /* vmem_contains() search cnt */
} vmem_kstat_t;
struct vmem {
char vm_name[VMEM_NAMELEN]; /* arena name */
cond_t vm_cv; /* cv for blocking allocations */
mutex_t vm_lock; /* arena lock */
uint32_t vm_id; /* vmem id */
uint32_t vm_mtbf; /* induced alloc failure rate */
int vm_cflags; /* arena creation flags */
int vm_qshift; /* log2(vm_quantum) */
size_t vm_quantum; /* vmem quantum */
size_t vm_qcache_max; /* maximum size to front by umem */
vmem_alloc_t *vm_source_alloc;
vmem_free_t *vm_source_free;
vmem_t *vm_source; /* vmem source for imported memory */
vmem_t *vm_next; /* next in vmem_list */
ssize_t vm_nsegfree; /* number of free vmem_seg_t's */
vmem_seg_t *vm_segfree; /* free vmem_seg_t list */
vmem_seg_t **vm_hash_table; /* allocated-segment hash table */
size_t vm_hash_mask; /* hash_size - 1 */
size_t vm_hash_shift; /* log2(vm_hash_mask + 1) */
ulong_t vm_freemap; /* bitmap of non-empty freelists */
vmem_seg_t vm_seg0; /* anchor segment */
vmem_seg_t vm_rotor; /* rotor for VM_NEXTFIT allocations */
vmem_seg_t *vm_hash0[VMEM_HASH_INITIAL]; /* initial hash table */
void *vm_qcache[VMEM_NQCACHE_MAX]; /* quantum caches */
vmem_freelist_t vm_freelist[VMEM_FREELISTS + 1]; /* power-of-2 flists */
vmem_kstat_t vm_kstat; /* kstat data */
};
/*
* We cannot use a mutex_t and MUTEX_HELD, since that will not work
* when libthread is not linked.
*/
typedef struct vmem_populate_lock {
mutex_t vmpl_mutex;
thread_t vmpl_thr;
} vmem_populate_lock_t;
#define VM_UMFLAGS VM_KMFLAGS
#ifdef __cplusplus
}
#endif
#endif /* _SYS_VMEM_IMPL_USER_H */

86
zfs/lib/libumem/include/umem.h
View File

@ -1,86 +0,0 @@
/*
* 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.
*/
#ifndef _UMEM_H
#define _UMEM_H
#pragma ident "%Z%%M% %I% %E% SMI"
#include <sys/types.h>
#include <sys/vmem.h>
#include <stdlib.h>
#ifdef __cplusplus
extern "C" {
#endif
#define UMEM_DEFAULT 0x0000 /* normal -- may fail */
#define UMEM_NOFAIL 0x0100 /* Never fails -- may call exit(2) */
#define UMEM_FLAGS 0xffff /* all settable umem flags */
extern void *umem_alloc(size_t, int);
extern void *umem_alloc_align(size_t, size_t, int);
extern void *umem_zalloc(size_t, int);
extern void umem_free(void *, size_t);
extern void umem_free_align(void *, size_t);
/*
* Flags for umem_cache_create()
*/
#define UMC_NOTOUCH 0x00010000
#define UMC_NODEBUG 0x00020000
#define UMC_NOMAGAZINE 0x00040000
#define UMC_NOHASH 0x00080000
struct umem_cache; /* cache structure is opaque to umem clients */
typedef struct umem_cache umem_cache_t;
typedef int umem_constructor_t(void *, void *, int);
typedef void umem_destructor_t(void *, void *);
typedef void umem_reclaim_t(void *);
typedef int umem_nofail_callback_t(void);
#define UMEM_CALLBACK_RETRY 0
#define UMEM_CALLBACK_EXIT(status) (0x100 | ((status) & 0xFF))
extern void umem_nofail_callback(umem_nofail_callback_t *);
extern umem_cache_t *umem_cache_create(char *, size_t,
size_t, umem_constructor_t *, umem_destructor_t *, umem_reclaim_t *,
void *, vmem_t *, int);
extern void umem_cache_destroy(umem_cache_t *);
extern void *umem_cache_alloc(umem_cache_t *, int);
extern void umem_cache_free(umem_cache_t *, void *);
extern void umem_reap(void);
#ifdef __cplusplus
}
#endif
#endif /* _UMEM_H */

146
zfs/lib/libumem/include/umem_base.h
View File

@ -1,146 +0,0 @@
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (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 2006 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#ifndef _UMEM_BASE_H
#define _UMEM_BASE_H
#pragma ident "%Z%%M% %I% %E% SMI"
#include <umem_impl.h>
#ifdef __cplusplus
extern "C" {
#endif
#include "misc.h"
extern size_t pagesize;
#undef PAGESIZE
#define PAGESIZE pagesize
/*
* umem.c: non-tunables
*/
extern vmem_t *umem_memalign_arena;
extern int umem_ready;
extern thread_t umem_init_thr; /* the thread doing the init */
extern int umem_init(void); /* do umem's initialization */
#pragma rarely_called(umem_init)
extern umem_log_header_t *umem_transaction_log;
extern umem_log_header_t *umem_content_log;
extern umem_log_header_t *umem_failure_log;
extern umem_log_header_t *umem_slab_log;
extern mutex_t umem_init_lock;
extern mutex_t umem_cache_lock;
extern umem_cache_t umem_null_cache;
extern mutex_t umem_flags_lock;
extern mutex_t umem_update_lock;
extern cond_t umem_update_cv;
extern volatile thread_t umem_st_update_thr;
extern thread_t umem_update_thr;
extern struct timeval umem_update_next;
extern volatile hrtime_t umem_reap_next;
extern volatile uint32_t umem_reaping;
#define UMEM_REAP_DONE 0x00000000 /* inactive */
#define UMEM_REAP_ADDING 0x00000001 /* umem_reap() is active */
#define UMEM_REAP_ACTIVE 0x00000002 /* update thread is reaping */
/*
* umem.c: tunables
*/
extern uint32_t umem_max_ncpus;
extern uint32_t umem_stack_depth;
extern uint32_t umem_reap_interval;
extern uint32_t umem_update_interval;
extern uint32_t umem_depot_contention;
extern uint32_t umem_abort;
extern uint32_t umem_output;
extern uint32_t umem_logging;
extern uint32_t umem_mtbf;
extern size_t umem_transaction_log_size;
extern size_t umem_content_log_size;
extern size_t umem_failure_log_size;
extern size_t umem_slab_log_size;
extern size_t umem_content_maxsave;
extern size_t umem_lite_minsize;
extern size_t umem_lite_maxalign;
extern size_t umem_maxverify;
extern size_t umem_minfirewall;
extern uint32_t umem_flags;
/*
* umem.c: Internal aliases (to avoid PLTs)
*/
extern void *_umem_alloc(size_t size, int umflags);
extern void *_umem_zalloc(size_t size, int umflags);
extern void _umem_free(void *buf, size_t size);
extern void *_umem_cache_alloc(umem_cache_t *cache, int flags);
extern void _umem_cache_free(umem_cache_t *cache, void *buffer);
/*
* umem.c: private interfaces
*/
extern void umem_type_init(caddr_t, size_t, size_t);
extern int umem_get_max_ncpus(void);
extern void umem_process_updates(void);
extern void umem_cache_applyall(void (*)(umem_cache_t *));
extern void umem_cache_update(umem_cache_t *);
extern void umem_alloc_sizes_add(size_t);
extern void umem_alloc_sizes_clear(void);
extern void umem_alloc_sizes_remove(size_t);
/*
* umem_fork.c: private interfaces
*/
extern void umem_forkhandler_init(void);
/*
* umem_update_thread.c
*/
extern int umem_create_update_thread(void);
/*
* envvar.c:
*/
void umem_setup_envvars(int);
void umem_process_envvars(void);
#ifdef __cplusplus
}
#endif
#endif /* _UMEM_BASE_H */

403
zfs/lib/libumem/include/umem_impl.h
View File

@ -1,403 +0,0 @@
/*
* 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.
*/
#ifndef _UMEM_IMPL_H
#define _UMEM_IMPL_H
#pragma ident "%Z%%M% %I% %E% SMI"
#include <umem.h>
#include <sys/sysmacros.h>
#include <sys/time.h>
#include <sys/vmem.h>
#include <thread.h>
#ifdef __cplusplus
extern "C" {
#endif
/*
* umem memory allocator: implementation-private data structures
*/
/*
* Internal flags for umem_cache_create
*/
#define UMC_QCACHE 0x00100000
#define UMC_INTERNAL 0x80000000
/*
* Cache flags
*/
#define UMF_AUDIT 0x00000001 /* transaction auditing */
#define UMF_DEADBEEF 0x00000002 /* deadbeef checking */
#define UMF_REDZONE 0x00000004 /* redzone checking */
#define UMF_CONTENTS 0x00000008 /* freed-buffer content logging */
#define UMF_CHECKSIGNAL 0x00000010 /* abort when in signal context */
#define UMF_NOMAGAZINE 0x00000020 /* disable per-cpu magazines */
#define UMF_FIREWALL 0x00000040 /* put all bufs before unmapped pages */
#define UMF_LITE 0x00000100 /* lightweight debugging */
#define UMF_HASH 0x00000200 /* cache has hash table */
#define UMF_RANDOMIZE 0x00000400 /* randomize other umem_flags */
#define UMF_BUFTAG (UMF_DEADBEEF | UMF_REDZONE)
#define UMF_TOUCH (UMF_BUFTAG | UMF_LITE | UMF_CONTENTS)
#define UMF_RANDOM (UMF_TOUCH | UMF_AUDIT | UMF_NOMAGAZINE)
#define UMF_DEBUG (UMF_RANDOM | UMF_FIREWALL)
#define UMEM_STACK_DEPTH umem_stack_depth
#define UMEM_FREE_PATTERN 0xdeadbeefdeadbeefULL
#define UMEM_UNINITIALIZED_PATTERN 0xbaddcafebaddcafeULL
#define UMEM_REDZONE_PATTERN 0xfeedfacefeedfaceULL
#define UMEM_REDZONE_BYTE 0xbb
#define UMEM_FATAL_FLAGS (UMEM_NOFAIL)
#define UMEM_SLEEP_FLAGS (0)
/*
* Redzone size encodings for umem_alloc() / umem_free(). We encode the
* allocation size, rather than storing it directly, so that umem_free()
* can distinguish frees of the wrong size from redzone violations.
*/
#define UMEM_SIZE_ENCODE(x) (251 * (x) + 1)
#define UMEM_SIZE_DECODE(x) ((x) / 251)
#define UMEM_SIZE_VALID(x) ((x) % 251 == 1)
/*
* The bufctl (buffer control) structure keeps some minimal information
* about each buffer: its address, its slab, and its current linkage,
* which is either on the slab's freelist (if the buffer is free), or
* on the cache's buf-to-bufctl hash table (if the buffer is allocated).
* In the case of non-hashed, or "raw", caches (the common case), only
* the freelist linkage is necessary: the buffer address is at a fixed
* offset from the bufctl address, and the slab is at the end of the page.
*
* NOTE: bc_next must be the first field; raw buffers have linkage only.
*/
typedef struct umem_bufctl {
struct umem_bufctl *bc_next; /* next bufctl struct */
void *bc_addr; /* address of buffer */
struct umem_slab *bc_slab; /* controlling slab */
} umem_bufctl_t;
/*
* The UMF_AUDIT version of the bufctl structure. The beginning of this
* structure must be identical to the normal bufctl structure so that
* pointers are interchangeable.
*/
#define UMEM_BUFCTL_AUDIT_SIZE_DEPTH(frames) \
((size_t)(&((umem_bufctl_audit_t *)0)->bc_stack[frames]))
/*
* umem_bufctl_audits must be allocated from a UMC_NOHASH cache, so we
* require that 2 of them, plus 2 buftags, plus a umem_slab_t, all fit on
* a single page.
*
* For ILP32, this is about 1000 frames.
* For LP64, this is about 490 frames.
*/
#define UMEM_BUFCTL_AUDIT_ALIGN 32
#define UMEM_BUFCTL_AUDIT_MAX_SIZE \
(P2ALIGN((PAGESIZE - sizeof (umem_slab_t))/2 - \
sizeof (umem_buftag_t), UMEM_BUFCTL_AUDIT_ALIGN))
#define UMEM_MAX_STACK_DEPTH \
((UMEM_BUFCTL_AUDIT_MAX_SIZE - \
UMEM_BUFCTL_AUDIT_SIZE_DEPTH(0)) / sizeof (uintptr_t))
typedef struct umem_bufctl_audit {
struct umem_bufctl *bc_next; /* next bufctl struct */
void *bc_addr; /* address of buffer */
struct umem_slab *bc_slab; /* controlling slab */
umem_cache_t *bc_cache; /* controlling cache */
hrtime_t bc_timestamp; /* transaction time */
thread_t bc_thread; /* thread doing transaction */
struct umem_bufctl *bc_lastlog; /* last log entry */
void *bc_contents; /* contents at last free */
int bc_depth; /* stack depth */
uintptr_t bc_stack[1]; /* pc stack */
} umem_bufctl_audit_t;
#define UMEM_LOCAL_BUFCTL_AUDIT(bcpp) \
*(bcpp) = (umem_bufctl_audit_t *) \
alloca(UMEM_BUFCTL_AUDIT_SIZE)
#define UMEM_BUFCTL_AUDIT_SIZE \
UMEM_BUFCTL_AUDIT_SIZE_DEPTH(UMEM_STACK_DEPTH)
/*
* A umem_buftag structure is appended to each buffer whenever any of the
* UMF_BUFTAG flags (UMF_DEADBEEF, UMF_REDZONE, UMF_VERIFY) are set.
*/
typedef struct umem_buftag {
uint64_t bt_redzone; /* 64-bit redzone pattern */
umem_bufctl_t *bt_bufctl; /* bufctl */
intptr_t bt_bxstat; /* bufctl ^ (alloc/free) */
} umem_buftag_t;
#define UMEM_BUFTAG(cp, buf) \
((umem_buftag_t *)((char *)(buf) + (cp)->cache_buftag))
#define UMEM_BUFCTL(cp, buf) \
((umem_bufctl_t *)((char *)(buf) + (cp)->cache_bufctl))
#define UMEM_BUF(cp, bcp) \
((void *)((char *)(bcp) - (cp)->cache_bufctl))
#define UMEM_SLAB(cp, buf) \
((umem_slab_t *)P2END((uintptr_t)(buf), (cp)->cache_slabsize) - 1)
#define UMEM_CPU_CACHE(cp, cpu) \
(umem_cpu_cache_t *)((char *)cp + cpu->cpu_cache_offset)
#define UMEM_MAGAZINE_VALID(cp, mp) \
(((umem_slab_t *)P2END((uintptr_t)(mp), PAGESIZE) - 1)->slab_cache == \
(cp)->cache_magtype->mt_cache)
#define UMEM_SLAB_MEMBER(sp, buf) \
((size_t)(buf) - (size_t)(sp)->slab_base < \
(sp)->slab_cache->cache_slabsize)
#define UMEM_BUFTAG_ALLOC 0xa110c8edUL
#define UMEM_BUFTAG_FREE 0xf4eef4eeUL
typedef struct umem_slab {
struct umem_cache *slab_cache; /* controlling cache */
void *slab_base; /* base of allocated memory */
struct umem_slab *slab_next; /* next slab on freelist */
struct umem_slab *slab_prev; /* prev slab on freelist */
struct umem_bufctl *slab_head; /* first free buffer */
long slab_refcnt; /* outstanding allocations */
long slab_chunks; /* chunks (bufs) in this slab */
} umem_slab_t;
#define UMEM_HASH_INITIAL 64
#define UMEM_HASH(cp, buf) \
((cp)->cache_hash_table + \
(((uintptr_t)(buf) >> (cp)->cache_hash_shift) & (cp)->cache_hash_mask))
typedef struct umem_magazine {
void *mag_next;
void *mag_round[1]; /* one or more rounds */
} umem_magazine_t;
/*
* The magazine types for fast per-cpu allocation
*/
typedef struct umem_magtype {
int mt_magsize; /* magazine size (number of rounds) */
int mt_align; /* magazine alignment */
size_t mt_minbuf; /* all smaller buffers qualify */
size_t mt_maxbuf; /* no larger buffers qualify */
umem_cache_t *mt_cache; /* magazine cache */
} umem_magtype_t;
#define UMEM_CPU_CACHE_SIZE 64 /* must be power of 2 */
#define UMEM_CPU_PAD (UMEM_CPU_CACHE_SIZE - sizeof (mutex_t) - \
2 * sizeof (uint_t) - 2 * sizeof (void *) - 4 * sizeof (int))
#define UMEM_CACHE_SIZE(ncpus) \
((size_t)(&((umem_cache_t *)0)->cache_cpu[ncpus]))
typedef struct umem_cpu_cache {
mutex_t cc_lock; /* protects this cpu's local cache */
uint_t cc_alloc; /* allocations from this cpu */
uint_t cc_free; /* frees to this cpu */
umem_magazine_t *cc_loaded; /* the currently loaded magazine */
umem_magazine_t *cc_ploaded; /* the previously loaded magazine */
int cc_rounds; /* number of objects in loaded mag */
int cc_prounds; /* number of objects in previous mag */
int cc_magsize; /* number of rounds in a full mag */
int cc_flags; /* CPU-local copy of cache_flags */
#ifndef _LP64
char cc_pad[UMEM_CPU_PAD]; /* for nice alignment (32-bit) */
#endif
} umem_cpu_cache_t;
/*
* The magazine lists used in the depot.
*/
typedef struct umem_maglist {
umem_magazine_t *ml_list; /* magazine list */
long ml_total; /* number of magazines */
long ml_min; /* min since last update */
long ml_reaplimit; /* max reapable magazines */
uint64_t ml_alloc; /* allocations from this list */
} umem_maglist_t;
#define UMEM_CACHE_NAMELEN 31
struct umem_cache {
/*
* Statistics
*/
uint64_t cache_slab_create; /* slab creates */
uint64_t cache_slab_destroy; /* slab destroys */
uint64_t cache_slab_alloc; /* slab layer allocations */
uint64_t cache_slab_free; /* slab layer frees */
uint64_t cache_alloc_fail; /* total failed allocations */
uint64_t cache_buftotal; /* total buffers */
uint64_t cache_bufmax; /* max buffers ever */
uint64_t cache_rescale; /* # of hash table rescales */
uint64_t cache_lookup_depth; /* hash lookup depth */
uint64_t cache_depot_contention; /* mutex contention count */
uint64_t cache_depot_contention_prev; /* previous snapshot */
/*
* Cache properties
*/
char cache_name[UMEM_CACHE_NAMELEN + 1];
size_t cache_bufsize; /* object size */
size_t cache_align; /* object alignment */
umem_constructor_t *cache_constructor;
umem_destructor_t *cache_destructor;
umem_reclaim_t *cache_reclaim;
void *cache_private; /* opaque arg to callbacks */
vmem_t *cache_arena; /* vmem source for slabs */
int cache_cflags; /* cache creation flags */
int cache_flags; /* various cache state info */
int cache_uflags; /* UMU_* flags */
uint32_t cache_mtbf; /* induced alloc failure rate */
umem_cache_t *cache_next; /* forward cache linkage */
umem_cache_t *cache_prev; /* backward cache linkage */
umem_cache_t *cache_unext; /* next in update list */
umem_cache_t *cache_uprev; /* prev in update list */
uint32_t cache_cpu_mask; /* mask for cpu offset */
/*
* Slab layer
*/
mutex_t cache_lock; /* protects slab layer */
size_t cache_chunksize; /* buf + alignment [+ debug] */
size_t cache_slabsize; /* size of a slab */
size_t cache_bufctl; /* buf-to-bufctl distance */
size_t cache_buftag; /* buf-to-buftag distance */
size_t cache_verify; /* bytes to verify */
size_t cache_contents; /* bytes of saved content */
size_t cache_color; /* next slab color */
size_t cache_mincolor; /* maximum slab color */
size_t cache_maxcolor; /* maximum slab color */
size_t cache_hash_shift; /* get to interesting bits */
size_t cache_hash_mask; /* hash table mask */
umem_slab_t *cache_freelist; /* slab free list */
umem_slab_t cache_nullslab; /* end of freelist marker */
umem_cache_t *cache_bufctl_cache; /* source of bufctls */
umem_bufctl_t **cache_hash_table; /* hash table base */
/*
* Depot layer
*/
mutex_t cache_depot_lock; /* protects depot */
umem_magtype_t *cache_magtype; /* magazine type */
umem_maglist_t cache_full; /* full magazines */
umem_maglist_t cache_empty; /* empty magazines */
/*
* Per-CPU layer
*/
umem_cpu_cache_t cache_cpu[1]; /* cache_cpu_mask + 1 entries */
};
typedef struct umem_cpu_log_header {
mutex_t clh_lock;
char *clh_current;
size_t clh_avail;
int clh_chunk;
int clh_hits;
char clh_pad[64 - sizeof (mutex_t) - sizeof (char *) -
sizeof (size_t) - 2 * sizeof (int)];
} umem_cpu_log_header_t;
typedef struct umem_log_header {
mutex_t lh_lock;
char *lh_base;
int *lh_free;
size_t lh_chunksize;
int lh_nchunks;
int lh_head;
int lh_tail;
int lh_hits;
umem_cpu_log_header_t lh_cpu[1]; /* actually umem_max_ncpus */
} umem_log_header_t;
typedef struct umem_cpu {
uint32_t cpu_cache_offset;
uint32_t cpu_number;
} umem_cpu_t;
#define UMEM_MAXBUF 16384
#define UMEM_ALIGN 8 /* min guaranteed alignment */
#define UMEM_ALIGN_SHIFT 3 /* log2(UMEM_ALIGN) */
#define UMEM_VOID_FRACTION 8 /* never waste more than 1/8 of slab */
/*
* For 64 bits, buffers >= 16 bytes must be 16-byte aligned
*/
#ifdef _LP64
#define UMEM_SECOND_ALIGN 16
#else
#define UMEM_SECOND_ALIGN UMEM_ALIGN
#endif
#define MALLOC_MAGIC 0x3a10c000 /* 8-byte tag */
#define MEMALIGN_MAGIC 0x3e3a1000
#ifdef _LP64
#define MALLOC_SECOND_MAGIC 0x16ba7000 /* 8-byte tag, 16-aligned */
#define MALLOC_OVERSIZE_MAGIC 0x06e47000 /* 16-byte tag, _LP64 */
#endif
#define UMEM_MALLOC_ENCODE(type, sz) (uint32_t)((type) - (sz))
#define UMEM_MALLOC_DECODE(stat, sz) (uint32_t)((stat) + (sz))
#define UMEM_FREE_PATTERN_32 (uint32_t)(UMEM_FREE_PATTERN)
#define UMU_MAGAZINE_RESIZE 0x00000001
#define UMU_HASH_RESCALE 0x00000002
#define UMU_REAP 0x00000004
#define UMU_NOTIFY 0x08000000
#define UMU_ACTIVE 0x80000000
#define UMEM_READY_INIT_FAILED -1
#define UMEM_READY_STARTUP 1
#define UMEM_READY_INITING 2
#define UMEM_READY 3
#ifdef UMEM_STANDALONE
extern void umem_startup(caddr_t, size_t, size_t, caddr_t, caddr_t);
extern int umem_add(caddr_t, size_t);
#endif
#ifdef __cplusplus
}
#endif
#endif /* _UMEM_IMPL_H */

85
zfs/lib/libumem/include/vmem_base.h
View File

@ -1,85 +0,0 @@
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (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 2006 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#ifndef _VMEM_BASE_H
#define _VMEM_BASE_H
#pragma ident "%Z%%M% %I% %E% SMI"
#include <sys/vmem.h>
#include <umem.h>
#ifdef __cplusplus
extern "C" {
#endif
#include "misc.h"
extern void vmem_startup(void);
extern vmem_t *vmem_init(const char *parent_name, size_t parent_quantum,
vmem_alloc_t *parent_alloc, vmem_free_t *parent_free,
const char *heap_name,
void *heap_start, size_t heap_size, size_t heap_quantum,
vmem_alloc_t *heap_alloc, vmem_free_t *heap_free);
extern void *_vmem_extend_alloc(vmem_t *vmp, void *vaddr, size_t size,
size_t alloc, int vmflag);
extern vmem_t *vmem_heap_arena(vmem_alloc_t **, vmem_free_t **);
extern void vmem_heap_init(void);
extern vmem_t *vmem_sbrk_arena(vmem_alloc_t **, vmem_free_t **);
extern vmem_t *vmem_mmap_arena(vmem_alloc_t **, vmem_free_t **);
extern vmem_t *vmem_stand_arena(vmem_alloc_t **, vmem_free_t **);
extern void vmem_update(void *);
extern void vmem_reap(void); /* vmem_populate()-safe reap */
extern size_t pagesize;
extern size_t vmem_sbrk_pagesize;
extern size_t vmem_sbrk_minalloc;
extern uint_t vmem_backend;
#define VMEM_BACKEND_SBRK 0x0000001
#define VMEM_BACKEND_MMAP 0x0000002
#define VMEM_BACKEND_STAND 0x0000003
extern vmem_t *vmem_heap;
extern vmem_alloc_t *vmem_heap_alloc;
extern vmem_free_t *vmem_heap_free;
extern void vmem_lockup(void);
extern void vmem_release(void);
extern void vmem_sbrk_lockup(void);
extern void vmem_sbrk_release(void);
extern void vmem_no_debug(void);
#ifdef __cplusplus
}
#endif
#endif /* _VMEM_BASE_H */

49
zfs/lib/libumem/include/vmem_stand.h
View File

@ -1,49 +0,0 @@
/*
* 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.
*/
#ifndef _VMEM_STAND_H
#define _VMEM_STAND_H
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* additional functions defined by the standalone backend
*/
#include <sys/types.h>
#ifdef __cplusplus
extern "C" {
#endif
extern void vmem_stand_init(void);
extern int vmem_stand_add(caddr_t, size_t);
#ifdef __cplusplus
}
#endif
#endif /* _VMEM_STAND_H */

71
zfs/lib/libumem/init_lib.c
View File

@ -1,71 +0,0 @@
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (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 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* Initialization routines for the library version of libumem.
*/
#include "umem_base.h"
#include "vmem_base.h"
#include <unistd.h>
#include <dlfcn.h>
void
vmem_heap_init(void)
{
void *handle = dlopen("libmapmalloc.so.1", RTLD_NOLOAD);
if (handle != NULL) {
log_message("sbrk backend disabled\n");
vmem_backend = VMEM_BACKEND_MMAP;
}
if ((vmem_backend & VMEM_BACKEND_MMAP) != 0) {
vmem_backend = VMEM_BACKEND_MMAP;
(void) vmem_mmap_arena(NULL, NULL);
} else {
vmem_backend = VMEM_BACKEND_SBRK;
(void) vmem_sbrk_arena(NULL, NULL);
}
}
/*ARGSUSED*/
void
umem_type_init(caddr_t start, size_t len, size_t pgsize)
{
pagesize = _sysconf(_SC_PAGESIZE);
}
int
umem_get_max_ncpus(void)
{
if (thr_main() != -1)
return (2 * sysconf(_SC_NPROCESSORS_ONLN));
else
return (1);
}

64
zfs/lib/libumem/init_stand.c
View File

@ -1,64 +0,0 @@
/*
* 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 "%Z%%M% %I% %E% SMI"
/*
* Initialization routines for the standalone version of libumem.
*/
#include "umem_base.h"
#include "vmem_base.h"
#include "vmem_stand.h"
void
vmem_heap_init(void)
{
vmem_backend = VMEM_BACKEND_STAND;
(void) vmem_stand_arena(NULL, NULL);
}
void
umem_type_init(caddr_t base, size_t len, size_t pgsize)
{
pagesize = pgsize;
vmem_stand_init();
(void) vmem_stand_add(base, len);
}
int
umem_get_max_ncpus(void)
{
return (1);
}
int
umem_add(caddr_t base, size_t len)
{
return (vmem_stand_add(base, len));
}

71
zfs/lib/libumem/linktest_stand.c
View File

@ -1,71 +0,0 @@
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (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 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* This file is used to verify that the standalone's external dependencies
* haven't changed in a way that'll break things that use it.
*/
void __umem_assert_failed(void) {}
void atomic_add_64(void) {}
void atomic_add_32_nv(void) {}
void dladdr1(void) {}
void bcopy(void) {}
void bzero(void) {}
void exit(void) {}
void getenv(void) {}
void gethrtime(void) {}
void membar_producer(void) {}
void memcpy(void) {}
void _memcpy(void) {}
void memset(void) {}
void snprintf(void) {}
void strchr(void) {}
void strcmp(void) {}
void strlen(void) {}
void strncpy(void) {}
void strrchr(void) {}
void strtoul(void) {}
void umem_err_recoverable(void) {}
void umem_panic(void) {}
void vsnprintf(void) {}
#ifdef __i386
void __mul64(void) {}
void __rem64(void) {}
void __div64(void) {}
#ifdef __GNUC__
void __divdi3(void) {}
void __moddi3(void) {}
#endif /* __GNUC__ */
#endif /* __i386 */
int __ctype;
int errno;

415
zfs/lib/libumem/malloc.c
View File

@ -1,415 +0,0 @@
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (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 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/sysmacros.h>
#include "umem_base.h"
#include "misc.h"
/*
* malloc_data_t is an 8-byte structure which is located "before" the pointer
* returned from {m,c,re}alloc and memalign. The first four bytes give
* information about the buffer, and the second four bytes are a status byte.
*
* See umem_impl.h for the various magic numbers used, and the size
* encode/decode macros.
*
* The 'size' of the buffer includes the tags. That is, we encode the
* argument to umem_alloc(), not the argument to malloc().
*/
typedef struct malloc_data {
uint32_t malloc_size;
uint32_t malloc_stat; /* = UMEM_MALLOC_ENCODE(state, malloc_size) */
} malloc_data_t;
void *
malloc(size_t size_arg)
{
#ifdef _LP64
uint32_t high_size = 0;
#endif
size_t size;
malloc_data_t *ret;
size = size_arg + sizeof (malloc_data_t);
#ifdef _LP64
if (size > UMEM_SECOND_ALIGN) {
size += sizeof (malloc_data_t);
high_size = (size >> 32);
}
#endif
if (size < size_arg) {
errno = ENOMEM; /* overflow */
return (NULL);
}
ret = (malloc_data_t *)_umem_alloc(size, UMEM_DEFAULT);
if (ret == NULL) {
if (size <= UMEM_MAXBUF)
errno = EAGAIN;
else
errno = ENOMEM;
return (NULL);
#ifdef _LP64
} else if (high_size > 0) {
uint32_t low_size = (uint32_t)size;
/*
* uses different magic numbers to make it harder to
* undetectably corrupt
*/
ret->malloc_size = high_size;
ret->malloc_stat = UMEM_MALLOC_ENCODE(MALLOC_MAGIC, high_size);
ret++;
ret->malloc_size = low_size;
ret->malloc_stat = UMEM_MALLOC_ENCODE(MALLOC_OVERSIZE_MAGIC,
low_size);
ret++;
} else if (size > UMEM_SECOND_ALIGN) {
uint32_t low_size = (uint32_t)size;
ret++; /* leave the first 8 bytes alone */
ret->malloc_size = low_size;
ret->malloc_stat = UMEM_MALLOC_ENCODE(MALLOC_SECOND_MAGIC,
low_size);
ret++;
#endif
} else {
ret->malloc_size = size;
ret->malloc_stat = UMEM_MALLOC_ENCODE(MALLOC_MAGIC, size);
ret++;
}
return ((void *)ret);
}
void *
calloc(size_t nelem, size_t elsize)
{
size_t size = nelem * elsize;
void *retval;
if (nelem > 0 && elsize > 0 && size/nelem != elsize) {
errno = ENOMEM; /* overflow */
return (NULL);
}
retval = malloc(size);
if (retval == NULL)
return (NULL);
(void) memset(retval, 0, size);
return (retval);
}
/*
* memalign uses vmem_xalloc to do its work.
*
* in 64-bit, the memaligned buffer always has two tags. This simplifies the
* code.
*/
void *
memalign(size_t align, size_t size_arg)
{
size_t size;
uintptr_t phase;
void *buf;
malloc_data_t *ret;
size_t overhead;
if (size_arg == 0 || align == 0 || (align & (align - 1)) != 0) {
errno = EINVAL;
return (NULL);
}
/*
* if malloc provides the required alignment, use it.
*/
if (align <= UMEM_ALIGN ||
(align <= UMEM_SECOND_ALIGN && size_arg >= UMEM_SECOND_ALIGN))
return (malloc(size_arg));
#ifdef _LP64
overhead = 2 * sizeof (malloc_data_t);
#else
overhead = sizeof (malloc_data_t);
#endif
ASSERT(overhead <= align);
size = size_arg + overhead;
phase = align - overhead;
if (umem_memalign_arena == NULL && umem_init() == 0) {
errno = ENOMEM;
return (NULL);
}
if (size < size_arg) {
errno = ENOMEM; /* overflow */
return (NULL);
}
buf = vmem_xalloc(umem_memalign_arena, size, align, phase,
0, NULL, NULL, VM_NOSLEEP);
if (buf == NULL) {
if ((size_arg + align) <= UMEM_MAXBUF)
errno = EAGAIN;
else
errno = ENOMEM;
return (NULL);
}
ret = (malloc_data_t *)buf;
{
uint32_t low_size = (uint32_t)size;
#ifdef _LP64
uint32_t high_size = (uint32_t)(size >> 32);
ret->malloc_size = high_size;
ret->malloc_stat = UMEM_MALLOC_ENCODE(MEMALIGN_MAGIC,
high_size);
ret++;
#endif
ret->malloc_size = low_size;
ret->malloc_stat = UMEM_MALLOC_ENCODE(MEMALIGN_MAGIC, low_size);
ret++;
}
ASSERT(P2PHASE((uintptr_t)ret, align) == 0);
ASSERT((void *)((uintptr_t)ret - overhead) == buf);
return ((void *)ret);
}
void *
valloc(size_t size)
{
return (memalign(pagesize, size));
}
/*
* process_free:
*
* Pulls information out of a buffer pointer, and optionally free it.
* This is used by free() and realloc() to process buffers.
*
* On failure, calls umem_err_recoverable() with an appropriate message
* On success, returns the data size through *data_size_arg, if (!is_free).
*
* Preserves errno, since free()'s semantics require it.
*/
static int
process_free(void *buf_arg,
int do_free, /* free the buffer, or just get its size? */
size_t *data_size_arg) /* output: bytes of data in buf_arg */
{
malloc_data_t *buf;
void *base;
size_t size;
size_t data_size;
const char *message;
int old_errno = errno;
buf = (malloc_data_t *)buf_arg;
buf--;
size = buf->malloc_size;
switch (UMEM_MALLOC_DECODE(buf->malloc_stat, size)) {
case MALLOC_MAGIC:
base = (void *)buf;
data_size = size - sizeof (malloc_data_t);
if (do_free)
buf->malloc_stat = UMEM_FREE_PATTERN_32;
goto process_malloc;
#ifdef _LP64
case MALLOC_SECOND_MAGIC:
base = (void *)(buf - 1);
data_size = size - 2 * sizeof (malloc_data_t);
if (do_free)
buf->malloc_stat = UMEM_FREE_PATTERN_32;
goto process_malloc;
case MALLOC_OVERSIZE_MAGIC: {
size_t high_size;
buf--;
high_size = buf->malloc_size;
if (UMEM_MALLOC_DECODE(buf->malloc_stat, high_size) !=
MALLOC_MAGIC) {
message = "invalid or corrupted buffer";
break;
}
size += high_size << 32;
base = (void *)buf;
data_size = size - 2 * sizeof (malloc_data_t);
if (do_free) {
buf->malloc_stat = UMEM_FREE_PATTERN_32;
(buf + 1)->malloc_stat = UMEM_FREE_PATTERN_32;
}
goto process_malloc;
}
#endif
case MEMALIGN_MAGIC: {
size_t overhead = sizeof (malloc_data_t);
#ifdef _LP64
size_t high_size;
overhead += sizeof (malloc_data_t);
buf--;
high_size = buf->malloc_size;
if (UMEM_MALLOC_DECODE(buf->malloc_stat, high_size) !=
MEMALIGN_MAGIC) {
message = "invalid or corrupted buffer";
break;
}
size += high_size << 32;
/*
* destroy the main tag's malloc_stat
*/
if (do_free)
(buf + 1)->malloc_stat = UMEM_FREE_PATTERN_32;
#endif
base = (void *)buf;
data_size = size - overhead;
if (do_free)
buf->malloc_stat = UMEM_FREE_PATTERN_32;
goto process_memalign;
}
default:
if (buf->malloc_stat == UMEM_FREE_PATTERN_32)
message = "double-free or invalid buffer";
else
message = "invalid or corrupted buffer";
break;
}
umem_err_recoverable("%s(%p): %s\n",
do_free? "free" : "realloc", buf_arg, message);
errno = old_errno;
return (0);
process_malloc:
if (do_free)
_umem_free(base, size);
else
*data_size_arg = data_size;
errno = old_errno;
return (1);
process_memalign:
if (do_free)
vmem_xfree(umem_memalign_arena, base, size);
else
*data_size_arg = data_size;
errno = old_errno;
return (1);
}
void
free(void *buf)
{
if (buf == NULL)
return;
/*
* Process buf, freeing it if it is not corrupt.
*/
(void) process_free(buf, 1, NULL);
}
void *
realloc(void *buf_arg, size_t newsize)
{
size_t oldsize;
void *buf;
if (buf_arg == NULL)
return (malloc(newsize));
if (newsize == 0) {
free(buf_arg);
return (NULL);
}
/*
* get the old data size without freeing the buffer
*/
if (process_free(buf_arg, 0, &oldsize) == 0) {
errno = EINVAL;
return (NULL);
}
if (newsize == oldsize) /* size didn't change */
return (buf_arg);
buf = malloc(newsize);
if (buf == NULL)
return (NULL);
(void) memcpy(buf, buf_arg, MIN(newsize, oldsize));
free(buf_arg);
return (buf);
}

275
zfs/lib/libumem/misc.c
View File

@ -1,275 +0,0 @@
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (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 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#include <unistd.h>
#include <dlfcn.h>
#include <signal.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <sys/machelf.h>
#include <umem_impl.h>
#include "misc.h"
#define UMEM_ERRFD 2 /* goes to standard error */
#define UMEM_MAX_ERROR_SIZE 4096 /* error messages are truncated to this */
/*
* This is a circular buffer for holding error messages.
* umem_error_enter appends to the buffer, adding "..." to the beginning
* if data has been lost.
*/
#define ERR_SIZE 8192 /* must be a power of 2 */
static mutex_t umem_error_lock = DEFAULTMUTEX;
static char umem_error_buffer[ERR_SIZE] = "";
static uint_t umem_error_begin = 0;
static uint_t umem_error_end = 0;
#define WRITE_AND_INC(var, value) { \
umem_error_buffer[(var)++] = (value); \
var = P2PHASE((var), ERR_SIZE); \
}
static void
umem_log_enter(const char *error_str)
{
int looped;
char c;
looped = 0;
(void) mutex_lock(&umem_error_lock);
while ((c = *error_str++) != '\0') {
WRITE_AND_INC(umem_error_end, c);
if (umem_error_end == umem_error_begin)
looped = 1;
}
umem_error_buffer[umem_error_end] = 0;
if (looped) {
uint_t idx;
umem_error_begin = P2PHASE(umem_error_end + 1, ERR_SIZE);
idx = umem_error_begin;
WRITE_AND_INC(idx, '.');
WRITE_AND_INC(idx, '.');
WRITE_AND_INC(idx, '.');
}
(void) mutex_unlock(&umem_error_lock);
}
void
umem_error_enter(const char *error_str)
{
#ifndef UMEM_STANDALONE
if (umem_output && !issetugid())
(void) write(UMEM_ERRFD, error_str, strlen(error_str));
#endif
umem_log_enter(error_str);
}
int
highbit(ulong_t i)
{
register int h = 1;
if (i == 0)
return (0);
#ifdef _LP64
if (i & 0xffffffff00000000ul) {
h += 32; i >>= 32;
}
#endif
if (i & 0xffff0000) {
h += 16; i >>= 16;
}
if (i & 0xff00) {
h += 8; i >>= 8;
}
if (i & 0xf0) {
h += 4; i >>= 4;
}
if (i & 0xc) {
h += 2; i >>= 2;
}
if (i & 0x2) {
h += 1;
}
return (h);
}
int
lowbit(ulong_t i)
{
register int h = 1;
if (i == 0)
return (0);
#ifdef _LP64
if (!(i & 0xffffffff)) {
h += 32; i >>= 32;
}
#endif
if (!(i & 0xffff)) {
h += 16; i >>= 16;
}
if (!(i & 0xff)) {
h += 8; i >>= 8;
}
if (!(i & 0xf)) {
h += 4; i >>= 4;
}
if (!(i & 0x3)) {
h += 2; i >>= 2;
}
if (!(i & 0x1)) {
h += 1;
}
return (h);
}
void
hrt2ts(hrtime_t hrt, timestruc_t *tsp)
{
tsp->tv_sec = hrt / NANOSEC;
tsp->tv_nsec = hrt % NANOSEC;
}
void
log_message(const char *format, ...)
{
char buf[UMEM_MAX_ERROR_SIZE] = "";
va_list va;
va_start(va, format);
(void) vsnprintf(buf, UMEM_MAX_ERROR_SIZE-1, format, va);
va_end(va);
#ifndef UMEM_STANDALONE
if (umem_output > 1)
(void) write(UMEM_ERRFD, buf, strlen(buf));
#endif
umem_log_enter(buf);
}
#ifndef UMEM_STANDALONE
void
debug_printf(const char *format, ...)
{
char buf[UMEM_MAX_ERROR_SIZE] = "";
va_list va;
va_start(va, format);
(void) vsnprintf(buf, UMEM_MAX_ERROR_SIZE-1, format, va);
va_end(va);
(void) write(UMEM_ERRFD, buf, strlen(buf));
}
#endif
void
umem_vprintf(const char *format, va_list va)
{
char buf[UMEM_MAX_ERROR_SIZE] = "";
(void) vsnprintf(buf, UMEM_MAX_ERROR_SIZE-1, format, va);
umem_error_enter(buf);
}
void
umem_printf(const char *format, ...)
{
va_list va;
va_start(va, format);
umem_vprintf(format, va);
va_end(va);
}
/*ARGSUSED*/
void
umem_printf_warn(void *ignored, const char *format, ...)
{
va_list va;
va_start(va, format);
umem_vprintf(format, va);
va_end(va);
}
/*
* print_sym tries to print out the symbol and offset of a pointer
*/
int
print_sym(void *pointer)
{
int result;
Dl_info sym_info;
uintptr_t end = NULL;
Sym *ext_info = NULL;
result = dladdr1(pointer, &sym_info, (void **)&ext_info,
RTLD_DL_SYMENT);
if (result != 0) {
const char *endpath;
end = (uintptr_t)sym_info.dli_saddr + ext_info->st_size;
endpath = strrchr(sym_info.dli_fname, '/');
if (endpath)
endpath++;
else
endpath = sym_info.dli_fname;
umem_printf("%s'", endpath);
}
if (result == 0 || (uintptr_t)pointer > end) {
umem_printf("?? (0x%p)", pointer);
return (0);
} else {
umem_printf("%s+0x%p", sym_info.dli_sname,
(char *)pointer - (char *)sym_info.dli_saddr);
return (1);
}
}

129
zfs/lib/libumem/stub_stand.c
View File

@ -1,129 +0,0 @@
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (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 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* Stubs for the standalone to reduce the dependence on external libraries
*/
#include <string.h>
#include "misc.h"
/*ARGSUSED*/
int
cond_init(cond_t *cvp, int type, void *arg)
{
return (0);
}
/*ARGSUSED*/
int
cond_destroy(cond_t *cvp)
{
return (0);
}
/*ARGSUSED*/
int
cond_wait(cond_t *cv, mutex_t *mutex)
{
umem_panic("attempt to wait on standumem cv %p", cv);
/*NOTREACHED*/
return (0);
}
/*ARGSUSED*/
int
cond_broadcast(cond_t *cvp)
{
return (0);
}
/*ARGSUSED*/
int
pthread_setcancelstate(int state, int *oldstate)
{
return (0);
}
thread_t
thr_self(void)
{
return ((thread_t)1);
}
static mutex_t _mp = DEFAULTMUTEX;
/*ARGSUSED*/
int
mutex_init(mutex_t *mp, int type, void *arg)
{
(void) memcpy(mp, &_mp, sizeof (mutex_t));
return (0);
}
/*ARGSUSED*/
int
mutex_destroy(mutex_t *mp)
{
return (0);
}
/*ARGSUSED*/
int
_mutex_held(mutex_t *mp)
{
return (1);
}
/*ARGSUSED*/
int
mutex_lock(mutex_t *mp)
{
return (0);
}
/*ARGSUSED*/
int
mutex_trylock(mutex_t *mp)
{
return (0);
}
/*ARGSUSED*/
int
mutex_unlock(mutex_t *mp)
{
return (0);
}
int
issetugid(void)
{
return (1);
}

3257
zfs/lib/libumem/umem.c
View File

File diff suppressed because it is too large Load Diff

43
zfs/lib/libumem/umem_agent_support.c
View File

@ -1,43 +0,0 @@
/*
* 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 2002 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#include "umem_base.h"
#define AGENT_STACK_SIZE 4096
char __umem_agent_stack_beg[AGENT_STACK_SIZE];
char *__umem_agent_stack_end = __umem_agent_stack_beg + AGENT_STACK_SIZE;
void
__umem_agent_free_bp(umem_cache_t *cp, void *buf)
{
extern void _breakpoint(void); /* inline asm */
_umem_cache_free(cp, buf);
_breakpoint();
}

146
zfs/lib/libumem/umem_fail.c
View File

@ -1,146 +0,0 @@
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (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 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* Failure routines for libumem (not standalone)
*/
#include <sys/types.h>
#include <signal.h>
#include <stdarg.h>
#include <string.h>
#include "misc.h"
static volatile int umem_exiting = 0;
#define UMEM_EXIT_ABORT 1
static mutex_t umem_exit_lock = DEFAULTMUTEX; /* protects umem_exiting */
static int
firstexit(int type)
{
if (umem_exiting)
return (0);
(void) mutex_lock(&umem_exit_lock);
if (umem_exiting) {
(void) mutex_unlock(&umem_exit_lock);
return (0);
}
umem_exiting = type;
(void) mutex_unlock(&umem_exit_lock);
return (1);
}
/*
* We can't use abort(3C), since it closes all of the standard library
* FILEs, which can call free().
*
* In addition, we can't just raise(SIGABRT), since the current handler
* might do allocation. We give them once chance, though.
*/
static void __NORETURN
umem_do_abort(void)
{
if (firstexit(UMEM_EXIT_ABORT))
(void) raise(SIGABRT);
for (;;) {
(void) signal(SIGABRT, SIG_DFL);
(void) sigrelse(SIGABRT);
(void) raise(SIGABRT);
}
}
#define SKIP_FRAMES 1 /* skip the panic frame */
#define ERR_STACK_FRAMES 128
static void
print_stacktrace(void)
{
uintptr_t cur_stack[ERR_STACK_FRAMES];
/*
* if we are in a signal context, checking for it will recurse
*/
uint_t nframes = getpcstack(cur_stack, ERR_STACK_FRAMES, 0);
uint_t idx;
if (nframes > SKIP_FRAMES) {
umem_printf("stack trace:\n");
for (idx = SKIP_FRAMES; idx < nframes; idx++) {
(void) print_sym((void *)cur_stack[idx]);
umem_printf("\n");
}
}
}
void
umem_panic(const char *format, ...)
{
va_list va;
va_start(va, format);
umem_vprintf(format, va);
va_end(va);
if (format[strlen(format)-1] != '\n')
umem_error_enter("\n");
print_stacktrace();
umem_do_abort();
}
void
umem_err_recoverable(const char *format, ...)
{
va_list va;
va_start(va, format);
umem_vprintf(format, va);
va_end(va);
if (format[strlen(format)-1] != '\n')
umem_error_enter("\n");
print_stacktrace();
if (umem_abort > 0)
umem_do_abort();
}
int
__umem_assert_failed(const char *assertion, const char *file, int line)
{
umem_panic("Assertion failed: %s, file %s, line %d\n",
assertion, file, line);
/*NOTREACHED*/
return (0);
}

223
zfs/lib/libumem/umem_fork.c
View File

@ -1,223 +0,0 @@
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (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 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#include "umem_base.h"
#include "vmem_base.h"
#include <unistd.h>
/*
* The following functions are for pre- and post-fork1(2) handling. See
* "Lock Ordering" in lib/libumem/common/umem.c for the lock ordering used.
*/
static void
umem_lockup_cache(umem_cache_t *cp)
{
int idx;
int ncpus = cp->cache_cpu_mask + 1;
for (idx = 0; idx < ncpus; idx++)
(void) mutex_lock(&cp->cache_cpu[idx].cc_lock);
(void) mutex_lock(&cp->cache_depot_lock);
(void) mutex_lock(&cp->cache_lock);
}
static void
umem_release_cache(umem_cache_t *cp)
{
int idx;
int ncpus = cp->cache_cpu_mask + 1;
(void) mutex_unlock(&cp->cache_lock);
(void) mutex_unlock(&cp->cache_depot_lock);
for (idx = 0; idx < ncpus; idx++)
(void) mutex_unlock(&cp->cache_cpu[idx].cc_lock);
}
static void
umem_lockup_log_header(umem_log_header_t *lhp)
{
int idx;
if (lhp == NULL)
return;
for (idx = 0; idx < umem_max_ncpus; idx++)
(void) mutex_lock(&lhp->lh_cpu[idx].clh_lock);
(void) mutex_lock(&lhp->lh_lock);
}
static void
umem_release_log_header(umem_log_header_t *lhp)
{
int idx;
if (lhp == NULL)
return;
(void) mutex_unlock(&lhp->lh_lock);
for (idx = 0; idx < umem_max_ncpus; idx++)
(void) mutex_unlock(&lhp->lh_cpu[idx].clh_lock);
}
static void
umem_lockup(void)
{
umem_cache_t *cp;
(void) mutex_lock(&umem_init_lock);
/*
* If another thread is busy initializing the library, we must
* wait for it to complete (by calling umem_init()) before allowing
* the fork() to proceed.
*/
if (umem_ready == UMEM_READY_INITING && umem_init_thr != thr_self()) {
(void) mutex_unlock(&umem_init_lock);
(void) umem_init();
(void) mutex_lock(&umem_init_lock);
}
vmem_lockup();
vmem_sbrk_lockup();
(void) mutex_lock(&umem_cache_lock);
(void) mutex_lock(&umem_update_lock);
(void) mutex_lock(&umem_flags_lock);
umem_lockup_cache(&umem_null_cache);
for (cp = umem_null_cache.cache_prev; cp != &umem_null_cache;
cp = cp->cache_prev)
umem_lockup_cache(cp);
umem_lockup_log_header(umem_transaction_log);
umem_lockup_log_header(umem_content_log);
umem_lockup_log_header(umem_failure_log);
umem_lockup_log_header(umem_slab_log);
(void) cond_broadcast(&umem_update_cv);
}
static void
umem_do_release(int as_child)
{
umem_cache_t *cp;
int cleanup_update = 0;
/*
* Clean up the update state if we are the child process and
* another thread was processing updates.
*/
if (as_child) {
if (umem_update_thr != thr_self()) {
umem_update_thr = 0;
cleanup_update = 1;
}
if (umem_st_update_thr != thr_self()) {
umem_st_update_thr = 0;
cleanup_update = 1;
}
}
if (cleanup_update) {
umem_reaping = UMEM_REAP_DONE;
for (cp = umem_null_cache.cache_next; cp != &umem_null_cache;
cp = cp->cache_next) {
if (cp->cache_uflags & UMU_NOTIFY)
cp->cache_uflags &= ~UMU_NOTIFY;
/*
* If the cache is active, we just re-add it to
* the update list. This will re-do any active
* updates on the cache, but that won't break
* anything.
*
* The worst that can happen is a cache has
* its magazines rescaled twice, instead of once.
*/
if (cp->cache_uflags & UMU_ACTIVE) {
umem_cache_t *cnext, *cprev;
ASSERT(cp->cache_unext == NULL &&
cp->cache_uprev == NULL);
cp->cache_uflags &= ~UMU_ACTIVE;
cp->cache_unext = cnext = &umem_null_cache;
cp->cache_uprev = cprev =
umem_null_cache.cache_uprev;
cnext->cache_uprev = cp;
cprev->cache_unext = cp;
}
}
}
umem_release_log_header(umem_slab_log);
umem_release_log_header(umem_failure_log);
umem_release_log_header(umem_content_log);
umem_release_log_header(umem_transaction_log);
for (cp = umem_null_cache.cache_next; cp != &umem_null_cache;
cp = cp->cache_next)
umem_release_cache(cp);
umem_release_cache(&umem_null_cache);
(void) mutex_unlock(&umem_flags_lock);
(void) mutex_unlock(&umem_update_lock);
(void) mutex_unlock(&umem_cache_lock);
vmem_sbrk_release();
vmem_release();
(void) mutex_unlock(&umem_init_lock);
}
static void
umem_release(void)
{
umem_do_release(0);
}
static void
umem_release_child(void)
{
umem_do_release(1);
}
void
umem_forkhandler_init(void)
{
/*
* There is no way to unregister these atfork functions,
* but we don't need to. The dynamic linker and libc take
* care of unregistering them if/when the library is unloaded.
*/
(void) pthread_atfork(umem_lockup, umem_release, umem_release_child);
}

165
zfs/lib/libumem/umem_update_thread.c
View File

@ -1,165 +0,0 @@
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (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 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#include "umem_base.h"
#include "vmem_base.h"
#include <signal.h>
/*ARGSUSED*/
static void *
umem_update_thread(void *arg)
{
struct timeval now;
int in_update = 0;
(void) mutex_lock(&umem_update_lock);
ASSERT(umem_update_thr == thr_self());
ASSERT(umem_st_update_thr == 0);
for (;;) {
umem_process_updates();
if (in_update) {
in_update = 0;
/*
* we wait until now to set the next update time
* so that the updates are self-throttling
*/
(void) gettimeofday(&umem_update_next, NULL);
umem_update_next.tv_sec += umem_reap_interval;
}
switch (umem_reaping) {
case UMEM_REAP_DONE:
case UMEM_REAP_ADDING:
break;
case UMEM_REAP_ACTIVE:
umem_reap_next = gethrtime() +
(hrtime_t)umem_reap_interval * NANOSEC;
umem_reaping = UMEM_REAP_DONE;
break;
default:
ASSERT(umem_reaping == UMEM_REAP_DONE ||
umem_reaping == UMEM_REAP_ADDING ||
umem_reaping == UMEM_REAP_ACTIVE);
break;
}
(void) gettimeofday(&now, NULL);
if (now.tv_sec > umem_update_next.tv_sec ||
(now.tv_sec == umem_update_next.tv_sec &&
now.tv_usec >= umem_update_next.tv_usec)) {
/*
* Time to run an update
*/
(void) mutex_unlock(&umem_update_lock);
vmem_update(NULL);
/*
* umem_cache_update can use umem_add_update to
* request further work. The update is not complete
* until all such work is finished.
*/
umem_cache_applyall(umem_cache_update);
(void) mutex_lock(&umem_update_lock);
in_update = 1;
continue; /* start processing immediately */
}
/*
* if there is no work to do, we wait until it is time for
* next update, or someone wakes us.
*/
if (umem_null_cache.cache_unext == &umem_null_cache) {
int cancel_state;
timespec_t abs_time;
abs_time.tv_sec = umem_update_next.tv_sec;
abs_time.tv_nsec = umem_update_next.tv_usec * 1000;
(void) pthread_setcancelstate(PTHREAD_CANCEL_DISABLE,
&cancel_state);
(void) cond_timedwait(&umem_update_cv,
&umem_update_lock, &abs_time);
(void) pthread_setcancelstate(cancel_state, NULL);
}
}
/* LINTED no return statement */
}
int
umem_create_update_thread(void)
{
sigset_t sigmask, oldmask;
thread_t newthread;
ASSERT(MUTEX_HELD(&umem_update_lock));
ASSERT(umem_update_thr == 0);
/*
* The update thread handles no signals
*/
(void) sigfillset(&sigmask);
(void) thr_sigsetmask(SIG_BLOCK, &sigmask, &oldmask);
/*
* drop the umem_update_lock; we cannot hold locks acquired in
* pre-fork handler while calling thr_create or thr_continue().
*/
(void) mutex_unlock(&umem_update_lock);
if (thr_create(NULL, NULL, umem_update_thread, NULL,
THR_BOUND | THR_DAEMON | THR_DETACHED | THR_SUSPENDED,
&newthread) == 0) {
(void) thr_sigsetmask(SIG_SETMASK, &oldmask, NULL);
(void) mutex_lock(&umem_update_lock);
/*
* due to the locking in umem_reap(), only one thread can
* ever call umem_create_update_thread() at a time. This
* must be the case for this code to work.
*/
ASSERT(umem_update_thr == 0);
umem_update_thr = newthread;
(void) mutex_unlock(&umem_update_lock);
(void) thr_continue(newthread);
(void) mutex_lock(&umem_update_lock);
return (1);
} else { /* thr_create failed */
(void) thr_sigsetmask(SIG_SETMASK, &oldmask, NULL);
(void) mutex_lock(&umem_update_lock);
}
return (0);
}

1796
zfs/lib/libumem/vmem.c
View File

File diff suppressed because it is too large Load Diff

56
zfs/lib/libumem/vmem_base.c
View File

@ -1,56 +0,0 @@
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (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 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#include "vmem_base.h"
#include "umem_base.h"
uint_t vmem_backend = 0;
vmem_t *
vmem_heap_arena(vmem_alloc_t **allocp, vmem_free_t **freep)
{
static mutex_t arena_mutex = DEFAULTMUTEX;
/*
* Allow the init thread through, block others until the init completes
*/
if (umem_ready != UMEM_READY && umem_init_thr != thr_self() &&
umem_init() == 0)
return (NULL);
(void) mutex_lock(&arena_mutex);
if (vmem_heap == NULL)
vmem_heap_init();
(void) mutex_unlock(&arena_mutex);
if (allocp != NULL)
*allocp = vmem_heap_alloc;
if (freep != NULL)
*freep = vmem_heap_free;
return (vmem_heap);
}

134
zfs/lib/libumem/vmem_mmap.c
View File

@ -1,134 +0,0 @@
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (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 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#include <unistd.h>
#include <errno.h>
#include <sys/mman.h>
#include <sys/sysmacros.h>
#include "vmem_base.h"
#define ALLOC_PROT PROT_READ | PROT_WRITE | PROT_EXEC
#define FREE_PROT PROT_NONE
#define ALLOC_FLAGS MAP_PRIVATE | MAP_ANON
#define FREE_FLAGS MAP_PRIVATE | MAP_ANON | MAP_NORESERVE
#define CHUNKSIZE (64*1024) /* 64 kilobytes */
static vmem_t *mmap_heap;
static void *
vmem_mmap_alloc(vmem_t *src, size_t size, int vmflags)
{
void *ret;
int old_errno = errno;
ret = vmem_alloc(src, size, vmflags);
if (ret != NULL &&
mmap(ret, size, ALLOC_PROT, ALLOC_FLAGS | MAP_FIXED, -1, 0) ==
MAP_FAILED) {
vmem_free(src, ret, size);
vmem_reap();
ASSERT((vmflags & VM_NOSLEEP) == VM_NOSLEEP);
errno = old_errno;
return (NULL);
}
errno = old_errno;
return (ret);
}
static void
vmem_mmap_free(vmem_t *src, void *addr, size_t size)
{
int old_errno = errno;
(void) mmap(addr, size, FREE_PROT, FREE_FLAGS | MAP_FIXED, -1, 0);
vmem_free(src, addr, size);
errno = old_errno;
}
static void *
vmem_mmap_top_alloc(vmem_t *src, size_t size, int vmflags)
{
void *ret;
void *buf;
int old_errno = errno;
ret = vmem_alloc(src, size, VM_NOSLEEP);
if (ret) {
errno = old_errno;
return (ret);
}
/*
* Need to grow the heap
*/
buf = mmap((void *)CHUNKSIZE, size, FREE_PROT, FREE_FLAGS | MAP_ALIGN,
-1, 0);
if (buf != MAP_FAILED) {
ret = _vmem_extend_alloc(src, buf, size, size, vmflags);
if (ret != NULL)
return (ret);
else {
(void) munmap(buf, size);
errno = old_errno;
return (NULL);
}
} else {
/*
* Growing the heap failed. The allocation above will
* already have called umem_reap().
*/
ASSERT((vmflags & VM_NOSLEEP) == VM_NOSLEEP);
errno = old_errno;
return (NULL);
}
}
vmem_t *
vmem_mmap_arena(vmem_alloc_t **a_out, vmem_free_t **f_out)
{
size_t pagesize = sysconf(_SC_PAGESIZE);
if (mmap_heap == NULL) {
mmap_heap = vmem_init("mmap_top", CHUNKSIZE,
vmem_mmap_top_alloc, vmem_free,
"mmap_heap", NULL, 0, pagesize,
vmem_mmap_alloc, vmem_mmap_free);
}
if (a_out != NULL)
*a_out = vmem_mmap_alloc;
if (f_out != NULL)
*f_out = vmem_mmap_free;
return (mmap_heap);
}

268
zfs/lib/libumem/vmem_sbrk.c
View File

@ -1,268 +0,0 @@
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (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 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* The structure of the sbrk backend:
*
* +-----------+
* | sbrk_top |
* +-----------+
* | (vmem_sbrk_alloc(), vmem_free())
* |
* +-----------+
* | sbrk_heap |
* +-----------+
* | | ... | (vmem_alloc(), vmem_free())
* <other arenas>
*
* The sbrk_top arena holds all controlled memory. vmem_sbrk_alloc() handles
* allocations from it, including growing the heap when we run low.
*
* Growing the heap is complicated by the fact that we have to extend the
* sbrk_top arena (using _vmem_extend_alloc()), and that can fail. Since
* other threads may be actively allocating, we can't return the memory.
*
* Instead, we put it on a doubly-linked list, sbrk_fails, which we search
* before calling sbrk().
*/
#include <errno.h>
#include <limits.h>
#include <sys/sysmacros.h>
#include <sys/mman.h>
#include <unistd.h>
#include "vmem_base.h"
#include "misc.h"
size_t vmem_sbrk_pagesize = 0; /* the preferred page size of the heap */
#define VMEM_SBRK_MINALLOC (64 * 1024)
size_t vmem_sbrk_minalloc = VMEM_SBRK_MINALLOC; /* minimum allocation */
static size_t real_pagesize;
static vmem_t *sbrk_heap;
typedef struct sbrk_fail {
struct sbrk_fail *sf_next;
struct sbrk_fail *sf_prev;
void *sf_base; /* == the sbrk_fail's address */
size_t sf_size; /* the size of this buffer */
} sbrk_fail_t;
static sbrk_fail_t sbrk_fails = {
&sbrk_fails,
&sbrk_fails,
NULL,
0
};
static mutex_t sbrk_faillock = DEFAULTMUTEX;
/*
* Try to extend src with [pos, pos + size).
*
* If it fails, add the block to the sbrk_fails list.
*/
static void *
vmem_sbrk_extend_alloc(vmem_t *src, void *pos, size_t size, size_t alloc,
int vmflags)
{
sbrk_fail_t *fnext, *fprev, *fp;
void *ret;
ret = _vmem_extend_alloc(src, pos, size, alloc, vmflags);
if (ret != NULL)
return (ret);
fp = (sbrk_fail_t *)pos;
ASSERT(sizeof (sbrk_fail_t) <= size);
fp->sf_base = pos;
fp->sf_size = size;
(void) mutex_lock(&sbrk_faillock);
fp->sf_next = fnext = &sbrk_fails;
fp->sf_prev = fprev = sbrk_fails.sf_prev;
fnext->sf_prev = fp;
fprev->sf_next = fp;
(void) mutex_unlock(&sbrk_faillock);
return (NULL);
}
/*
* Try to add at least size bytes to src, using the sbrk_fails list
*/
static void *
vmem_sbrk_tryfail(vmem_t *src, size_t size, int vmflags)
{
sbrk_fail_t *fp;
(void) mutex_lock(&sbrk_faillock);
for (fp = sbrk_fails.sf_next; fp != &sbrk_fails; fp = fp->sf_next) {
if (fp->sf_size >= size) {
fp->sf_next->sf_prev = fp->sf_prev;
fp->sf_prev->sf_next = fp->sf_next;
fp->sf_next = fp->sf_prev = NULL;
break;
}
}
(void) mutex_unlock(&sbrk_faillock);
if (fp != &sbrk_fails) {
ASSERT(fp->sf_base == (void *)fp);
return (vmem_sbrk_extend_alloc(src, fp, fp->sf_size, size,
vmflags));
}
/*
* nothing of the right size on the freelist
*/
return (NULL);
}
static void *
vmem_sbrk_alloc(vmem_t *src, size_t size, int vmflags)
{
extern void *_sbrk_grow_aligned(size_t min_size, size_t low_align,
size_t high_align, size_t *actual_size);
void *ret;
void *buf;
size_t buf_size;
int old_errno = errno;
ret = vmem_alloc(src, size, VM_NOSLEEP);
if (ret != NULL) {
errno = old_errno;
return (ret);
}
/*
* The allocation failed. We need to grow the heap.
*
* First, try to use any buffers which failed earlier.
*/
if (sbrk_fails.sf_next != &sbrk_fails &&
(ret = vmem_sbrk_tryfail(src, size, vmflags)) != NULL)
return (ret);
buf_size = MAX(size, vmem_sbrk_minalloc);
/*
* buf_size gets overwritten with the actual allocated size
*/
buf = _sbrk_grow_aligned(buf_size, real_pagesize, vmem_sbrk_pagesize,
&buf_size);
if (buf != MAP_FAILED) {
ret = vmem_sbrk_extend_alloc(src, buf, buf_size, size, vmflags);
if (ret != NULL) {
errno = old_errno;
return (ret);
}
}
/*
* Growing the heap failed. The vmem_alloc() above called umem_reap().
*/
ASSERT((vmflags & VM_NOSLEEP) == VM_NOSLEEP);
errno = old_errno;
return (NULL);
}
/*
* fork1() support
*/
void
vmem_sbrk_lockup(void)
{
(void) mutex_lock(&sbrk_faillock);
}
void
vmem_sbrk_release(void)
{
(void) mutex_unlock(&sbrk_faillock);
}
vmem_t *
vmem_sbrk_arena(vmem_alloc_t **a_out, vmem_free_t **f_out)
{
if (sbrk_heap == NULL) {
size_t heap_size;
real_pagesize = sysconf(_SC_PAGESIZE);
heap_size = vmem_sbrk_pagesize;
if (issetugid()) {
heap_size = 0;
} else if (heap_size != 0 && !ISP2(heap_size)) {
heap_size = 0;
log_message("ignoring bad pagesize: 0x%p\n", heap_size);
}
if (heap_size <= real_pagesize) {
heap_size = real_pagesize;
} else {
struct memcntl_mha mha;
mha.mha_cmd = MHA_MAPSIZE_BSSBRK;
mha.mha_flags = 0;
mha.mha_pagesize = heap_size;
if (memcntl(NULL, 0, MC_HAT_ADVISE, (char *)&mha, 0, 0)
== -1) {
log_message("unable to set MAPSIZE_BSSBRK to "
"0x%p\n", heap_size);
heap_size = real_pagesize;
}
}
vmem_sbrk_pagesize = heap_size;
/* validate vmem_sbrk_minalloc */
if (vmem_sbrk_minalloc < VMEM_SBRK_MINALLOC)
vmem_sbrk_minalloc = VMEM_SBRK_MINALLOC;
vmem_sbrk_minalloc = P2ROUNDUP(vmem_sbrk_minalloc, heap_size);
sbrk_heap = vmem_init("sbrk_top", real_pagesize,
vmem_sbrk_alloc, vmem_free,
"sbrk_heap", NULL, 0, real_pagesize,
vmem_alloc, vmem_free);
}
if (a_out != NULL)
*a_out = vmem_alloc;
if (f_out != NULL)
*f_out = vmem_free;
return (sbrk_heap);
}

164
zfs/lib/libumem/vmem_stand.c
View File

@ -1,164 +0,0 @@
/*
* 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 "%Z%%M% %I% %E% 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);
}