mem.c 12.6 KB
Newer Older
Bob Halley's avatar
base  
Bob Halley committed
1
/*
Bob Halley's avatar
Bob Halley committed
2
 * Copyright (C) 1997, 1998, 1999  Internet Software Consortium.
Bob Halley's avatar
Bob Halley committed
3
 * 
Bob Halley's avatar
base  
Bob Halley committed
4 5 6
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
Bob Halley's avatar
Bob Halley committed
7
 * 
Bob Halley's avatar
base  
Bob Halley committed
8 9 10 11 12 13 14 15 16 17
 * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
 * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
 * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
 * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 * SOFTWARE.
 */

Bob Halley's avatar
Bob Halley committed
18
#include <config.h>
Bob Halley's avatar
base  
Bob Halley committed
19 20 21

#include <stdio.h>
#include <stdlib.h>
Bob Halley's avatar
Bob Halley committed
22
#include <stddef.h>
Bob Halley's avatar
base  
Bob Halley committed
23 24 25
#include <string.h>

#include <isc/assertions.h>
26
#include <isc/error.h>
Bob Halley's avatar
Bob Halley committed
27
#include <isc/mem.h>
Bob Halley's avatar
Bob Halley committed
28

29
#ifndef ISC_SINGLETHREADED
Bob Halley's avatar
update  
Bob Halley committed
30
#include <isc/mutex.h>
Bob Halley's avatar
Bob Halley committed
31 32
#include "util.h"
#else
Bob Halley's avatar
Bob Halley committed
33 34
#define LOCK(l)
#define UNLOCK(l)
Bob Halley's avatar
update  
Bob Halley committed
35 36
#endif

Bob Halley's avatar
base  
Bob Halley committed
37 38 39 40 41 42
/*
 * Types.
 */

typedef struct {
	void *			next;
Bob Halley's avatar
Bob Halley committed
43
} element;
Bob Halley's avatar
base  
Bob Halley committed
44 45 46 47 48 49

typedef struct {
	size_t			size;
	/*
	 * This structure must be ALIGNMENT_SIZE bytes.
	 */
Bob Halley's avatar
Bob Halley committed
50
} size_info;
Bob Halley's avatar
base  
Bob Halley committed
51 52

struct stats {
Bob Halley's avatar
Bob Halley committed
53 54 55 56
	unsigned long		gets;
	unsigned long		totalgets;
	unsigned long		blocks;
	unsigned long		freefrags;
Bob Halley's avatar
base  
Bob Halley committed
57 58
};

59 60
#define MEM_MAGIC		0x4D656d43U	/* MemC. */
#define VALID_CONTEXT(c)	((c) != NULL && (c)->magic == MEM_MAGIC)
Bob Halley's avatar
Bob Halley committed
61

62
struct isc_mem {
Bob Halley's avatar
Bob Halley committed
63 64
	unsigned int		magic;
	isc_mutex_t		lock;
Bob Halley's avatar
base  
Bob Halley committed
65 66
	size_t			max_size;
	size_t			mem_target;
Bob Halley's avatar
Bob Halley committed
67 68
	element **		freelists;
	element *		basic_blocks;
69 70 71
	unsigned char **	basic_table;
	unsigned int		basic_table_count;
	unsigned int		basic_table_size;
Bob Halley's avatar
Bob Halley committed
72 73
	unsigned char *		lowest;
	unsigned char *		highest;
Bob Halley's avatar
base  
Bob Halley committed
74
	struct stats *		stats;
75
	size_t			quota;
Bob Halley's avatar
Bob Halley committed
76
	size_t			total;
Bob Halley's avatar
base  
Bob Halley committed
77 78 79 80 81 82
};

/* Forward. */

static size_t			quantize(size_t);

Bob Halley's avatar
Bob Halley committed
83
/* Constants. */
Bob Halley's avatar
base  
Bob Halley committed
84 85 86 87 88

#define DEF_MAX_SIZE		1100
#define DEF_MEM_TARGET		4096
#define ALIGNMENT_SIZE		sizeof (void *)
#define NUM_BASIC_BLOCKS	64			/* must be > 1 */
89
#define TABLE_INCREMENT		1024
Bob Halley's avatar
base  
Bob Halley committed
90 91 92

/* Private Inline-able. */

