greg/libumem
1
0
Fork 0
Code Issues 8 Pull requests Projects Releases Packages Wiki Activity

Initial revision

Browse source
This commit is contained in:
Wez Furlong 2006-03-10 02:45:59 +00:00
parent 3f3cd30cf7
commit d7fe11594f
33 changed files with 10239 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
COPYRIGHT Normal file
View file

@ -0,0 +1,6 @@
The bulk of the library is Copyright 2004 Sun Microsystems, Inc.
Portions are Copyright 2006 OmniTI, Inc.
The library is distributed under the terms of the CDDL.
See the file OPENSOLARIS.LICENSE for more information.

385
OPENSOLARIS.LICENSE Normal file
View file

@ -0,0 +1,385 @@
Unless otherwise noted, all files in this distribution are released
under the Common Development and Distribution License (CDDL),
Version 1.0 only. Exceptions are noted within the associated
source files.
--------------------------------------------------------------------
COMMON DEVELOPMENT AND DISTRIBUTION LICENSE Version 1.0
1. Definitions.
1.1. "Contributor" means each individual or entity that creates
or contributes to the creation of Modifications.
1.2. "Contributor Version" means the combination of the Original
Software, prior Modifications used by a Contributor (if any),
and the Modifications made by that particular Contributor.
1.3. "Covered Software" means (a) the Original Software, or (b)
Modifications, or (c) the combination of files containing
Original Software with files containing Modifications, in
each case including portions thereof.
1.4. "Executable" means the Covered Software in any form other
than Source Code.
1.5. "Initial Developer" means the individual or entity that first
makes Original Software available under this License.
1.6. "Larger Work" means a work which combines Covered Software or
portions thereof with code not governed by the terms of this
License.
1.7. "License" means this document.
1.8. "Licensable" means having the right to grant, to the maximum
extent possible, whether at the time of the initial grant or
subsequently acquired, any and all of the rights conveyed
herein.
1.9. "Modifications" means the Source Code and Executable form of
any of the following:
A. Any file that results from an addition to, deletion from or
modification of the contents of a file containing Original
Software or previous Modifications;
B. Any new file that contains any part of the Original
Software or previous Modifications; or
C. Any new file that is contributed or otherwise made
available under the terms of this License.
1.10. "Original Software" means the Source Code and Executable
form of computer software code that is originally released
under this License.
1.11. "Patent Claims" means any patent claim(s), now owned or
hereafter acquired, including without limitation, method,
process, and apparatus claims, in any patent Licensable by
grantor.
1.12. "Source Code" means (a) the common form of computer software
code in which modifications are made and (b) associated
documentation included in or with such code.
1.13. "You" (or "Your") means an individual or a legal entity
exercising rights under, and complying with all of the terms
of, this License. For legal entities, "You" includes any
entity which controls, is controlled by, or is under common
control with You. For purposes of this definition,
"control" means (a) the power, direct or indirect, to cause
the direction or management of such entity, whether by
contract or otherwise, or (b) ownership of more than fifty
percent (50%) of the outstanding shares or beneficial
ownership of such entity.
2. License Grants.
2.1. The Initial Developer Grant.
Conditioned upon Your compliance with Section 3.1 below and
subject to third party intellectual property claims, the Initial
Developer hereby grants You a world-wide, royalty-free,
non-exclusive license:
(a) under intellectual property rights (other than patent or
trademark) Licensable by Initial Developer, to use,
reproduce, modify, display, perform, sublicense and
distribute the Original Software (or portions thereof),
with or without Modifications, and/or as part of a Larger
Work; and
(b) under Patent Claims infringed by the making, using or
selling of Original Software, to make, have made, use,
practice, sell, and offer for sale, and/or otherwise
dispose of the Original Software (or portions thereof).
(c) The licenses granted in Sections 2.1(a) and (b) are
effective on the date Initial Developer first distributes
or otherwise makes the Original Software available to a
third party under the terms of this License.
(d) Notwithstanding Section 2.1(b) above, no patent license is
granted: (1) for code that You delete from the Original
Software, or (2) for infringements caused by: (i) the
modification of the Original Software, or (ii) the
combination of the Original Software with other software
or devices.
2.2. Contributor Grant.
Conditioned upon Your compliance with Section 3.1 below and
subject to third party intellectual property claims, each
Contributor hereby grants You a world-wide, royalty-free,
non-exclusive license:
(a) under intellectual property rights (other than patent or
trademark) Licensable by Contributor to use, reproduce,
modify, display, perform, sublicense and distribute the
Modifications created by such Contributor (or portions
thereof), either on an unmodified basis, with other
Modifications, as Covered Software and/or as part of a
Larger Work; and
(b) under Patent Claims infringed by the making, using, or
selling of Modifications made by that Contributor either
alone and/or in combination with its Contributor Version
(or portions of such combination), to make, use, sell,
offer for sale, have made, and/or otherwise dispose of:
(1) Modifications made by that Contributor (or portions
thereof); and (2) the combination of Modifications made by
that Contributor with its Contributor Version (or portions
of such combination).
(c) The licenses granted in Sections 2.2(a) and 2.2(b) are
effective on the date Contributor first distributes or
otherwise makes the Modifications available to a third
party.
(d) Notwithstanding Section 2.2(b) above, no patent license is
granted: (1) for any code that Contributor has deleted
from the Contributor Version; (2) for infringements caused
by: (i) third party modifications of Contributor Version,
or (ii) the combination of Modifications made by that
Contributor with other software (except as part of the
Contributor Version) or other devices; or (3) under Patent
Claims infringed by Covered Software in the absence of
Modifications made by that Contributor.
3. Distribution Obligations.
3.1. Availability of Source Code.
Any Covered Software that You distribute or otherwise make
available in Executable form must also be made available in Source
Code form and that Source Code form must be distributed only under
the terms of this License. You must include a copy of this
License with every copy of the Source Code form of the Covered
Software You distribute or otherwise make available. You must
inform recipients of any such Covered Software in Executable form
as to how they can obtain such Covered Software in Source Code
form in a reasonable manner on or through a medium customarily
used for software exchange.
3.2. Modifications.
The Modifications that You create or to which You contribute are
governed by the terms of this License. You represent that You
believe Your Modifications are Your original creation(s) and/or
You have sufficient rights to grant the rights conveyed by this
License.
3.3. Required Notices.
You must include a notice in each of Your Modifications that
identifies You as the Contributor of the Modification. You may
not remove or alter any copyright, patent or trademark notices
contained within the Covered Software, or any notices of licensing
or any descriptive text giving attribution to any Contributor or
the Initial Developer.
3.4. Application of Additional Terms.
You may not offer or impose any terms on any Covered Software in
Source Code form that alters or restricts the applicable version
of this License or the recipients' rights hereunder. You may
choose to offer, and to charge a fee for, warranty, support,
indemnity or liability obligations to one or more recipients of
Covered Software. However, you may do so only on Your own behalf,
and not on behalf of the Initial Developer or any Contributor.
You must make it absolutely clear that any such warranty, support,
indemnity or liability obligation is offered by You alone, and You
hereby agree to indemnify the Initial Developer and every
Contributor for any liability incurred by the Initial Developer or
such Contributor as a result of warranty, support, indemnity or
liability terms You offer.
3.5. Distribution of Executable Versions.
You may distribute the Executable form of the Covered Software
under the terms of this License or under the terms of a license of
Your choice, which may contain terms different from this License,
provided that You are in compliance with the terms of this License
and that the license for the Executable form does not attempt to
limit or alter the recipient's rights in the Source Code form from
the rights set forth in this License. If You distribute the
Covered Software in Executable form under a different license, You
must make it absolutely clear that any terms which differ from
this License are offered by You alone, not by the Initial
Developer or Contributor. You hereby agree to indemnify the
Initial Developer and every Contributor for any liability incurred
by the Initial Developer or such Contributor as a result of any
such terms You offer.
3.6. Larger Works.
You may create a Larger Work by combining Covered Software with
other code not governed by the terms of this License and
distribute the Larger Work as a single product. In such a case,
You must make sure the requirements of this License are fulfilled
for the Covered Software.
4. Versions of the License.
4.1. New Versions.
Sun Microsystems, Inc. is the initial license steward and may
publish revised and/or new versions of this License from time to
time. Each version will be given a distinguishing version number.
Except as provided in Section 4.3, no one other than the license
steward has the right to modify this License.
4.2. Effect of New Versions.
You may always continue to use, distribute or otherwise make the
Covered Software available under the terms of the version of the
License under which You originally received the Covered Software.
If the Initial Developer includes a notice in the Original
Software prohibiting it from being distributed or otherwise made
available under any subsequent version of the License, You must
distribute and make the Covered Software available under the terms
of the version of the License under which You originally received
the Covered Software. Otherwise, You may also choose to use,
distribute or otherwise make the Covered Software available under
the terms of any subsequent version of the License published by
the license steward.
4.3. Modified Versions.
When You are an Initial Developer and You want to create a new
license for Your Original Software, You may create and use a
modified version of this License if You: (a) rename the license
and remove any references to the name of the license steward
(except to note that the license differs from this License); and
(b) otherwise make it clear that the license contains terms which
differ from this License.
5. DISCLAIMER OF WARRANTY.
COVERED SOFTWARE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS"
BASIS, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED,
INCLUDING, WITHOUT LIMITATION, WARRANTIES THAT THE COVERED
SOFTWARE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR
PURPOSE OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND
PERFORMANCE OF THE COVERED SOFTWARE IS WITH YOU. SHOULD ANY
COVERED SOFTWARE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT THE
INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY
NECESSARY SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF
WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO USE OF
ANY COVERED SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS
DISCLAIMER.
6. TERMINATION.
6.1. This License and the rights granted hereunder will terminate
automatically if You fail to comply with terms herein and fail to
cure such breach within 30 days of becoming aware of the breach.
Provisions which, by their nature, must remain in effect beyond
the termination of this License shall survive.
6.2. If You assert a patent infringement claim (excluding
declaratory judgment actions) against Initial Developer or a
Contributor (the Initial Developer or Contributor against whom You
assert such claim is referred to as "Participant") alleging that
the Participant Software (meaning the Contributor Version where
the Participant is a Contributor or the Original Software where
the Participant is the Initial Developer) directly or indirectly
infringes any patent, then any and all rights granted directly or
indirectly to You by such Participant, the Initial Developer (if
the Initial Developer is not the Participant) and all Contributors
under Sections 2.1 and/or 2.2 of this License shall, upon 60 days
notice from Participant terminate prospectively and automatically
at the expiration of such 60 day notice period, unless if within
such 60 day period You withdraw Your claim with respect to the
Participant Software against such Participant either unilaterally
or pursuant to a written agreement with Participant.
6.3. In the event of termination under Sections 6.1 or 6.2 above,
all end user licenses that have been validly granted by You or any
distributor hereunder prior to termination (excluding licenses
granted to You by any distributor) shall survive termination.
7. LIMITATION OF LIABILITY.
UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT
(INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL YOU, THE
INITIAL DEVELOPER, ANY OTHER CONTRIBUTOR, OR ANY DISTRIBUTOR OF
COVERED SOFTWARE, OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE
LIABLE TO ANY PERSON FOR ANY INDIRECT, SPECIAL, INCIDENTAL, OR
CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT
LIMITATION, DAMAGES FOR LOST PROFITS, LOSS OF GOODWILL, WORK
STOPPAGE, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER
COMMERCIAL DAMAGES OR LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN
INFORMED OF THE POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF
LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL
INJURY RESULTING FROM SUCH PARTY'S NEGLIGENCE TO THE EXTENT
APPLICABLE LAW PROHIBITS SUCH LIMITATION. SOME JURISDICTIONS DO
NOT ALLOW THE EXCLUSION OR LIMITATION OF INCIDENTAL OR
CONSEQUENTIAL DAMAGES, SO THIS EXCLUSION AND LIMITATION MAY NOT
APPLY TO YOU.
8. U.S. GOVERNMENT END USERS.
The Covered Software is a "commercial item," as that term is
defined in 48 C.F.R. 2.101 (Oct. 1995), consisting of "commercial
computer software" (as that term is defined at 48
C.F.R. 252.227-7014(a)(1)) and "commercial computer software
documentation" as such terms are used in 48 C.F.R. 12.212
(Sept. 1995). Consistent with 48 C.F.R. 12.212 and 48
C.F.R. 227.7202-1 through 227.7202-4 (June 1995), all
U.S. Government End Users acquire Covered Software with only those
rights set forth herein. This U.S. Government Rights clause is in
lieu of, and supersedes, any other FAR, DFAR, or other clause or
provision that addresses Government rights in computer software
under this License.
9. MISCELLANEOUS.
This License represents the complete agreement concerning subject
matter hereof. If any provision of this License is held to be
unenforceable, such provision shall be reformed only to the extent
necessary to make it enforceable. This License shall be governed
by the law of the jurisdiction specified in a notice contained
within the Original Software (except to the extent applicable law,
if any, provides otherwise), excluding such jurisdiction's
conflict-of-law provisions. Any litigation relating to this
License shall be subject to the jurisdiction of the courts located
in the jurisdiction and venue specified in a notice contained
within the Original Software, with the losing party responsible
for costs, including, without limitation, court costs and
reasonable attorneys' fees and expenses. The application of the
United Nations Convention on Contracts for the International Sale
of Goods is expressly excluded. Any law or regulation which
provides that the language of a contract shall be construed
against the drafter shall not apply to this License. You agree
that You alone are responsible for compliance with the United
States export administration regulations (and the export control
laws and regulation of any other countries) when You use,
distribute or otherwise make available any Covered Software.
10. RESPONSIBILITY FOR CLAIMS.
As between Initial Developer and the Contributors, each party is
responsible for claims and damages arising, directly or
indirectly, out of its utilization of rights under this License
and You agree to work with Initial Developer and Contributors to
distribute such responsibility on an equitable basis. Nothing
herein is intended or shall be deemed to constitute any admission
of liability.
--------------------------------------------------------------------
NOTICE PURSUANT TO SECTION 9 OF THE COMMON DEVELOPMENT AND
DISTRIBUTION LICENSE (CDDL)
For Covered Software in this distribution, this License shall
be governed by the laws of the State of California (excluding
conflict-of-law provisions).
Any litigation relating to this License shall be subject to the
jurisdiction of the Federal Courts of the Northern District of
California and the state courts of the State of California, with
venue lying in Santa Clara County, California.

