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

93
static inline size_t
Bob Halley's avatar
base  
Bob Halley committed
94
quantize(size_t size) {
95
	int temp;
Bob Halley's avatar
base  
Bob Halley committed
96 97

	/*
98
	 * Round up the result in order to get a size big
Bob Halley's avatar
base  
Bob Halley committed
99 100 101
	 * enough to satisfy the request and be aligned on ALIGNMENT_SIZE
	 * byte boundaries.
	 */
102 103 104

	temp = size + (ALIGNMENT_SIZE - 1);
	return (temp - temp % ALIGNMENT_SIZE); 
Bob Halley's avatar
base  
Bob Halley committed
105 106 107 108
}

/* Public. */

Bob Halley's avatar
Bob Halley committed
109
isc_result_t
110 111
isc_mem_create(size_t init_max_size, size_t target_size,
	       isc_mem_t **ctxp)
Bob Halley's avatar
Bob Halley committed
112
{
113
	isc_mem_t *ctx;
Bob Halley's avatar
Bob Halley committed
114 115

	REQUIRE(ctxp != NULL && *ctxp == NULL);
Bob Halley's avatar
base  
Bob Halley committed
116 117 118 119 120 121 122 123 124 125

	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
126
	ctx->freelists = malloc(ctx->max_size * sizeof (element *));
Bob Halley's avatar
base  
Bob Halley committed
127 128
	if (ctx->freelists == NULL) {
		free(ctx);
Bob Halley's avatar
Bob Halley committed
129
		return (ISC_R_NOMEMORY);
Bob Halley's avatar
base  
Bob Halley committed
130 131
	}
	memset(ctx->freelists, 0,
Bob Halley's avatar
Bob Halley committed
132
	       ctx->max_size * sizeof (element *));
Bob Halley's avatar
base  
Bob Halley committed
133 134 135 136
	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
137
		return (ISC_R_NOMEMORY);
Bob Halley's avatar
base  
Bob Halley committed
138 139 140
	}
	memset(ctx->stats, 0, (ctx->max_size + 1) * sizeof (struct stats));
	ctx->basic_blocks = NULL;
141 142 143
	ctx->basic_table = NULL;
	ctx->basic_table_count = 0;
	ctx->basic_table_size = 0;
Bob Halley's avatar
base  
Bob Halley committed
144 145
	ctx->lowest = NULL;
	ctx->highest = NULL;
Bob Halley's avatar
Bob Halley committed
146
	if (isc_mutex_init(&ctx->lock) != ISC_R_SUCCESS) {
Bob Halley's avatar
update  
Bob Halley committed
147 148 149
		free(ctx->stats);
		free(ctx->freelists);
		free(ctx);
Bob Halley's avatar
Bob Halley committed
150
		UNEXPECTED_ERROR(__FILE__, __LINE__,
Bob Halley's avatar
Bob Halley committed
151
				 "isc_mutex_init() failed");
Bob Halley's avatar
Bob Halley committed
152
		return (ISC_R_UNEXPECTED);
Bob Halley's avatar
update  
Bob Halley committed
153
	}
154
	ctx->quota = 0;
Bob Halley's avatar
Bob Halley committed
155
	ctx->total = 0;
Bob Halley's avatar
Bob Halley committed
156
	ctx->magic = MEM_MAGIC;
Bob Halley's avatar
base  
Bob Halley committed
157
	*ctxp = ctx;
Bob Halley's avatar
Bob Halley committed
158
	return (ISC_R_SUCCESS);
Bob Halley's avatar
base  
Bob Halley committed
159 160 161
}

void
162
isc_mem_destroy(isc_mem_t **ctxp) {
163
	unsigned int i;
164
	isc_mem_t *ctx;
165

Bob Halley's avatar
base  
Bob Halley committed
166
	REQUIRE(ctxp != NULL);
167
	ctx = *ctxp;
Bob Halley's avatar
Bob Halley committed
168 169 170
	REQUIRE(VALID_CONTEXT(ctx));

	ctx->magic = 0;
171 172 173 174 175 176 177 178 179

	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
180
	(void)isc_mutex_destroy(&ctx->lock);
181
	free(ctx);
Bob Halley's avatar
base  
Bob Halley committed
182 183 184 185

	*ctxp = NULL;
}