Bob Halley's avatar
update  
Bob Halley committed
93
static inline size_t 
Bob Halley's avatar
base  
Bob Halley committed
94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114
quantize(size_t size) {
	int remainder;

	/*
	 * If there is no remainder for the integer division of 
	 *
	 *	(rightsize/ALIGNMENT_SIZE)
	 *
	 * then we already have a good size; if not, then we need
	 * to round up the result in order to get a size big
	 * enough to satisfy the request and be aligned on ALIGNMENT_SIZE
	 * byte boundaries.
	 */
	remainder = size % ALIGNMENT_SIZE;
	if (remainder != 0)
        	size += ALIGNMENT_SIZE - remainder;
	return (size);
}

/* Public. */

Bob Halley's avatar
Bob Halley committed
115
isc_result_t
116 117
isc_mem_create(size_t init_max_size, size_t target_size,
	       isc_mem_t **ctxp)
Bob Halley's avatar
Bob Halley committed
118
{
119
	isc_mem_t *ctx;
Bob Halley's avatar
Bob Halley committed
120 121

	REQUIRE(ctxp != NULL && *ctxp == NULL);
Bob Halley's avatar
base  
Bob Halley committed
122 123 124 125 126 127 128 129 130 131

	ctx = malloc(sizeof *ctx);
	if (init_max_size == 0)
		ctx->max_size = DEF_MAX_SIZE;
	else
		ctx->max_size = init_max_size;
	if (target_size == 0)
		ctx->mem_target = DEF_MEM_TARGET;
	else
		ctx->mem_target = target_size;
Bob Halley's avatar
Bob Halley committed
132
	ctx->freelists = malloc(ctx->max_size * sizeof (element *));
Bob Halley's avatar
base  
Bob Halley committed
133 134
	if (ctx->freelists == NULL) {
		free(ctx);
Bob Halley's avatar
Bob Halley committed
135
		return (ISC_R_NOMEMORY);
Bob Halley's avatar
base  
Bob Halley committed
136 137
	}
	memset(ctx->freelists, 0,
Bob Halley's avatar
Bob Halley committed
138
	       ctx->max_size * sizeof (element *));
Bob Halley's avatar
base  
Bob Halley committed
139 140 141 142
	ctx->stats = malloc((ctx->max_size+1) * sizeof (struct stats));
	if (ctx->stats == NULL) {
		free(ctx->freelists);
		free(ctx);
Bob Halley's avatar
Bob Halley committed
143
		return (ISC_R_NOMEMORY);
Bob Halley's avatar
base  
Bob Halley committed
144 145 146
	}
	memset(ctx->stats, 0, (ctx->max_size + 1) * sizeof (struct stats));
	ctx->basic_blocks = NULL;
147 148 149
	ctx->basic_table = NULL;
	ctx->basic_table_count = 0;
	ctx->basic_table_size = 0;
Bob Halley's avatar
base  
Bob Halley committed
150 151
	ctx->lowest = NULL;
	ctx->highest = NULL;
Bob Halley's avatar
Bob Halley committed
152
	if (isc_mutex_init(&ctx->lock) != ISC_R_SUCCESS) {
Bob Halley's avatar
update  
Bob Halley committed
153 154 155
		free(ctx->stats);
		free(ctx->freelists);
		free(ctx);
Bob Halley's avatar
Bob Halley committed
156
		UNEXPECTED_ERROR(__FILE__, __LINE__,
Bob Halley's avatar
Bob Halley committed
157
				 "isc_mutex_init() failed");
Bob Halley's avatar
Bob Halley committed
158
		return (ISC_R_UNEXPECTED);
Bob Halley's avatar
update  
Bob Halley committed
159
	}
160
	ctx->quota = 0;
Bob Halley's avatar
Bob Halley committed
161
	ctx->total = 0;
Bob Halley's avatar
Bob Halley committed
162
	ctx->magic = MEM_MAGIC;
Bob Halley's avatar
base  
Bob Halley committed
163
	*ctxp = ctx;
Bob Halley's avatar
Bob Halley committed
164
	return (ISC_R_SUCCESS);
Bob Halley's avatar
base  
Bob Halley committed
165 166 167
}