23
README Normal file
View file

@ -0,0 +1,23 @@
Portable libumem.
================
This is a port of Solaris libumem to non-Solaris systems.
The port was made while integrating libumem with our Ecelerity MTA product, so
your initial experience will not be 100% out-of-the-box, because there is no
standalone configure script for the library at this time. (patches welcome!)
In addition, since our deployment is threaded, we force the library into
threaded mode.
While the library is itself stable (it's the memory allocator used by the
Solaris OS), the port may have a few rough edges. We're shipping umem with
Linux and Windows versions of our product as we have found it to be stable.
We will continue to update this project as and when we make improvements, and
welcome third-party patches that improve the usability for everyone.
Wez Furlong,
OmniTI, Inc.

688
envvar.c Normal file
View file

@ -0,0 +1,688 @@
/*
* 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.
*/
/*
* Portions Copyright 2006 OmniTI, Inc.
*/
/* #pragma ident "@(#)envvar.c 1.5 05/06/08 SMI" */
#include "config.h"
#include <ctype.h>
#include <errno.h>
#include <limits.h>
#include <stdlib.h>
#include <string.h>
#if HAVE_DLFCN_H
#include <dlfcn.h>
#endif
#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;
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
},
#ifndef _WIN32
#ifndef UMEM_STANDALONE
{ "sbrk_pagesize", "Private", ITEM_SIZE,
"The preferred page size for the sbrk(2) heap.",
NULL, 0, NULL, &vmem_sbrk_pagesize
},
#endif
#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);
}
#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_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_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
#ifdef _WIN32
# define dlopen(a, b) GetModuleHandle(NULL)
# define dlsym(a, b) GetProcAddress((HANDLE)a, b)
# define dlclose(a) 0
# define dlerror() 0
#endif
/* 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);
}
}
}

211
getpcstack.c Normal file
View file

@ -0,0 +1,211 @@
/*
* 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.
*/
/*
* Portions Copyright 2006 OmniTI, Inc.
*/
/* #pragma ident "@(#)getpcstack.c 1.5 05/06/08 SMI" */
#include "config.h"
#include "misc.h"
#if HAVE_UCONTEXT_H
#include <ucontext.h>
#endif
#if HAVE_SYS_FRAME_H
#include <sys/frame.h>
#endif
#if HAVE_SYS_STACK_H
#include <sys/stack.h>
#endif
#include <stdio.h>
#if defined(__MACH__)
/*
* Darwin doesn't have any exposed frame info, so give it some space.
*/
#define UMEM_FRAMESIZE (2 * sizeof(long long))
#elif 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))
#elif !defined(EC_UMEM_DUMMY_PCSTACK)
#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)
{
#ifdef EC_UMEM_DUMMY_PCSTACK
return 0;
#else
struct frame *fp;
struct frame *nextfp, *minfp;
int depth = 0;
uintptr_t base = 0;
size_t size = 0;
#ifndef UMEM_STANDALONE
int on_altstack = 0;
uintptr_t sigbase = 0;
size_t sigsize = 0;
stack_t st;
if (stack_getbounds(&st) != 0) {
if (thr_stksegment(&st) != 0 ||
(uintptr_t)st.ss_sp < st.ss_size) {
return (0); /* unable to get stack bounds */
}
/*
* thr_stksegment(3C) has a slightly different interface than
* stack_getbounds(3C) -- correct it
*/
st.ss_sp = (void *)(((uintptr_t)st.ss_sp) - st.ss_size);
st.ss_flags = 0; /* can't be on-stack */
}
on_altstack = (st.ss_flags & SS_ONSTACK);
if (st.ss_size != 0) {
base = (uintptr_t)st.ss_sp;
size = st.ss_size;
} else {
/*
* If size == 0, then ss_sp is the *top* of the stack.
*
* Since we only allow increasing frame pointers, and we
* know our caller set his up correctly, we can treat ss_sp
* as an upper bound safely.
*/
base = 0;
size = (uintptr_t)st.ss_sp;
}
if (check_signal != 0) {
void (*sigfunc)() = NULL;
int sigfuncsize = 0;
extern void thr_sighndlrinfo(void (**)(), int *);
thr_sighndlrinfo(&sigfunc, &sigfuncsize);
sigbase = (uintptr_t)sigfunc;
sigsize = sigfuncsize;
}
#else /* UMEM_STANDALONE */
base = (uintptr_t)umem_min_stack;
size = umem_max_stack - umem_min_stack;
#endif
/*
* shorten size so that fr_savfp and fr_savpc will be within the stack
* bounds.
*/
if (size >= UMEM_FRAMESIZE - 1)
size -= (UMEM_FRAMESIZE - 1);
else
size = 0;
#if defined(__sparc) || defined(__sparcv9)
flush_windows();
#endif
/* LINTED alignment */
fp = (struct frame *)((caddr_t)getfp() + STACK_BIAS);
minfp = fp;
if (((uintptr_t)fp - base) >= size)
return (0); /* the frame pointer isn't in our stack */
while (depth < pcstack_limit) {
uintptr_t tmp;
/* LINTED alignment */
nextfp = (struct frame *)((caddr_t)fp->fr_savfp + STACK_BIAS);
tmp = (uintptr_t)nextfp;
/*
* Check nextfp for validity. It must be properly aligned,
* increasing compared to the last %fp (or the top of the
* stack we just switched to), and it must be inside
* [base, base + size).
*/
if (tmp != SA(tmp))
break;
else if (nextfp <= minfp || (tmp - base) >= size) {
#ifndef UMEM_STANDALONE
if (tmp == NULL || !on_altstack)
break;
/*
* If we're on an alternate signal stack, try jumping
* to the main thread stack.
*
* If the main thread stack has an unlimited size, we
* punt, since we don't know where the frame pointer's
* been.
*
* (thr_stksegment() returns the *top of stack*
* in ss_sp, not the bottom)
*/
if (thr_stksegment(&st) == 0) {
if (st.ss_size >= (uintptr_t)st.ss_sp ||
st.ss_size < UMEM_FRAMESIZE - 1)
break;
on_altstack = 0;
base = (uintptr_t)st.ss_sp - st.ss_size;
size = st.ss_size - (UMEM_FRAMESIZE - 1);
minfp = (struct frame *)base;
continue; /* try again */
}
#endif
break;
}
#ifndef UMEM_STANDALONE
if (check_signal && (fp->fr_savpc - sigbase) <= sigsize)
umem_panic("called from signal handler");
#endif
pcstack[depth++] = fp->fr_savpc;
fp = nextfp;
minfp = fp;
}
return (depth);
#endif
}

