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

Merge commit 'refs/top-bases/linux-debug-zerocopy' into linux-debug-zerocopy

This commit is contained in:
Brian Behlendorf 2008-12-10 12:55:22 -08:00
parent deeb049ae2 d5e63c17eb
commit a115c36928
39 changed files with 6 additions and 9498 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
configure.ac
View File

@ -117,9 +117,6 @@ AC_CONFIG_FILES([ Makefile
zfs/lib/libuutil/Makefile
zfs/lib/libzfs/include/Makefile
zfs/lib/libzfs/Makefile
zfs/lib/libumem/include/Makefile
zfs/lib/libumem/include/sys/Makefile
zfs/lib/libumem/Makefile
zfs/lib/libzcommon/include/Makefile
zfs/lib/libzcommon/include/sys/fm/fs/Makefile
zfs/lib/libzcommon/include/sys/fm/Makefile

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/

1
zfs/lib/Makefile.in
View File

@ -1,5 +1,4 @@
subdir-m += libuutil # User space util support
subdir-m += libumem # User space memory support
subdir-m += libzfs # User space library support
subdir-m += libspl # User space compatibility library

44
zfs/lib/libumem/Makefile.in
View File

@ -1,44 +0,0 @@
subdir-m += include
DISTFILES = envvar.c getpcstack.c init_lib.c init_stand.c linktest_stand.c
DISTFILES += malloc.c misc.c stub_stand.c umem.c umem_agent_support.c
DISTFILES += umem_fail.c umem_fork.c umem_update_thread.c vmem.c
DISTFILES += vmem_base.c vmem_mmap.c vmem_sbrk.c vmem_stand.c zu.c
LIBRARY := libumem
# Compile as shared library. There's an extra useless host program
# here called 'zu' because it was the easiest way I could convince
# the kernel build system to construct a user space shared library.
HOSTCFLAGS += @HOSTCFLAGS@
HOSTCFLAGS += -I@LIBDIR@/libspl/include
HOSTCFLAGS += -I@LIBDIR@/libumem/include
HOSTLDFLAGS += -pthread
HOSTLDFLAGS += -ldl
hostprogs-y := zu
always := $(hostprogs-y)
zu-objs := zu.o ${LIBRARY}.so
${LIBRARY}-objs += envvar.o
${LIBRARY}-objs += getpcstack.o
${LIBRARY}-objs += init_lib.o
${LIBRARY}-objs += misc.o
${LIBRARY}-objs += umem.o
${LIBRARY}-objs += umem_agent_support.o
${LIBRARY}-objs += umem_fail.o
${LIBRARY}-objs += umem_fork.o
${LIBRARY}-objs += umem_update_thread.o
${LIBRARY}-objs += vmem.o
${LIBRARY}-objs += vmem_base.o
${LIBRARY}-objs += vmem_mmap.o
${LIBRARY}-objs += vmem_sbrk.o
# Currently unused
# ${LIBRARY}-objs += init_stand.o
# ${LIBRARY}-objs += linktest_stand.o
# ${LIBRARY}-objs += malloc.o
# ${LIBRARY}-objs += stub_stand.o
# ${LIBRARY}-objs += vmem_stand.o

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)(void) = NULL;
int sigfuncsize = 0;
extern void thr_sighndlrinfo(void (**)(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 == 0 || !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);
}

2
zfs/lib/libumem/include/Makefile.in
View File

@ -1,2 +0,0 @@
subdir-m += sys
DISTFILES = misc.h umem.h umem_base.h umem_impl.h vmem_base.h vmem_stand.h

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 */

1
zfs/lib/libumem/include/sys/Makefile.in
View File

@ -1 +0,0 @@
DISTFILES = vmem.h vmem_impl_user.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);
}

4
zfs/lib/libumem/zu.c
View File

@ -1,4 +0,0 @@
int main(void)
{
return 0;
}

4
zfs/zcmd/zdb/Makefile.in
View File

@ -7,21 +7,19 @@ HOSTCFLAGS += -I@CMDDIR@/zdb/
HOSTCFLAGS += -I@LIBDIR@/libspl/include
HOSTCFLAGS += -I@LIBDIR@/libavl/include
HOSTCFLAGS += -I@LIBDIR@/libnvpair/include
HOSTCFLAGS += -I@LIBDIR@/libumem/include
HOSTCFLAGS += -I@LIBDIR@/libuutil/include
HOSTCFLAGS += -I@LIBDIR@/libzcommon/include
HOSTCFLAGS += -I@LIBDIR@/libzfs/include
HOSTLDFLAGS += -lavl -L@LIBDIR@/libavl
HOSTLDFLAGS += -lnvpair -L@LIBDIR@/libnvpair
HOSTLDFLAGS += -lumem -L@LIBDIR@/libumem
HOSTLDFLAGS += -luutil -L@LIBDIR@/libuutil
HOSTLDFLAGS += -lzport -L@LIBDIR@/libspl
HOSTLDFLAGS += -lzcommon -L@LIBDIR@/libzcommon
HOSTLDFLAGS += -lzfs -L@LIBDIR@/libzfs
# Additional shared library paths for executing binaries in-tree
export LD_RUN_PATH = @LIBDIR@/libavl:@LIBDIR@/libnvpair:@LIBDIR@/libumem:@LIBDIR@/libuutil:@LIBDIR@/libspl:@LIBDIR@/libzcommon:@LIBDIR@/libzfs
export LD_RUN_PATH = @LIBDIR@/libavl:@LIBDIR@/libnvpair:@LIBDIR@/libuutil:@LIBDIR@/libspl:@LIBDIR@/libzcommon:@LIBDIR@/libzfs
hostprogs-y := ${CMD}
always := $(hostprogs-y)