void
168
isc_mem_destroy(isc_mem_t **ctxp) {
169
	unsigned int i;
170
	isc_mem_t *ctx;
171

Bob Halley's avatar
base  
Bob Halley committed
172
	REQUIRE(ctxp != NULL);
173
	ctx = *ctxp;
Bob Halley's avatar
Bob Halley committed
174 175 176
	REQUIRE(VALID_CONTEXT(ctx));

	ctx->magic = 0;
177 178 179 180 181 182 183 184 185

	for (i = 0; i <= ctx->max_size; i++)
		INSIST(ctx->stats[i].gets == 0);

	for (i = 0; i < ctx->basic_table_count; i++)
		free(ctx->basic_table[i]);
	free(ctx->freelists);
	free(ctx->stats);
	free(ctx->basic_table);
Bob Halley's avatar
Bob Halley committed
186
	(void)isc_mutex_destroy(&ctx->lock);
187
	free(ctx);
Bob Halley's avatar
base  
Bob Halley committed
188 189 190 191

	*ctxp = NULL;
}

192
static void
193
more_basic_blocks(isc_mem_t *ctx) {
194 195 196 197 198
	void *new;
	unsigned char *curr, *next;
	unsigned char *first, *last;
	unsigned char **table;
	unsigned int table_size;
Bob Halley's avatar
Bob Halley committed
199
	size_t increment;
200 201 202 203
	int i;

	/* Require: we hold the context lock. */

204 205 206
	/*
	 * Did we hit the quota for this context?
	 */
Bob Halley's avatar
Bob Halley committed
207 208 209
	increment = NUM_BASIC_BLOCKS * ctx->mem_target;
	if (ctx->quota != 0 && ctx->total + increment > ctx->quota)
		return;
210 211 212

	INSIST(ctx->basic_table_count <= ctx->basic_table_size);
	if (ctx->basic_table_count == ctx->basic_table_size) {
213 214 215 216
		table_size = ctx->basic_table_size + TABLE_INCREMENT;
		table = malloc(table_size * sizeof (unsigned char *));
		if (table == NULL)
			return;
217 218 219 220 221 222
		if (ctx->basic_table_size != 0) {
			memcpy(table, ctx->basic_table,
			       ctx->basic_table_size *
			       sizeof (unsigned char *));
			free(ctx->basic_table);
		}
223 224
		ctx->basic_table = table;
		ctx->basic_table_size = table_size;
225
	}
226 227

	new = malloc(NUM_BASIC_BLOCKS * ctx->mem_target);
228
	if (new == NULL)
229
		return;
Bob Halley's avatar
Bob Halley committed
230
	ctx->total += increment;
231 232
	ctx->basic_table[ctx->basic_table_count] = new;
	ctx->basic_table_count++;
233

234 235 236
	curr = new;
	next = curr + ctx->mem_target;
	for (i = 0; i < (NUM_BASIC_BLOCKS - 1); i++) {
Bob Halley's avatar
Bob Halley committed
237
		((element *)curr)->next = next;
238 239 240 241 242 243 244
		curr = next;
		next += ctx->mem_target;
	}
	/*
	 * curr is now pointing at the last block in the
	 * array.
	 */
Bob Halley's avatar
Bob Halley committed
245
	((element *)curr)->next = NULL;
246 247 248 249 250 251 252 253 254
	first = new;
	last = first + NUM_BASIC_BLOCKS * ctx->mem_target - 1;
	if (first < ctx->lowest || ctx->lowest == NULL)
		ctx->lowest = first;
	if (last > ctx->highest)
		ctx->highest = last;
	ctx->basic_blocks = new;
}