72
i386_subr_sol.s Normal file
View file

@ -0,0 +1,72 @@
/*
* 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 "@(#)asm_subr.s 1.4 05/06/08 SMI"
#include <sys/asm_linkage.h>
#if defined(lint)
void *
getfp(void)
{
return (NULL);
}
#ifndef UMEM_STANDALONE
void
_breakpoint(void)
{
return;
}
#endif
#else /* lint */
#if defined(__amd64)
ENTRY(getfp)
movq %rbp, %rax
ret
SET_SIZE(getfp)
#else /* __i386 */
ENTRY(getfp)
movl %ebp, %eax
ret
SET_SIZE(getfp)
#endif
#ifndef UMEM_STANDALONE
ENTRY(_breakpoint)
int $3
ret
SET_SIZE(_breakpoint)
#endif
#endif /* lint */

104
init_lib.c Normal file
View file

@ -0,0 +1,104 @@
/*
* 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.
*/
/*
* Portions Copyright 2006 OmniTI, Inc.
*/
/* #pragma ident "@(#)init_lib.c 1.2 05/06/08 SMI" */
/*
* Initialization routines for the library version of libumem.
*/
#include "config.h"
#include "umem_base.h"
#include "vmem_base.h"
#if HAVE_UNISTD_H
#include <unistd.h>
#endif
#if HAVE_DLFCN_H
#include <dlfcn.h>
#endif
void
vmem_heap_init(void)
{
#ifdef _WIN32
vmem_backend = VMEM_BACKEND_MMAP;
#else
#if 0
void *handle = dlopen("libmapmalloc.so.1", RTLD_NOLOAD);
if (handle != NULL) {
#endif
log_message("sbrk backend disabled\n");
vmem_backend = VMEM_BACKEND_MMAP;
#if 0
}
#endif
#endif
if ((vmem_backend & VMEM_BACKEND_MMAP) != 0) {
vmem_backend = VMEM_BACKEND_MMAP;
(void) vmem_mmap_arena(NULL, NULL);
} else {
#ifndef _WIN32
vmem_backend = VMEM_BACKEND_SBRK;
(void) vmem_sbrk_arena(NULL, NULL);
#endif
}
}
/*ARGSUSED*/
void
umem_type_init(caddr_t start, size_t len, size_t pgsize)
{
#ifdef _WIN32
SYSTEM_INFO info;
GetSystemInfo(&info);
pagesize = info.dwPageSize;
#else
pagesize = _sysconf(_SC_PAGESIZE);
#endif
}
int
umem_get_max_ncpus(void)
{
#ifdef _SC_NPROCESSORS_ONLN
return (2 * sysconf(_SC_NPROCESSORS_ONLN));
#elif defined(_SC_NPROCESSORS_CONF)
return (2 * sysconf(_SC_NPROCESSORS_CONF));
#elif defined(_WIN32)
SYSTEM_INFO info;
GetSystemInfo(&info);
return info.dwNumberOfProcessors;
#else
/* XXX: determine CPU count on other platforms */
return (1);
#endif
}