4
zfs/zcmd/zdump/Makefile.in
View File

@ -7,21 +7,19 @@ HOSTCFLAGS += -I@CMDDIR@/zdump/
HOSTCFLAGS += -I@LIBDIR@/libspl/include
HOSTCFLAGS += -I@LIBDIR@/libavl/include
HOSTCFLAGS += -I@LIBDIR@/libnvpair/include
HOSTCFLAGS += -I@LIBDIR@/libumem/include
HOSTCFLAGS += -I@LIBDIR@/libuutil/include
HOSTCFLAGS += -I@LIBDIR@/libzcommon/include
HOSTCFLAGS += -I@LIBDIR@/libzfs/include
HOSTLDFLAGS += -lavl -L@LIBDIR@/libavl
HOSTLDFLAGS += -lnvpair -L@LIBDIR@/libnvpair
HOSTLDFLAGS += -lumem -L@LIBDIR@/libumem
HOSTLDFLAGS += -luutil -L@LIBDIR@/libuutil
HOSTLDFLAGS += -lzport -L@LIBDIR@/libspl
HOSTLDFLAGS += -lzcommon -L@LIBDIR@/libzcommon
HOSTLDFLAGS += -lzfs -L@LIBDIR@/libzfs
# Additional shared library paths for executing binaries in-tree
export LD_RUN_PATH = @LIBDIR@/libavl:@LIBDIR@/libnvpair:@LIBDIR@/libumem:@LIBDIR@/libuutil:@LIBDIR@/libspl:@LIBDIR@/libzcommon:@LIBDIR@/libzfs
export LD_RUN_PATH = @LIBDIR@/libavl:@LIBDIR@/libnvpair:@LIBDIR@/libuutil:@LIBDIR@/libspl:@LIBDIR@/libzcommon:@LIBDIR@/libzfs
hostprogs-y := ${CMD}
always := $(hostprogs-y)

4
zfs/zcmd/zfs/Makefile.in
View File

@ -7,21 +7,19 @@ HOSTCFLAGS += -I@CMDDIR@/zpool/
HOSTCFLAGS += -I@LIBDIR@/libspl/include
HOSTCFLAGS += -I@LIBDIR@/libavl/include
HOSTCFLAGS += -I@LIBDIR@/libnvpair/include
HOSTCFLAGS += -I@LIBDIR@/libumem/include
HOSTCFLAGS += -I@LIBDIR@/libuutil/include
HOSTCFLAGS += -I@LIBDIR@/libzcommon/include
HOSTCFLAGS += -I@LIBDIR@/libzfs/include
HOSTLDFLAGS += -lavl -L@LIBDIR@/libavl
HOSTLDFLAGS += -lnvpair -L@LIBDIR@/libnvpair
HOSTLDFLAGS += -lumem -L@LIBDIR@/libumem
HOSTLDFLAGS += -luutil -L@LIBDIR@/libuutil
HOSTLDFLAGS += -lzport -L@LIBDIR@/libspl
HOSTLDFLAGS += -lzcommon -L@LIBDIR@/libzcommon
HOSTLDFLAGS += -lzfs -L@LIBDIR@/libzfs
# Additional shared library paths for executing binaries in-tree
export LD_RUN_PATH = @LIBDIR@/libavl:@LIBDIR@/libnvpair:@LIBDIR@/libumem:@LIBDIR@/libuutil:@LIBDIR@/libspl:@LIBDIR@/libzcommon:@LIBDIR@/libzfs
export LD_RUN_PATH = @LIBDIR@/libavl:@LIBDIR@/libnvpair:@LIBDIR@/libuutil:@LIBDIR@/libspl:@LIBDIR@/libzcommon:@LIBDIR@/libzfs
hostprogs-y := ${CMD}
always := $(hostprogs-y)

4
zfs/zcmd/zinject/Makefile.in
View File