Bob Halley's avatar
base  
Bob Halley committed
255
void *
256
__isc_mem_get(isc_mem_t *ctx, size_t size) {
Bob Halley's avatar
base  
Bob Halley committed
257 258 259 260
	size_t new_size = quantize(size);
	void *ret;

	REQUIRE(size > 0);
Bob Halley's avatar
Bob Halley committed
261 262
	REQUIRE(VALID_CONTEXT(ctx));
	LOCK(&ctx->lock);
Bob Halley's avatar
base  
Bob Halley committed
263 264 265

	if (size >= ctx->max_size || new_size >= ctx->max_size) {
		/* memget() was called on something beyond our upper limit. */
Bob Halley's avatar
Bob Halley committed
266 267 268 269
		if (ctx->quota != 0 && ctx->total + size > ctx->quota) {
			ret = NULL;
			goto done;
		}
Bob Halley's avatar
base  
Bob Halley committed
270 271
		ret = malloc(size);
		if (ret != NULL) {
Bob Halley's avatar
Bob Halley committed
272
			ctx->total += size;
Bob Halley's avatar
base  
Bob Halley committed
273 274 275 276 277 278 279 280 281 282 283 284 285 286 287
			ctx->stats[ctx->max_size].gets++;
			ctx->stats[ctx->max_size].totalgets++;
		}
		goto done;
	}

	/* 
	 * If there are no blocks in the free list for this size, get a chunk
	 * of memory and then break it up into "new_size"-sized blocks, adding
	 * them to the free list.
	 */
	if (ctx->freelists[new_size] == NULL) {
		int i, frags;
		size_t total_size;
		void *new;
Bob Halley's avatar
Bob Halley committed
288
		unsigned char *curr, *next;
Bob Halley's avatar
base  
Bob Halley committed
289 290

		if (ctx->basic_blocks == NULL) {
291 292
			more_basic_blocks(ctx);
			if (ctx->basic_blocks == NULL) {
Bob Halley's avatar
base  
Bob Halley committed
293 294 295 296 297 298 299 300 301 302 303 304 305 306
				ret = NULL;
				goto done;
			}
		}
		total_size = ctx->mem_target;
		new = ctx->basic_blocks;
		ctx->basic_blocks = ctx->basic_blocks->next;
		frags = total_size / new_size;
		ctx->stats[new_size].blocks++;
		ctx->stats[new_size].freefrags += frags;
		/* Set up a linked-list of blocks of size "new_size". */
		curr = new;
		next = curr + new_size;
		for (i = 0; i < (frags - 1); i++) {
Bob Halley's avatar
Bob Halley committed
307
			((element *)curr)->next = next;
Bob Halley's avatar
base  
Bob Halley committed
308 309 310 311
			curr = next;
			next += new_size;
		}
		/* curr is now pointing at the last block in the array. */
Bob Halley's avatar
Bob Halley committed
312
		((element *)curr)->next = NULL;
Bob Halley's avatar
base  
Bob Halley committed
313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330
		ctx->freelists[new_size] = new;
	}

	/* The free list uses the "rounded-up" size "new_size": */
	ret = ctx->freelists[new_size];
	ctx->freelists[new_size] = ctx->freelists[new_size]->next;

	/* 
	 * The stats[] uses the _actual_ "size" requested by the
	 * caller, with the caveat (in the code above) that "size" >= the
	 * max. size (max_size) ends up getting recorded as a call to
	 * max_size.
	 */
	ctx->stats[size].gets++;
	ctx->stats[size].totalgets++;
	ctx->stats[new_size].freefrags--;

 done:
Bob Halley's avatar
Bob Halley committed
331
	UNLOCK(&ctx->lock);
Bob Halley's avatar
base  
Bob Halley committed
332 333 334 335 336

	return (ret);
}

void
337
__isc_mem_put(isc_mem_t *ctx, void *mem, size_t size) {
Bob Halley's avatar
base  
Bob Halley committed
338 339 340
	size_t new_size = quantize(size);

	REQUIRE(size > 0);
Bob Halley's avatar
Bob Halley committed
341 342
	REQUIRE(VALID_CONTEXT(ctx));
	LOCK(&ctx->lock);
Bob Halley's avatar
base  
Bob Halley committed
343 344 345 346 347 348

	if (size == ctx->max_size || new_size >= ctx->max_size) {
		/* memput() called on something beyond our upper limit */
		free(mem);
		INSIST(ctx->stats[ctx->max_size].gets != 0);
		ctx->stats[ctx->max_size].gets--;
Bob Halley's avatar
Bob Halley committed
349 350
		INSIST(size <= ctx->total);
		ctx->total -= size;
Bob Halley's avatar
base  
Bob Halley committed
351 352 353 354
		goto done;
	}

	/* The free list uses the "rounded-up" size "new_size": */
Bob Halley's avatar
Bob Halley committed
355 356
	((element *)mem)->next = ctx->freelists[new_size];
	ctx->freelists[new_size] = (element *)mem;
Bob Halley's avatar
base  
Bob Halley committed
357 358 359 360 361 362 363 364 365 366 367 368

	/* 
	 * The stats[] uses the _actual_ "size" requested by the
	 * caller, with the caveat (in the code above) that "size" >= the
	 * max. size (max_size) ends up getting recorded as a call to
	 * max_size.
	 */
	INSIST(ctx->stats[size].gets != 0);
	ctx->stats[size].gets--;
	ctx->stats[new_size].freefrags++;

 done:
Bob Halley's avatar
Bob Halley committed
369
	UNLOCK(&ctx->lock);
Bob Halley's avatar
base  
Bob Halley committed
370 371 372
}