65
init_stand.c Normal file
View file

@ -0,0 +1,65 @@
/*
* 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 "@(#)init_stand.c 1.3 05/06/08 SMI"
/*
* Initialization routines for the standalone version of libumem.
*/
#include "config.h"
#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));
}

70
linktest_stand.c Normal file
View file

@ -0,0 +1,70 @@
/*
* 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 "@(#)linktest_stand.c 1.3 05/06/08 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 bcopy(void) {}
void bzero(void) {}
void dladdr1(void) {}
void exit(void) {}
void getenv(void) {}
void gethrtime(void) {}
void membar_producer(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;

416
malloc.c Normal file
View file

@ -0,0 +1,416 @@
/*
* 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 "@(#)malloc.c 1.5 05/06/08 SMI"
#include "config.h"
#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));
/*
* 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);
}

293
misc.c Normal file
View file

@ -0,0 +1,293 @@
/*
* 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 2005 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* Portions Copyright 2006 OmniTI, Inc.
*/
/* #pragma ident "@(#)misc.c 1.6 05/06/08 SMI" */
#define _BUILDING_UMEM_MISC_C
#include "config.h"
/* #include "mtlib.h" */
#if HAVE_UNISTD_H
#include <unistd.h>
#endif
#if HAVE_DLFCN_H
#include <dlfcn.h>
#endif
#include <signal.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#if HAVE_SYS_MACHELF_H
#include <sys/machelf.h>
#endif
#include <umem_impl.h>
#include "misc.h"
#include "util.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 serious)
{
int looped;
char c;
looped = 0;
mem_printf(serious ? DCRITICAL : DINFO, "umem: %s", error_str);
(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, 1);
}
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, 0);
}
#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)
{
#if HAVE_SYS_MACHELF_H
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);
}
#else
return 0;
#endif
}