186
static void
187
more_basic_blocks(isc_mem_t *ctx) {
188 189 190 191 192
	void *new;
	unsigned char *curr, *next;
	unsigned char *first, *last;
	unsigned char **table;
	unsigned int table_size;
Bob Halley's avatar
Bob Halley committed
193
	size_t increment;
194 195 196 197
	int i;

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

198 199 200
	/*
	 * Did we hit the quota for this context?
	 */
Bob Halley's avatar
Bob Halley committed
201 202 203
	increment = NUM_BASIC_BLOCKS * ctx->mem_target;
	if (ctx->quota != 0 && ctx->total + increment > ctx->quota)
		return;
204 205 206

	INSIST(ctx->basic_table_count <= ctx->basic_table_size);
	if (ctx->basic_table_count == ctx->basic_table_size) {
207 208 209 210
		table_size = ctx->basic_table_size + TABLE_INCREMENT;
		table = malloc(table_size * sizeof (unsigned char *));
		if (table == NULL)
			return;
211 212 213 214 215 216
		if (ctx->basic_table_size != 0) {
			memcpy(table, ctx->basic_table,
			       ctx->basic_table_size *
			       sizeof (unsigned char *));
			free(ctx->basic_table);
		}
217 218
		ctx->basic_table = table;
		ctx->basic_table_size = table_size;
219
	}
220 221

	new = malloc(NUM_BASIC_BLOCKS * ctx->mem_target);
222
	if (new == NULL)
223
		return;
Bob Halley's avatar
Bob Halley committed
224
	ctx->total += increment;
225 226
	ctx->basic_table[ctx->basic_table_count] = new;
	ctx->basic_table_count++;
227

228 229 230
	curr = new;
	next = curr + ctx->mem_target;
	for (i = 0; i < (NUM_BASIC_BLOCKS - 1); i++) {
Bob Halley's avatar
Bob Halley committed
231
		((element *)curr)->next = next;
232 233 234 235 236 237 238
		curr = next;
		next += ctx->mem_target;
	}
	/*
	 * curr is now pointing at the last block in the
	 * array.
	 */
Bob Halley's avatar
Bob Halley committed
239
	((element *)curr)->next = NULL;
240 241 242 243 244 245 246 247 248
	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
249
void *
250
__isc_mem_get(isc_mem_t *ctx, size_t size) {
Bob Halley's avatar
base  
Bob Halley committed
251 252 253 254
	size_t new_size = quantize(size);
	void *ret;

	REQUIRE(size > 0);
Bob Halley's avatar
Bob Halley committed
255 256
	REQUIRE(VALID_CONTEXT(ctx));
	LOCK(&ctx->lock);
Bob Halley's avatar
base  
Bob Halley committed
257 258 259

	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
260 261 262 263
		if (ctx->quota != 0 && ctx->total + size > ctx->quota) {
			ret = NULL;
			goto done;
		}
Bob Halley's avatar
base  
Bob Halley committed
264 265
		ret = malloc(size);
		if (ret != NULL) {
Bob Halley's avatar
Bob Halley committed
266
			ctx->total += size;
Bob Halley's avatar
base  
Bob Halley committed
267 268 269 270 271 272 273 274 275 276 277 278 279 280 281
			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
282
		unsigned char *curr, *next;
Bob Halley's avatar
base  
Bob Halley committed
283 284

		if (ctx->basic_blocks == NULL) {
285 286
			more_basic_blocks(ctx);
			if (ctx->basic_blocks == NULL) {
Bob Halley's avatar
base  
Bob Halley committed
287 288 289 290 291 292 293 294 295 296 297 298 299 300
				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
301
			((element *)curr)->next = next;
Bob Halley's avatar
base  
Bob Halley committed
302 303 304 305
			curr = next;
			next += new_size;
		}
		/* curr is now pointing at the last block in the array. */
Bob Halley's avatar
Bob Halley committed
306
		((element *)curr)->next = NULL;
Bob Halley's avatar
base  
Bob Halley committed
307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324
		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
325
	UNLOCK(&ctx->lock);
Bob Halley's avatar
base  
Bob Halley committed
326

327 328 329 330 331
#if ISC_MEM_FILL
	if (ret != NULL)
		memset(ret, 0xbe, new_size); /* Mnemonic for "beef". */
#endif

Bob Halley's avatar
base  
Bob Halley committed
332 333 334 335
	return (ret);
}

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

	REQUIRE(size > 0);
Bob Halley's avatar
Bob Halley committed
340 341
	REQUIRE(VALID_CONTEXT(ctx));
	LOCK(&ctx->lock);
Bob Halley's avatar
base  
Bob Halley committed
342

343 344 345 346
#if ISC_MEM_FILL
	memset(mem, 0xde, new_size); /* Mnemonic for "dead". */
#endif

Bob Halley's avatar
base  
Bob Halley committed
347 348 349 350 351
	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
352 353
		INSIST(size <= ctx->total);
		ctx->total -= size;
Bob Halley's avatar
base  
Bob Halley committed
354 355 356 357
		goto done;
	}

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

	/* 
	 * 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
372
	UNLOCK(&ctx->lock);
Bob Halley's avatar
base  
Bob Halley committed
373 374 375
}

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

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

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

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

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

	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
420
	UNLOCK(&ctx->lock);
Bob Halley's avatar
base  
Bob Halley committed
421 422
}

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

Bob Halley's avatar
Bob Halley committed
428 429
	REQUIRE(VALID_CONTEXT(ctx));
	LOCK(&ctx->lock);
Bob Halley's avatar
base  
Bob Halley committed
430 431

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

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

Bob Halley's avatar
Bob Halley committed
436
	return (result);
Bob Halley's avatar
base  
Bob Halley committed
437 438 439 440 441 442 443
}

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

void *
444
isc_mem_allocate(isc_mem_t *ctx, size_t size) {
Bob Halley's avatar
Bob Halley committed
445
	size_info *si;
Bob Halley's avatar
base  
Bob Halley committed
446 447

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

void
456
isc_mem_free(isc_mem_t *ctx, void *ptr) {
Bob Halley's avatar
Bob Halley committed
457
	size_info *si;
Bob Halley's avatar
base  
Bob Halley committed
458

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

Bob Halley's avatar
Bob Halley committed
463 464 465 466
/*
 * Other useful things.
 */

Bob Halley's avatar
Bob Halley committed
467 468 469 470 471 472 473 474 475 476 477 478 479 480
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);
}

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 506 507 508
/*
 * 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
509 510
#ifdef ISC_MEMCLUSTER_LEGACY

Bob Halley's avatar
base  
Bob Halley committed
511 512 513 514
/*
 * Public Legacy.
 */

515
static isc_mem_t *default_context = NULL;
Bob Halley's avatar
Bob Halley committed
516

Bob Halley's avatar
base  
Bob Halley committed
517 518 519 520 521
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
522
	return (isc_mem_create(init_max_size, target_size, &default_context));
Bob Halley's avatar
base  
Bob Halley committed
523 524
}

525
isc_mem_t *
Bob Halley's avatar
base  
Bob Halley committed
526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552
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
553
		(unsigned long)size, ptr);
Bob Halley's avatar
base  
Bob Halley committed
554 555 556 557 558 559
	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
560
		ptr, (unsigned long)size);
Bob Halley's avatar
base  
Bob Halley committed
561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576
	__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
577 578

#endif /* ISC_MEMCLUSTER_LEGACY */