void *
373
__isc_mem_getdebug(isc_mem_t *ctx, size_t size, const char *file, int line) {
Bob Halley's avatar
base  
Bob Halley committed
374
	void *ptr;
Bob Halley's avatar
Bob Halley committed
375

376
	ptr = __isc_mem_get(ctx, size);
Bob Halley's avatar
base  
Bob Halley committed
377
	fprintf(stderr, "%s:%d: mem_get(%p, %lu) -> %p\n", file, line,
Bob Halley's avatar
Bob Halley committed
378
		ctx, (unsigned long)size, ptr);
Bob Halley's avatar
base  
Bob Halley committed
379 380 381 382
	return (ptr);
}

void
383
__isc_mem_putdebug(isc_mem_t *ctx, void *ptr, size_t size, const char *file,
Bob Halley's avatar
Bob Halley committed
384
		 int line)
Bob Halley's avatar
base  
Bob Halley committed
385 386
{
	fprintf(stderr, "%s:%d: mem_put(%p, %p, %lu)\n", file, line, 
Bob Halley's avatar
Bob Halley committed
387
		ctx, ptr, (unsigned long)size);
388
	__isc_mem_put(ctx, ptr, size);
Bob Halley's avatar
base  
Bob Halley committed
389 390 391 392 393 394
}

/*
 * Print the stats[] on the stream "out" with suitable formatting.
 */
void
395
isc_mem_stats(isc_mem_t *ctx, FILE *out) {
Bob Halley's avatar
base  
Bob Halley committed
396 397
	size_t i;

Bob Halley's avatar
Bob Halley committed
398 399
	REQUIRE(VALID_CONTEXT(ctx));
	LOCK(&ctx->lock);
Bob Halley's avatar
base  
Bob Halley committed
400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416

	if (ctx->freelists == NULL)
		return;
	for (i = 1; i <= ctx->max_size; i++) {
		const struct stats *s = &ctx->stats[i];

		if (s->totalgets == 0 && s->gets == 0)
			continue;
		fprintf(out, "%s%5d: %11lu gets, %11lu rem",
			(i == ctx->max_size) ? ">=" : "  ",
			i, s->totalgets, s->gets);
		if (s->blocks != 0)
			fprintf(out, " (%lu bl, %lu ff)",
				s->blocks, s->freefrags);
		fputc('\n', out);
	}

Bob Halley's avatar
Bob Halley committed
417
	UNLOCK(&ctx->lock);
Bob Halley's avatar
base  
Bob Halley committed
418 419
}

Bob Halley's avatar
Bob Halley committed
420
isc_boolean_t
421
isc_mem_valid(isc_mem_t *ctx, void *ptr) {
Bob Halley's avatar
Bob Halley committed
422
	unsigned char *cp = ptr;
Bob Halley's avatar
Bob Halley committed
423
	isc_boolean_t result = ISC_FALSE;
Bob Halley's avatar
base  
Bob Halley committed
424

Bob Halley's avatar
Bob Halley committed
425 426
	REQUIRE(VALID_CONTEXT(ctx));
	LOCK(&ctx->lock);
Bob Halley's avatar
base  
Bob Halley committed
427 428

	if (ctx->lowest != NULL && cp >= ctx->lowest && cp <= ctx->highest)
Bob Halley's avatar
Bob Halley committed
429
		result = ISC_TRUE;
Bob Halley's avatar
base  
Bob Halley committed
430

Bob Halley's avatar
Bob Halley committed
431
	UNLOCK(&ctx->lock);
Bob Halley's avatar
base  
Bob Halley committed
432

Bob Halley's avatar
Bob Halley committed
433
	return (result);
Bob Halley's avatar
base  
Bob Halley committed
434 435 436 437 438 439 440
}

/*
 * Replacements for malloc() and free().
 */

void *
441
isc_mem_allocate(isc_mem_t *ctx, size_t size) {
Bob Halley's avatar
Bob Halley committed
442
	size_info *si;
Bob Halley's avatar
base  
Bob Halley committed
443 444

	size += ALIGNMENT_SIZE;
Bob Halley's avatar
Bob Halley committed
445
	si = isc_mem_get(ctx, size);
Bob Halley's avatar
base  
Bob Halley committed
446 447 448 449 450 451 452
	if (si == NULL)
		return (NULL);
	si->size = size;
	return (&si[1]);
}