150
misc.h Normal file
View file

@ -0,0 +1,150 @@
/*
* 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.
*/
/*
* Portions Copyright 2006 OmniTI, Inc.
*/
#ifndef _MISC_H
#define _MISC_H
/* #pragma ident "@(#)misc.h 1.6 05/06/08 SMI" */
#include "config.h"
#include <sys/types.h>
#ifndef _WIN32
#include <sys/time.h>
#endif
#ifdef HAVE_THREAD_H
# include <thread.h>
#else
# include "sol_compat.h"
#endif
#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) __attribute__ ((pure));
int lowbit(ulong_t) __attribute__ ((pure));;
/* #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, ...) __attribute__((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) __attribute__ ((noreturn));
/* #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 */

133
sol_compat.h Normal file
View file

@ -0,0 +1,133 @@
/*
* Copyright (c) 2006 OmniTI, Inc. All rights reserved
* This header file distributed under the terms of the CDDL.
* Portions Copyright 2004 Sun Microsystems, Inc. All Rights reserved.
*/
#ifndef _EC_UMEM_SOL_COMPAT_H_
#define _EC_UMEM_SOL_COMPAT_H_
#if defined(__MACH__) || defined(_WIN32)
#define NO_WEAK_SYMBOLS
#define _umem_cache_alloc(a,b) umem_cache_alloc(a,b)
#define _umem_cache_free(a,b) umem_cache_free(a,b)
#define _umem_zalloc(a,b) umem_zalloc(a,b)
#define _umem_alloc(a,b) umem_alloc(a,b)
#define _umem_alloc_align(a,b,c) umem_alloc_align(a,b,c)
#define _umem_free(a,b) umem_free(a,b)
#define _umem_free_align(a,b) umem_free_align(a,b)
#endif
#ifdef _WIN32
#define bcopy(s, d, n) memcpy(d, s, n)
#define bzero(m, s) memset(m, 0, s)
#endif
typedef pthread_t thread_t;
typedef pthread_mutex_t mutex_t;
typedef pthread_cond_t cond_t;
typedef u_int64_t hrtime_t;
typedef uint32_t uint_t;
typedef unsigned long ulong_t;
typedef struct timespec timestruc_t;
typedef long long longlong_t;
typedef struct timespec timespec_t;
static INLINE hrtime_t gethrtime(void) {
struct timeval tv;
gettimeofday(&tv, NULL);
return (((u_int64_t)tv.tv_sec) << 32) | tv.tv_usec;
}
# define thr_self() pthread_self()
static INLINE thread_t _thr_self(void) {
return thr_self();
}
#if defined(_MACH_PORT_T)
#define CPUHINT() (pthread_mach_thread_np(pthread_self()))
#endif
# define thr_sigsetmask pthread_sigmask
#define THR_BOUND 1
#define THR_DETACHED 2
#define THR_DAEMON 4
static INLINE int thr_create(void *stack_base,
size_t stack_size, THR_RETURN (THR_API *start_func)(void*),
void *arg, long flags, thread_t *new_thread_ID)
{
int ret;
pthread_attr_t attr;
pthread_attr_init(&attr);
if (flags & THR_DETACHED) {
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
}
ret = pthread_create(new_thread_ID, &attr, start_func, arg);
pthread_attr_destroy(&attr);
return ret;
}
# define mutex_init(mp, type, arg) pthread_mutex_init(mp, NULL)
# define mutex_lock(mp) pthread_mutex_lock(mp)
# define mutex_unlock(mp) pthread_mutex_unlock(mp)
# define mutex_destroy(mp) pthread_mutex_destroy(mp)
# define mutex_trylock(mp) pthread_mutex_trylock(mp)
# define DEFAULTMUTEX PTHREAD_MUTEX_INITIALIZER
# define DEFAULTCV PTHREAD_COND_INITIALIZER
# define MUTEX_HELD(mp) 1 /* not really, but only used in an assert */
# define cond_init(c, type, arg) pthread_cond_init(c, NULL)
# define cond_wait(c, m) pthread_cond_wait(c, m)
# define _cond_wait(c, m) pthread_cond_wait(c, m)
# define cond_signal(c) pthread_cond_signal(c)
# define cond_broadcast(c) pthread_cond_broadcast(c)
# define cond_destroy(c) pthread_cond_destroy(c)
# define cond_timedwait pthread_cond_timedwait
# define _cond_timedwait pthread_cond_timedwait
#ifndef RTLD_FIRST
# define RTLD_FIRST 0
#endif
#include "ec_atomic.h"
#define P2PHASE(x, align) ((x) & ((align) - 1))
#define P2ALIGN(x, align) ((x) & -(align))
#define P2NPHASE(x, align) (-(x) & ((align) - 1))
#define P2ROUNDUP(x, align) (-(-(x) & -(align)))
#define P2END(x, align) (-(~(x) & -(align)))
#define P2PHASEUP(x, align, phase) ((phase) - (((phase) - (x)) & -(align)))
#define P2CROSS(x, y, align) (((x) ^ (y)) > (align) - 1)
#define P2SAMEHIGHBIT(x, y) (((x) ^ (y)) < ((x) & (y)))
#define IS_P2ALIGNED(v, a) ((((uintptr_t)(v)) & ((uintptr_t)(a) - 1)) == 0)
#define ISP2(x) (((x) & ((x) - 1)) == 0)
/* beware! umem only uses these atomic adds for incrementing by 1 */
#define atomic_add_64(lvalptr, delta) ec_atomic_inc64(lvalptr)
#define atomic_add_32_nv(a, b) ec_atomic_inc(a)
#ifndef NANOSEC
#define NANOSEC 1000000000
#endif
#ifdef _WIN32
#define issetugid() 0
#else
#define issetugid() (geteuid() == 0)
#endif
#define _sysconf(a) sysconf(a)
#define __NORETURN __attribute__ ((noreturn))
#define EC_UMEM_DUMMY_PCSTACK 1
static INLINE int __nthreads(void)
{
/* or more; just to force multi-threaded mode */
return 2;
}
#if (SIZEOF_VOID_P == 8)
# define _LP64 1
#endif
#endif