@ -7,21 +7,19 @@ HOSTCFLAGS += -I@CMDDIR@/zinject/
HOSTCFLAGS += -I@LIBDIR@/libspl/include
HOSTCFLAGS += -I@LIBDIR@/libavl/include
HOSTCFLAGS += -I@LIBDIR@/libnvpair/include
HOSTCFLAGS += -I@LIBDIR@/libumem/include
HOSTCFLAGS += -I@LIBDIR@/libuutil/include
HOSTCFLAGS += -I@LIBDIR@/libzcommon/include
HOSTCFLAGS += -I@LIBDIR@/libzfs/include
HOSTLDFLAGS += -lavl -L@LIBDIR@/libavl
HOSTLDFLAGS += -lnvpair -L@LIBDIR@/libnvpair
HOSTLDFLAGS += -lumem -L@LIBDIR@/libumem
HOSTLDFLAGS += -luutil -L@LIBDIR@/libuutil
HOSTLDFLAGS += -lzport -L@LIBDIR@/libspl
HOSTLDFLAGS += -lzcommon -L@LIBDIR@/libzcommon
HOSTLDFLAGS += -lzfs -L@LIBDIR@/libzfs
# Additional shared library paths for executing binaries in-tree
export LD_RUN_PATH = @LIBDIR@/libavl:@LIBDIR@/libnvpair:@LIBDIR@/libumem:@LIBDIR@/libuutil:@LIBDIR@/libspl:@LIBDIR@/libzcommon:@LIBDIR@/libzfs
export LD_RUN_PATH = @LIBDIR@/libavl:@LIBDIR@/libnvpair:@LIBDIR@/libuutil:@LIBDIR@/libspl:@LIBDIR@/libzcommon:@LIBDIR@/libzfs
hostprogs-y := ${CMD}
always := $(hostprogs-y)

4
zfs/zcmd/zpool/Makefile.in
View File

@ -7,21 +7,19 @@ HOSTCFLAGS += -I@CMDDIR@/zpool/
HOSTCFLAGS += -I@LIBDIR@/libspl/include
HOSTCFLAGS += -I@LIBDIR@/libavl/include
HOSTCFLAGS += -I@LIBDIR@/libnvpair/include
HOSTCFLAGS += -I@LIBDIR@/libumem/include
HOSTCFLAGS += -I@LIBDIR@/libuutil/include
HOSTCFLAGS += -I@LIBDIR@/libzcommon/include
HOSTCFLAGS += -I@LIBDIR@/libzfs/include
HOSTLDFLAGS += -lavl -L@LIBDIR@/libavl
HOSTLDFLAGS += -lnvpair -L@LIBDIR@/libnvpair
HOSTLDFLAGS += -lumem -L@LIBDIR@/libumem
HOSTLDFLAGS += -luutil -L@LIBDIR@/libuutil
HOSTLDFLAGS += -lzport -L@LIBDIR@/libspl
HOSTLDFLAGS += -lzcommon -L@LIBDIR@/libzcommon
HOSTLDFLAGS += -lzfs -L@LIBDIR@/libzfs
# Additional shared library paths for executing binaries in-tree
export LD_RUN_PATH = @LIBDIR@/libavl:@LIBDIR@/libnvpair:@LIBDIR@/libumem:@LIBDIR@/libuutil:@LIBDIR@/libspl:@LIBDIR@/libzcommon:@LIBDIR@/libzfs
export LD_RUN_PATH = @LIBDIR@/libavl:@LIBDIR@/libnvpair:@LIBDIR@/libuutil:@LIBDIR@/libspl:@LIBDIR@/libzcommon:@LIBDIR@/libzfs
hostprogs-y := ${CMD}
always := $(hostprogs-y)

4
zfs/zcmd/ztest/Makefile.in
View File

@ -7,21 +7,19 @@ HOSTCFLAGS += -I@CMDDIR@/ztest/
HOSTCFLAGS += -I@LIBDIR@/libspl/include
HOSTCFLAGS += -I@LIBDIR@/libavl/include
HOSTCFLAGS += -I@LIBDIR@/libnvpair/include
HOSTCFLAGS += -I@LIBDIR@/libumem/include
HOSTCFLAGS += -I@LIBDIR@/libuutil/include
HOSTCFLAGS += -I@LIBDIR@/libzcommon/include
HOSTCFLAGS += -I@LIBDIR@/libzfs/include
HOSTLDFLAGS += -lavl -L@LIBDIR@/libavl
HOSTLDFLAGS += -lnvpair -L@LIBDIR@/libnvpair
HOSTLDFLAGS += -lumem -L@LIBDIR@/libumem
HOSTLDFLAGS += -luutil -L@LIBDIR@/libuutil
HOSTLDFLAGS += -lzport -L@LIBDIR@/libspl
HOSTLDFLAGS += -lzcommon -L@LIBDIR@/libzcommon
HOSTLDFLAGS += -lzfs -L@LIBDIR@/libzfs
# Additional shared library paths for executing binaries in-tree
export LD_RUN_PATH = @LIBDIR@/libavl:@LIBDIR@/libnvpair:@LIBDIR@/libumem:@LIBDIR@/libuutil:@LIBDIR@/libspl:@LIBDIR@/libzcommon:@LIBDIR@/libzfs
export LD_RUN_PATH = @LIBDIR@/libavl:@LIBDIR@/libnvpair:@LIBDIR@/libuutil:@LIBDIR@/libspl:@LIBDIR@/libzcommon:@LIBDIR@/libzfs
hostprogs-y := ${CMD}
always := $(hostprogs-y)