void
453
isc_mem_free(isc_mem_t *ctx, void *ptr) {
Bob Halley's avatar
Bob Halley committed
454
	size_info *si;
Bob Halley's avatar
base  
Bob Halley committed
455

Bob Halley's avatar
Bob Halley committed
456
	si = &(((size_info *)ptr)[-1]);
Bob Halley's avatar
Bob Halley committed
457
	isc_mem_put(ctx, si, si->size);
Bob Halley's avatar
base  
Bob Halley committed
458 459
}

Bob Halley's avatar
Bob Halley committed
460 461 462 463
/*
 * Other useful things.
 */

Bob Halley's avatar
Bob Halley committed
464 465 466 467 468 469 470 471 472 473 474 475 476 477
char *
isc_mem_strdup(isc_mem_t *mctx, const char *s) {
	size_t len;
	char *ns;

	len = strlen(s);
	ns = isc_mem_allocate(mctx, len + 1);
	if (ns == NULL)
		return (NULL);
	strncpy(ns, s, len + 1);
	
	return (ns);
}

478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505
/*
 * Quotas
 */

void
isc_mem_setquota(isc_mem_t *ctx, size_t quota) {
	REQUIRE(VALID_CONTEXT(ctx));
	LOCK(&ctx->lock);

	ctx->quota = quota;

	UNLOCK(&ctx->lock);
}

size_t
isc_mem_getquota(isc_mem_t *ctx) {
	size_t quota;

	REQUIRE(VALID_CONTEXT(ctx));
	LOCK(&ctx->lock);

	quota = ctx->quota;

	UNLOCK(&ctx->lock);

	return (quota);
}

Bob Halley's avatar
Bob Halley committed
506 507
#ifdef ISC_MEMCLUSTER_LEGACY

Bob Halley's avatar
base  
Bob Halley committed
508 509 510 511
/*
 * Public Legacy.
 */

512
static isc_mem_t *default_context = NULL;
Bob Halley's avatar
Bob Halley committed
513

Bob Halley's avatar
base  
Bob Halley committed
514 515 516 517 518
int
meminit(size_t init_max_size, size_t target_size) {
	/* need default_context lock here */
	if (default_context != NULL)
		return (-1);
Bob Halley's avatar
Bob Halley committed
519
	return (isc_mem_create(init_max_size, target_size, &default_context));
Bob Halley's avatar
base  
Bob Halley committed
520 521
}

522
isc_mem_t *
Bob Halley's avatar
base  
Bob Halley committed
523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549
mem_default_context(void) {
	/* need default_context lock here */
	if (default_context == NULL && meminit(0, 0) == -1)
		return (NULL);
	return (default_context);
}

void *
__memget(size_t size) {
	/* need default_context lock here */
	if (default_context == NULL && meminit(0, 0) == -1)
		return (NULL);
	return (__mem_get(default_context, size));
}

void
__memput(void *mem, size_t size) {
	/* need default_context lock here */
	REQUIRE(default_context != NULL);
	__mem_put(default_context, mem, size);
}

void *
__memget_debug(size_t size, const char *file, int line) {
	void *ptr;
	ptr = __memget(size);
	fprintf(stderr, "%s:%d: memget(%lu) -> %p\n", file, line,
Bob Halley's avatar
Bob Halley committed
550
		(unsigned long)size, ptr);
Bob Halley's avatar
base  
Bob Halley committed
551 552 553 554 555 556
	return (ptr);
}

void
__memput_debug(void *ptr, size_t size, const char *file, int line) {
	fprintf(stderr, "%s:%d: memput(%p, %lu)\n", file, line, 
Bob Halley's avatar
Bob Halley committed
557
		ptr, (unsigned long)size);
Bob Halley's avatar
base  
Bob Halley committed
558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573
	__memput(ptr, size);
}

int
memvalid(void *ptr) {
	/* need default_context lock here */
	REQUIRE(default_context != NULL);
	return (mem_valid(default_context, ptr));
}

void
memstats(FILE *out) {
	/* need default_context lock here */
	REQUIRE(default_context != NULL);
	mem_stats(default_context, out);
}
Bob Halley's avatar
Bob Halley committed
574 575

#endif /* ISC_MEMCLUSTER_LEGACY */