92
sparc_subr_sol.s Normal file
View file

@ -0,0 +1,92 @@
/*
* 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 "@(#)asm_subr.s 1.3 05/06/08 SMI"
#include <sys/asm_linkage.h>
#if defined(lint)
void *
getfp(void)
{
return (NULL);
}
void
flush_windows(void)
{
}
#ifndef UMEM_STANDALONE
void
_breakpoint(void)
{
return;
}
#endif
#else /* lint */
ENTRY(getfp)
retl
mov %fp, %o0
SET_SIZE(getfp)
#ifdef UMEM_STANDALONE
#ifdef __sparcv9
/*
* The caller doesn't need the top window to be flushed, so this
* is sufficient.
*/
ENTRY(flush_windows)
retl
flushw
SET_SIZE(flush_windows)
#else /* !__sparcv9 */
#error "This file does not provide a pre-v9 standalone flush_windows"
#endif /* __sparcv9 */
#else /* !UMEM_STANDALONE */
ENTRY(flush_windows)
retl
ta 0x3
SET_SIZE(flush_windows)
#endif /* UMEM_STANDALONE */
#ifndef UMEM_STANDALONE
ENTRY(_breakpoint)
retl
ta 0x1
SET_SIZE(_breakpoint)
#endif
#endif /* lint */

39
stand_mapfile Normal file
View file

@ -0,0 +1,39 @@
#
# Copyright 2005 Sun Microsystems, Inc. All rights reserved.
# Use is subject to license terms.
#
# 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
#
#ident "@(#)stand_mapfile 1.3 05/06/08 SMI"
#
#
# This is a supplemental mapfile, used in addition to the standard one
# produced by the spec tools. This mapfile exposes an additional
# symbol (umem_startup) that is only present in the standalone version
# of libumem.
#
SUNWprivate1.1 {
global:
umem_startup;
umem_add;
};

125
stub_stand.c Normal file
View file

@ -0,0 +1,125 @@
/*
* 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 "@(#)stub_stand.c 1.3 05/06/08 SMI"
/*
* Stubs for the standalone to reduce the dependence on external libraries
*/
#include "config.h"
#include <string.h>
#include <thread.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);
}
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);
}

142
sys/vmem.h Normal file
View file

@ -0,0 +1,142 @@
/*
* 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 2005 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#ifndef _SYS_VMEM_H
#define _SYS_VMEM_H
/* #pragma ident "@(#)vmem.h 1.13 05/06/08 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
*/
#define VMC_XALLOC 0x00080000
#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 *, 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 */

165
sys/vmem_impl_user.h Normal file
View file

@ -0,0 +1,165 @@
/*
* 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.
*/
/*
* Portions Copyright 2006 OmniTI, Inc.
*/
#ifndef _SYS_VMEM_IMPL_USER_H
#define _SYS_VMEM_IMPL_USER_H
/* #pragma ident "@(#)vmem_impl_user.h 1.2 05/06/08 SMI" */
#if HAVE_SYS_KSTAT
#include <sys/kstat.h>
#endif
#ifndef _WIN32
#include <sys/time.h>
#endif
#include <sys/vmem.h>
#if HAVE_THREAD_H
#include <thread.h>
#else
# include "sol_compat.h"
#endif
#if HAVE_SYNC_H
#include <synch.h>
#endif
#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 */

3158
umem.c Normal file
View file

File diff suppressed because it is too large Load diff

86
umem.h Normal file
View file

@ -0,0 +1,86 @@
/*
* 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 "@(#)umem.h 1.3 05/06/08 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 */

50
umem_agent_support.c Normal file
View file

@ -0,0 +1,50 @@
/*
* 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.
*/
/*
* Portions Copyright 2006 OmniTI, Inc.
*/
/* #pragma ident "@(#)umem_agent_support.c 1.2 05/06/08 SMI" */
#include "config.h"
#include "umem_base.h"
#define AGENT_STACK_SIZE 4096
#if 0
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();
}
#endif

143
umem_base.h Normal file
View file

@ -0,0 +1,143 @@
/*
* 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_BASE_H
#define _UMEM_BASE_H
/* #pragma ident "@(#)umem_base.h 1.4 05/06/08 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 *);
/*
* 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 */

163
umem_fail.c Normal file
View file

@ -0,0 +1,163 @@
/*
* 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 2005 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* Portions Copyright 2006 OmniTI, Inc.
*/
/* #pragma ident "@(#)umem_fail.c 1.4 05/06/08 SMI" */
/*
* Failure routines for libumem (not standalone)
*/
#include "config.h"
#include <sys/types.h>
#include <signal.h>
#include <stdarg.h>
#include <string.h>
#include "misc.h"
#include "util.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)
{
#ifdef _WIN32
abort();
#else
if (firstexit(UMEM_EXIT_ABORT)) {
(void) raise(SIGABRT);
}
for (;;) {
(void) signal(SIGABRT, SIG_DFL);
(void) sigrelse(SIGABRT);
(void) raise(SIGABRT);
}
#endif
}
#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");
va_start(va, format);
ec_debug_vprintf(DCRITICAL, DMEM, format, va);
va_end(va);
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);
umem_do_abort();
/*NOTREACHED*/
return (0);
}

214
umem_fork.c Normal file
View file

@ -0,0 +1,214 @@
/*
* 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.
*/
/*
* Portions Copyright 2006 OmniTI, Inc.
*/
/* #pragma ident "@(#)umem_fork.c 1.3 05/06/08 SMI" */
#include "config.h"
/* #include "mtlib.h" */
#include "umem_base.h"
#include "vmem_base.h"
#ifndef _WIN32
#include <unistd.h>
/*
* The following functions are for pre- and post-fork1(2) handling.
*/
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);
}
(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);
vmem_sbrk_lockup();
vmem_lockup();
}
static void
umem_release(void)
{
umem_cache_t *cp;
vmem_release();
vmem_sbrk_release();
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);
(void) mutex_unlock(&umem_init_lock);
}
static void
umem_release_child(void)
{
umem_cache_t *cp;
/*
* Clean up the update state
*/
umem_update_thr = 0;
if (umem_st_update_thr != thr_self()) {
umem_st_update_thr = 0;
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();
}
#endif
void
umem_forkhandler_init(void)
{
#ifndef _WIN32
/*
* 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);
#endif
}

424
umem_impl.h Normal file
View file

@ -0,0 +1,424 @@
/*
* 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.
*/
/*
* Portions Copyright 2006 OmniTI, Inc.
*/
#ifndef _UMEM_IMPL_H
#define _UMEM_IMPL_H
/* #pragma ident "@(#)umem_impl.h 1.6 05/06/08 SMI" */
#include <umem.h>
#ifdef HAVE_SYS_SYSMACROS_H
#include <sys/sysmacros.h>
#endif
#if HAVE_SYS_TIME_H
#include <sys/time.h>
#endif
#include <sys/vmem.h>
#ifdef HAVE_THREAD_H
# include <thread.h>
#else
# include "sol_compat.h"
#endif
#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;
#if (defined(__PTHREAD_MUTEX_SIZE__) && __PTHREAD_MUTEX_SIZE__ >= 24) || defined(UMEM_PTHREAD_MUTEX_TOO_BIG)
#define UMEM_CPU_CACHE_SIZE 128 /* must be power of 2 */
#else
#define UMEM_CPU_CACHE_SIZE 64 /* must be power of 2 */
#endif
#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 */
#if (!defined(_LP64) || defined(UMEM_PTHREAD_MUTEX_TOO_BIG)) && !defined(_WIN32)
/* on win32, UMEM_CPU_PAD evaluates to zero, and the MS compiler
* won't allow static initialization of arrays containing structures
* that contain zero size arrays */
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[UMEM_CPU_CACHE_SIZE -
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 */

153
umem_update_thread.c Normal file
View file

@ -0,0 +1,153 @@
/*
* 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.
*/
/*
* Portions Copyright 2006 OmniTI, Inc.
*/
/* #pragma ident "@(#)umem_update_thread.c 1.2 05/06/08 SMI" */
#include "config.h"
#include "umem_base.h"
#include "vmem_base.h"
#include <signal.h>
/*
* we use the _ version, since we don't want to be cancelled.
*/
extern int _cond_timedwait(cond_t *cv, mutex_t *mutex, const timespec_t *delay);
/*ARGSUSED*/
static THR_RETURN
THR_API 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) {
timespec_t abs_time;
abs_time.tv_sec = umem_update_next.tv_sec;
abs_time.tv_nsec = umem_update_next.tv_usec * 1000;
(void) _cond_timedwait(&umem_update_cv,
&umem_update_lock, &abs_time);
}
}
/* LINTED no return statement */
}
int
umem_create_update_thread(void)
{
#ifndef _WIN32
sigset_t sigmask, oldmask;
#endif
ASSERT(MUTEX_HELD(&umem_update_lock));
ASSERT(umem_update_thr == 0);
#ifndef _WIN32
/*
* The update thread handles no signals
*/
(void) sigfillset(&sigmask);
(void) thr_sigsetmask(SIG_BLOCK, &sigmask, &oldmask);
#endif
if (thr_create(NULL, 0, umem_update_thread, NULL,
THR_BOUND | THR_DAEMON | THR_DETACHED, &umem_update_thr) == 0) {
#ifndef _WIN32
(void) thr_sigsetmask(SIG_SETMASK, &oldmask, NULL);
#endif
return (1);
}
umem_update_thr = 0;
#ifndef _WIN32
(void) thr_sigsetmask(SIG_SETMASK, &oldmask, NULL);
#endif
return (0);
}

1804
vmem.c Normal file
View file

File diff suppressed because it is too large Load diff

58
vmem_base.c Normal file
View file

@ -0,0 +1,58 @@
/*
* 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 2005 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/* #pragma ident "@(#)vmem_base.c 1.6 05/06/08 SMI" */
/* #include "mtlib.h" */
#include "config.h"
#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);
}

85
vmem_base.h Normal file
View file

@ -0,0 +1,85 @@
/*
* 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_BASE_H
#define _VMEM_BASE_H
/* #pragma ident "@(#)vmem_base.h 1.3 05/06/08 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 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 */

183
vmem_mmap.c Normal file
View file

@ -0,0 +1,183 @@
/*
* 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.
*/
/*
* Portions Copyright 2006 OmniTI, Inc.
*/
/* #pragma ident "@(#)vmem_mmap.c 1.2 05/06/08 SMI" */
#include "config.h"
#include <errno.h>
#if HAVE_SYS_MMAN_H
#include <sys/mman.h>
#endif
#ifdef HAVE_SYS_SYSMACROS_H
#include <sys/sysmacros.h>
#endif
#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
#ifdef MAP_ALIGN
#define CHUNKSIZE (64*1024) /* 64 kilobytes */
#else
static size_t CHUNKSIZE;
#endif
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);
#ifndef _WIN32
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);
}
#endif
errno = old_errno;
return (ret);
}
static void
vmem_mmap_free(vmem_t *src, void *addr, size_t size)
{
int old_errno = errno;
#ifdef _WIN32
VirtualFree(addr, size, MEM_RELEASE);
#else
(void) mmap(addr, size, FREE_PROT, FREE_FLAGS | MAP_FIXED, -1, 0);
#endif
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
*/
#ifdef _WIN32
buf = VirtualAlloc(NULL, size, MEM_RESERVE|MEM_COMMIT, PAGE_READWRITE);
#else
buf = mmap(
#ifdef MAP_ALIGN
(void *)CHUNKSIZE,
#else
0,
#endif
size, FREE_PROT, FREE_FLAGS
#ifdef MAP_ALIGN
| MAP_ALIGN
#endif
, -1, 0);
#endif
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)
{
#ifdef _WIN32
SYSTEM_INFO info;
size_t pagesize;
#else
size_t pagesize = _sysconf(_SC_PAGESIZE);
#endif
#ifdef _WIN32
GetSystemInfo(&info);
pagesize = info.dwPageSize;
CHUNKSIZE = info.dwAllocationGranularity;
#elif !defined(MAP_ALIGN)
CHUNKSIZE = pagesize;
#endif
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);
}

326
vmem_sbrk.c Normal file
View file

@ -0,0 +1,326 @@
/*
* 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.
*/
/*
* Portions Copyright 2006 OmniTI, Inc.
*/
/* #pragma ident "@(#)vmem_sbrk.c 1.4 05/06/08 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 "config.h"
/* #include "mtlib.h" */
#include <errno.h>
#include <limits.h>
#ifdef HAVE_SYS_SYSMACROS_H
#include <sys/sysmacros.h>
#endif
#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 MIN_ALLOC (64*1024)
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;
/*
* _sbrk_grow_aligned() aligns the old break to a low_align boundry,
* adds min_size, aligns to a high_align boundry, and calls _brk_unlocked()
* to set the new break. The low_aligned-aligned value is returned, and
* the actual space allocated is returned through actual_size.
*
* Unlike sbrk(2), _sbrk_grow_aligned takes an unsigned size, and does
* not allow shrinking the heap.
*/
void *
_sbrk_grow_aligned(size_t min_size, size_t low_align, size_t high_align,
size_t *actual_size)
{
uintptr_t old_brk;
uintptr_t ret_brk;
uintptr_t high_brk;
uintptr_t new_brk;
int brk_result;
#define ALIGNSZ 16
#define BRKALIGN(x) (caddr_t)P2ROUNDUP((uintptr_t)(x), ALIGNSZ)
if ((low_align & (low_align - 1)) != 0 ||
(high_align & (high_align - 1)) != 0) {
errno = EINVAL;
return ((void *)-1);
}
low_align = MAX(low_align, ALIGNSZ);
high_align = MAX(high_align, ALIGNSZ);
old_brk = (uintptr_t)BRKALIGN(sbrk(0));
ret_brk = P2ROUNDUP(old_brk, low_align);
high_brk = ret_brk + min_size;
new_brk = P2ROUNDUP(high_brk, high_align);
/*
* Check for overflow
*/
if (ret_brk < old_brk || high_brk < ret_brk || new_brk < high_brk) {
errno = ENOMEM;
return ((void *)-1);
}
brk_result = brk((void *)new_brk);
if (brk_result != 0)
return ((void *)-1);
if (actual_size != NULL)
*actual_size = (new_brk - ret_brk);
return ((void *)ret_brk);
}
/*
* 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, MIN_ALLOC);
/*
* 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 {
#ifdef MHA_MAPSIZE_BSSBRK
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;
}
#else
heap_size = real_pagesize;
#endif
}
vmem_sbrk_pagesize = 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
vmem_stand.c Normal file
View file

@ -0,0 +1,164 @@
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2004 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "@(#)vmem_stand.c 1.4 05/06/08 SMI"
/*
* Standalone-specific vmem routines
*
* The standalone allocator operates on a pre-existing blob of memory, the
* location and dimensions of which are set using vmem_stand_setsize(). We
* then hand out CHUNKSIZE-sized pieces of this blob, until we run out.
*/
#define DEF_CHUNKSIZE (64 * 1024) /* 64K */
#define DEF_NREGIONS 2
#include <errno.h>
#include <limits.h>
#include <sys/sysmacros.h>
#include <sys/mman.h>
#include <unistd.h>
#include <strings.h>
#include "vmem_base.h"
#include "misc.h"
static vmem_t *stand_heap;
static size_t stand_chunksize;
typedef struct stand_region {
caddr_t sr_base;
caddr_t sr_curtop;
size_t sr_left;
} stand_region_t;
static stand_region_t stand_regions[DEF_NREGIONS];
static int stand_nregions;
extern void membar_producer(void);
void
vmem_stand_init(void)
{
stand_chunksize = MAX(DEF_CHUNKSIZE, pagesize);
stand_nregions = 0;
}
int
vmem_stand_add(caddr_t base, size_t len)
{
stand_region_t *sr = &stand_regions[stand_nregions];
ASSERT(pagesize != 0);
if (stand_nregions == DEF_NREGIONS) {
errno = ENOSPC;
return (-1); /* we don't have room -- throw it back */
}
/*
* We guarantee that only one call to `vmem_stand_add' will be
* active at a time, but we can't ensure that the allocator won't be
* in use while this function is being called. As such, we have to
* ensure that sr is populated and visible to other processors before
* allowing the allocator to access the new region.
*/
sr->sr_base = base;
sr->sr_curtop = (caddr_t)P2ROUNDUP((ulong_t)base, stand_chunksize);
sr->sr_left = P2ALIGN(len - (size_t)(sr->sr_curtop - sr->sr_base),
stand_chunksize);
membar_producer();
stand_nregions++;
return (0);
}
static void *
stand_parent_alloc(vmem_t *src, size_t size, int vmflags)
{
int old_errno = errno;
stand_region_t *sr;
size_t chksize;
void *ret;
int i;
if ((ret = vmem_alloc(src, size, VM_NOSLEEP)) != NULL) {
errno = old_errno;
return (ret);
}
/* We need to allocate another chunk */
chksize = roundup(size, stand_chunksize);
for (sr = stand_regions, i = 0; i < stand_nregions; i++, sr++) {
if (sr->sr_left >= chksize)
break;
}
if (i == stand_nregions) {
/*
* We don't have enough in any of our regions to satisfy the
* request.
*/
errno = old_errno;
return (NULL);
}
if ((ret = _vmem_extend_alloc(src, sr->sr_curtop, chksize, size,
vmflags)) == NULL) {
errno = old_errno;
return (NULL);
}
bzero(sr->sr_curtop, chksize);
sr->sr_curtop += chksize;
sr->sr_left -= chksize;
return (ret);
}
vmem_t *
vmem_stand_arena(vmem_alloc_t **a_out, vmem_free_t **f_out)
{
ASSERT(stand_nregions == 1);
stand_heap = vmem_init("stand_parent", stand_chunksize,
stand_parent_alloc, vmem_free,
"stand_heap", NULL, 0, pagesize, vmem_alloc, vmem_free);
if (a_out != NULL)
*a_out = vmem_alloc;
if (f_out != NULL)
*f_out = vmem_free;
return (stand_heap);
}

49
vmem_stand.h Normal file
View file

@ -0,0 +1,49 @@
/*
* 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 "@(#)vmem_stand.h 1.3 05/06/08 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 */