mem.c 35.3 KB
Newer Older
Bob Halley's avatar
base  
Bob Halley committed
1
/*
David Lawrence's avatar
David Lawrence committed
2
 * Copyright (C) 1997-2000  Internet Software Consortium.
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.
7
 *
8
9
10
11
12
13
14
15
 * 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
base  
Bob Halley committed
16
17
 */

18
/* $Id: mem.c,v 1.76 2000/12/29 01:02:07 bwelling Exp $ */
David Lawrence's avatar
David Lawrence committed
19

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

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

Michael Graff's avatar
Michael Graff committed
26
27
#include <limits.h>

Bob Halley's avatar
Bob Halley committed
28
#include <isc/mem.h>
29
#include <isc/msgs.h>
30
#include <isc/ondestroy.h>
31
#include <isc/string.h>
Bob Halley's avatar
Bob Halley committed
32

Bob Halley's avatar
update    
Bob Halley committed
33
#include <isc/mutex.h>
Michael Graff's avatar
Michael Graff committed
34
#include <isc/util.h>
Bob Halley's avatar
update    
Bob Halley committed
35

36
unsigned int isc_mem_debugging = 0;
37
38
39
40
41
42
43

/*
 * Constants.
 */

#define DEF_MAX_SIZE		1100
#define DEF_MEM_TARGET		4096
44
45
#define ALIGNMENT_SIZE		8		/* must be a power of 2 */
#define NUM_BASIC_BLOCKS	64		/* must be > 1 */
46
#define TABLE_INCREMENT		1024
Michael Graff's avatar
Michael Graff committed
47
#define DEBUGLIST_COUNT		1024
48

Bob Halley's avatar
base  
Bob Halley committed
49
50
51
/*
 * Types.
 */
52
#if ISC_MEM_TRACKLINES
Michael Graff's avatar
Michael Graff committed
53
54
55
56
57
58
59
60
typedef struct debuglink debuglink_t;
struct debuglink {
	ISC_LINK(debuglink_t)	link;
	const void	       *ptr[DEBUGLIST_COUNT];
	const char	       *file[DEBUGLIST_COUNT];
	unsigned int		line[DEBUGLIST_COUNT];
	unsigned int		count;
};
Bob Halley's avatar
base  
Bob Halley committed
61

Michael Graff's avatar
Michael Graff committed
62
63
64
65
66
67
#define FLARG_PASS	, file, line
#define FLARG		, const char *file, int line
#else
#define FLARG_PASS
#define FLARG
#endif
68

Michael Graff's avatar
Michael Graff committed
69
typedef struct element element;
70
71
72
struct element {
	element *		next;
};
Bob Halley's avatar
base  
Bob Halley committed
73
74
75
76
77

typedef struct {
	/*
	 * This structure must be ALIGNMENT_SIZE bytes.
	 */
78
79
80
81
	union {
		size_t		size;
		char		bytes[ALIGNMENT_SIZE];
	} u;
Bob Halley's avatar
Bob Halley committed
82
} size_info;
Bob Halley's avatar
base  
Bob Halley committed
83
84

struct stats {
Bob Halley's avatar
Bob Halley committed
85
86
87
88
	unsigned long		gets;
	unsigned long		totalgets;
	unsigned long		blocks;
	unsigned long		freefrags;
Bob Halley's avatar
base  
Bob Halley committed
89
90
};

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

94
struct isc_mem {
Bob Halley's avatar
Bob Halley committed
95
	unsigned int		magic;
96
	isc_ondestroy_t		ondestroy;
Bob Halley's avatar
Bob Halley committed
97
	isc_mutex_t		lock;
98
99
100
	isc_memalloc_t		memalloc;
	isc_memfree_t		memfree;
	void *			arg;
Bob Halley's avatar
base  
Bob Halley committed
101
102
	size_t			max_size;
	size_t			mem_target;
Bob Halley's avatar
Bob Halley committed
103
104
	element **		freelists;
	element *		basic_blocks;
105
106
107
	unsigned char **	basic_table;
	unsigned int		basic_table_count;
	unsigned int		basic_table_size;
Bob Halley's avatar
Bob Halley committed
108
109
	unsigned char *		lowest;
	unsigned char *		highest;
110
	isc_boolean_t		checkfree;
111
	isc_boolean_t		trysplit;
Bob Halley's avatar
base  
Bob Halley committed
112
	struct stats *		stats;
113
	unsigned int		references;
114
	size_t			quota;
Bob Halley's avatar
Bob Halley committed
115
	size_t			total;
116
	size_t			inuse;
117
118
119
120
121
	size_t			hi_water;
	size_t			lo_water;
	isc_boolean_t		hi_called;
	isc_mem_water_t		water;
	void *			water_arg;
Michael Graff's avatar
Michael Graff committed
122
	ISC_LIST(isc_mempool_t)	pools;
123
#if ISC_MEM_TRACKLINES
Michael Graff's avatar
Michael Graff committed
124
125
	ISC_LIST(debuglink_t)	debuglist;
#endif
Michael Graff's avatar
Michael Graff committed
126
127
128
129
130
131
};

#define MEMPOOL_MAGIC		0x4D454d70U	/* MEMp. */
#define VALID_MEMPOOL(c)	((c) != NULL && (c)->magic == MEMPOOL_MAGIC)

struct isc_mempool {
Michael Graff's avatar
Michael Graff committed
132
	/* always unlocked */
Michael Graff's avatar
Michael Graff committed
133
	unsigned int	magic;		/* magic number */
Michael Graff's avatar
Michael Graff committed
134
	isc_mutex_t    *lock;		/* optional lock */
Michael Graff's avatar
Michael Graff committed
135
	isc_mem_t      *mctx;		/* our memory context */
Michael Graff's avatar
Michael Graff committed
136
137
138
	/* locked via the memory context's lock */
	ISC_LINK(isc_mempool_t)	link;	/* next pool in this mem context */
	/* optionally locked from here down */
Michael Graff's avatar
Michael Graff committed
139
140
141
142
143
144
145
146
147
	element	       *items;		/* low water item list */
	size_t		size;		/* size of each item on this pool */
	unsigned int	maxalloc;	/* max number of items allowed */
	unsigned int	allocated;	/* # of items currently given out */
	unsigned int	freecount;	/* # of items on reserved list */
	unsigned int	freemax;	/* # of items allowed on free list */
	unsigned int	fillcount;	/* # of items to fetch on each fill */
	/* Stats only. */
	unsigned int	gets;		/* # of requests to this pool */
Michael Graff's avatar
Michael Graff committed
148
	/* Debugging only. */
149
#if ISC_MEMPOOL_NAMES
Michael Graff's avatar
Michael Graff committed
150
151
	char		name[16];	/* printed name in stats reports */
#endif
Bob Halley's avatar
base  
Bob Halley committed
152
153
};

154
155
156
/*
 * Private Inline-able.
 */
Bob Halley's avatar
base  
Bob Halley committed
157

158
#if ! ISC_MEM_TRACKLINES
Michael Graff's avatar
Michael Graff committed
159
160
161
162
163
164
165
166
167
168
169
170
171
172
#define ADD_TRACE(a, b, c, d, e)
#define DELETE_TRACE(a, b, c, d, e)
#else
#define ADD_TRACE(a, b, c, d, e)	add_trace_entry(a, b, c, d, e)
#define DELETE_TRACE(a, b, c, d, e)	delete_trace_entry(a, b, c, d, e)

#define MEM_TRACE	((isc_mem_debugging & ISC_MEM_DEBUGTRACE) != 0)
#define MEM_RECORD	((isc_mem_debugging & ISC_MEM_DEBUGRECORD) != 0)

/*
 * mctx must be locked.
 */
static inline void
add_trace_entry(isc_mem_t *mctx, const void *ptr, unsigned int size
Michael Graff's avatar
pasto    
Michael Graff committed
173
		FLARG)
Michael Graff's avatar
Michael Graff committed
174
175
176
177
178
{
	debuglink_t *dl;
	unsigned int i;

	if (MEM_TRACE)
179
180
181
182
		fprintf(stderr, isc_msgcat_get(isc_msgcat, ISC_MSGSET_MEM,
					       ISC_MSG_ADDTRACE,
					       "add %p size %u "
					       "file %s line %u mctx %p\n"),
183
			ptr, size, file, line, mctx);
Michael Graff's avatar
Michael Graff committed
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230

	if (!MEM_RECORD)
		return;

	dl = ISC_LIST_HEAD(mctx->debuglist);
	while (dl != NULL) {
		if (dl->count == DEBUGLIST_COUNT)
			goto next;
		for (i = 0 ; i < DEBUGLIST_COUNT ; i++) {
			if (dl->ptr[i] == NULL) {
				dl->ptr[i] = ptr;
				dl->file[i] = file;
				dl->line[i] = line;
				dl->count++;
				return;
			}
		}
	next:
		dl = ISC_LIST_NEXT(dl, link);
	}

	dl = malloc(sizeof(debuglink_t));
	INSIST(dl != NULL);

	ISC_LINK_INIT(dl, link);
	for (i = 1 ; i < DEBUGLIST_COUNT ; i++) {
		dl->ptr[i] = NULL;
		dl->file[i] = NULL;
		dl->line[i] = 0;
	}

	dl->ptr[0] = ptr;
	dl->file[0] = file;
	dl->line[0] = line;
	dl->count = 1;

	ISC_LIST_PREPEND(mctx->debuglist, dl, link);
}

static inline void
delete_trace_entry(isc_mem_t *mctx, const void *ptr, unsigned int size,
		   const char *file, unsigned int line)
{
	debuglink_t *dl;
	unsigned int i;

	if (MEM_TRACE)
231
232
233
234
		fprintf(stderr, isc_msgcat_get(isc_msgcat, ISC_MSGSET_MEM,
					       ISC_MSG_DELTRACE,
					       "del %p size %u "
					       "file %s line %u mctx %p\n"),
235
			ptr, size, file, line, mctx);
Michael Graff's avatar
Michael Graff committed
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268

	if (!MEM_RECORD)
		return;

	dl = ISC_LIST_HEAD(mctx->debuglist);
	while (dl != NULL) {
		for (i = 0 ; i < DEBUGLIST_COUNT ; i++) {
			if (dl->ptr[i] == ptr) {
				dl->ptr[i] = NULL;
				dl->file[i] = NULL;
				dl->line[i] = 0;

				INSIST(dl->count > 0);
				dl->count--;
				if (dl->count == 0) {
					ISC_LIST_UNLINK(mctx->debuglist,
							dl, link);
					free(dl);
				}
				return;
			}
		}
		dl = ISC_LIST_NEXT(dl, link);
	}

	/*
	 * If we get here, we didn't find the item on the list.  We're
	 * screwed.
	 */
	INSIST(dl != NULL);
}
#endif /* ISC_MEM_TRACKLINES */

269
270
271
272
273
static inline size_t
rmsize(size_t size) {
	/*
 	 * round down to ALIGNMENT_SIZE
	 */
274
	return (size & (~(ALIGNMENT_SIZE - 1)));
275
276
}

277
static inline size_t
Bob Halley's avatar
base  
Bob Halley committed
278
279
quantize(size_t size) {
	/*
280
	 * Round up the result in order to get a size big
Bob Halley's avatar
base  
Bob Halley committed
281
282
283
	 * enough to satisfy the request and be aligned on ALIGNMENT_SIZE
	 * byte boundaries.
	 */
284

285
286
	if (size == 0)
		return (ALIGNMENT_SIZE);
287
	return ((size + ALIGNMENT_SIZE - 1) & (~(ALIGNMENT_SIZE - 1)));
Bob Halley's avatar
base  
Bob Halley committed
288
289
}

David Lawrence's avatar
David Lawrence committed
290
291
292
293
static inline void
split(isc_mem_t *ctx, size_t size, size_t new_size) {
	unsigned char *ptr;
	size_t remaining_size;
Michael Graff's avatar
Michael Graff committed
294

David Lawrence's avatar
David Lawrence committed
295
296
297
298
299
300
	/*
	 * Unlink a frag of size 'size'.
	 */
	ptr = (unsigned char *)ctx->freelists[size];
	ctx->freelists[size] = ctx->freelists[size]->next;
	ctx->stats[size].freefrags--;
Michael Graff's avatar
Michael Graff committed
301

David Lawrence's avatar
David Lawrence committed
302
303
304
305
306
307
	/*
	 * Create a frag of size 'new_size' and link it in.
	 */
	((element *)ptr)->next = ctx->freelists[new_size];
	ctx->freelists[new_size] = (element *)ptr;
	ctx->stats[new_size].freefrags++;
Bob Halley's avatar
base  
Bob Halley committed
308

David Lawrence's avatar
David Lawrence committed
309
310
311
312
313
314
315
316
	/*
	 * Create a frag of size 'size - new_size' and link it in.
	 */
	remaining_size = size - new_size;
	ptr += new_size;
	((element *)ptr)->next = ctx->freelists[remaining_size];
	ctx->freelists[remaining_size] = (element *)ptr;
	ctx->stats[remaining_size].freefrags++;
317
318
}

David Lawrence's avatar
David Lawrence committed
319
320
321
static inline isc_boolean_t
try_split(isc_mem_t *ctx, size_t new_size) {
	size_t i, doubled_size;
322

David Lawrence's avatar
David Lawrence committed
323
324
	if (!ctx->trysplit)
		return (ISC_FALSE);
Michael Graff's avatar
Michael Graff committed
325

David Lawrence's avatar
David Lawrence committed
326
327
328
329
330
331
332
333
334
335
336
337
	/*
	 * Try splitting a frag that's at least twice as big as the size
	 * we want.
	 */
	doubled_size = new_size * 2;
	for (i = doubled_size;
	     i < ctx->max_size;
	     i += ALIGNMENT_SIZE) {
		if (ctx->freelists[i] != NULL) {
			split(ctx, i, new_size);
			return (ISC_TRUE);
		}
338
339
	}

340
	/*
David Lawrence's avatar
David Lawrence committed
341
	 * No luck.  Try splitting any frag bigger than the size we need.
342
	 */
David Lawrence's avatar
David Lawrence committed
343
344
345
346
347
348
349
350
	for (i = new_size + ALIGNMENT_SIZE;
	     i < doubled_size;
	     i += ALIGNMENT_SIZE) {
		if (ctx->freelists[i] != NULL) {
			split(ctx, i, new_size);
			return (ISC_TRUE);
		}
	}
351

David Lawrence's avatar
David Lawrence committed
352
	return (ISC_FALSE);
353
354
}

355
static inline isc_boolean_t
356
more_basic_blocks(isc_mem_t *ctx) {
357
358
359
360
361
	void *new;
	unsigned char *curr, *next;
	unsigned char *first, *last;
	unsigned char **table;
	unsigned int table_size;
Bob Halley's avatar
Bob Halley committed
362
	size_t increment;
363
364
365
366
	int i;

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

367
368
369
	/*
	 * Did we hit the quota for this context?
	 */
Bob Halley's avatar
Bob Halley committed
370
371
	increment = NUM_BASIC_BLOCKS * ctx->mem_target;
	if (ctx->quota != 0 && ctx->total + increment > ctx->quota)
372
		return (ISC_FALSE);
373
374
375

	INSIST(ctx->basic_table_count <= ctx->basic_table_size);
	if (ctx->basic_table_count == ctx->basic_table_size) {
376
		table_size = ctx->basic_table_size + TABLE_INCREMENT;
377
378
		table = (ctx->memalloc)(ctx->arg,
					table_size * sizeof (unsigned char *));
379
		if (table == NULL)
380
			return (ISC_FALSE);
381
382
383
384
		if (ctx->basic_table_size != 0) {
			memcpy(table, ctx->basic_table,
			       ctx->basic_table_size *
			       sizeof (unsigned char *));
385
			(ctx->memfree)(ctx->arg, ctx->basic_table);
386
		}
387
388
		ctx->basic_table = table;
		ctx->basic_table_size = table_size;
389
	}
390

391
	new = (ctx->memalloc)(ctx->arg, NUM_BASIC_BLOCKS * ctx->mem_target);
392
	if (new == NULL)
393
		return (ISC_FALSE);
Bob Halley's avatar
Bob Halley committed
394
	ctx->total += increment;
395
396
	ctx->basic_table[ctx->basic_table_count] = new;
	ctx->basic_table_count++;
397

398
399
400
	curr = new;
	next = curr + ctx->mem_target;
	for (i = 0; i < (NUM_BASIC_BLOCKS - 1); i++) {
401
		((element *)curr)->next = (element *)next;
402
403
404
405
406
407
408
		curr = next;
		next += ctx->mem_target;
	}
	/*
	 * curr is now pointing at the last block in the
	 * array.
	 */
Bob Halley's avatar
Bob Halley committed
409
	((element *)curr)->next = NULL;
410
411
412
413
414
415
416
	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;
417
418

	return (ISC_TRUE);
419
420
}

421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
static inline isc_boolean_t
more_frags(isc_mem_t *ctx, size_t new_size) {
	int i, frags;
	size_t total_size;
	void *new;
	unsigned char *curr, *next;

	/*
	 * Try to get more fragments by chopping up a basic block.
	 */

	if (ctx->basic_blocks == NULL) {
		if (!more_basic_blocks(ctx)) {
			/*
			 * We can't get more memory from the OS, or we've
			 * hit the quota for this context.
			 */
			/*
439
			 * XXXRTH  "At quota" notification here.
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
			 */
			/*
			 * Maybe we can split one of our existing
			 * list frags.
			 */
			return (try_split(ctx, new_size));
		}
	}

	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;
461
	total_size -= new_size;
462
463
464
465
	for (i = 0; i < (frags - 1); i++) {
		((element *)curr)->next = (element *)next;
		curr = next;
		next += new_size;
466
467
468
469
470
471
472
473
474
475
		total_size -= new_size;
	}
	/*
	 * Add the remaining fragment of the basic block to a free list.
	 */
	total_size = rmsize(total_size);
	if (total_size > 0) {
		((element *)next)->next = ctx->freelists[total_size];
		ctx->freelists[total_size] = (element *)next;
		ctx->stats[total_size].freefrags++;
476
477
478
479
480
481
482
483
484
485
486
	}
	/*
	 * curr is now pointing at the last block in the
	 * array.
	 */
	((element *)curr)->next = NULL;
	ctx->freelists[new_size] = new;

	return (ISC_TRUE);
}

Michael Graff's avatar
Michael Graff committed
487
static inline void *
488
mem_getunlocked(isc_mem_t *ctx, size_t size) {
Michael Graff's avatar
Michael Graff committed
489
490
	size_t new_size = quantize(size);
	void *ret;
Bob Halley's avatar
base  
Bob Halley committed
491
492

	if (size >= ctx->max_size || new_size >= ctx->max_size) {
493
494
495
		/*
		 * memget() was called on something beyond our upper limit.
		 */
Bob Halley's avatar
Bob Halley committed
496
497
498
499
		if (ctx->quota != 0 && ctx->total + size > ctx->quota) {
			ret = NULL;
			goto done;
		}
Mark Andrews's avatar
Mark Andrews committed
500
		ret = (ctx->memalloc)(ctx->arg, size);
Bob Halley's avatar
base  
Bob Halley committed
501
		if (ret != NULL) {
Bob Halley's avatar
Bob Halley committed
502
			ctx->total += size;
503
			ctx->inuse += size;
Bob Halley's avatar
base  
Bob Halley committed
504
505
			ctx->stats[ctx->max_size].gets++;
			ctx->stats[ctx->max_size].totalgets++;
Mark Andrews's avatar
Mark Andrews committed
506
507
508
509
510
511
			/*
			 * If we don't set new_size to size, then the
			 * ISC_MEM_FILL code might write over bytes we
			 * don't own.
			 */
			new_size = size;
Bob Halley's avatar
base  
Bob Halley committed
512
513
514
515
		}
		goto done;
	}

516
	/*
Bob Halley's avatar
base  
Bob Halley committed
517
518
519
520
	 * 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.
	 */
521
522
	if (ctx->freelists[new_size] == NULL && !more_frags(ctx, new_size))
		return (NULL);
Bob Halley's avatar
base  
Bob Halley committed
523

524
525
526
	/*
	 * The free list uses the "rounded-up" size "new_size".
	 */
Bob Halley's avatar
base  
Bob Halley committed
527
528
529
	ret = ctx->freelists[new_size];
	ctx->freelists[new_size] = ctx->freelists[new_size]->next;

530
	/*
Bob Halley's avatar
base  
Bob Halley committed
531
532
533
534
535
536
537
538
	 * 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--;
539
	ctx->inuse += new_size;
Bob Halley's avatar
base  
Bob Halley committed
540
541
542

 done:

543
#if ISC_MEM_FILL
544
545
	if (ret != NULL)
		memset(ret, 0xbe, new_size); /* Mnemonic for "beef". */
David Lawrence's avatar
David Lawrence committed
546
547
548
#endif

	return (ret);
Michael Graff's avatar
Michael Graff committed
549
550
}

551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
#if ISC_MEM_FILL && ISC_MEM_CHECKOVERRUN
static inline void
check_overrun(void *mem, size_t size, size_t new_size) {
	unsigned char *cp;

	cp = (unsigned char *)mem;
	cp += size;
	while (size < new_size) {
		INSIST(*cp == 0xbe);
		cp++;
		size++;
	}
}
#endif

Michael Graff's avatar
Michael Graff committed
566
static inline void
567
mem_putunlocked(isc_mem_t *ctx, void *mem, size_t size) {
Michael Graff's avatar
Michael Graff committed
568
	size_t new_size = quantize(size);
Bob Halley's avatar
base  
Bob Halley committed
569

570
	if (size == ctx->max_size || new_size >= ctx->max_size) {
571
572
573
		/*
		 * memput() called on something beyond our upper limit.
		 */
574
#if ISC_MEM_FILL
Mark Andrews's avatar
Mark Andrews committed
575
576
		memset(mem, 0xde, size); /* Mnemonic for "dead". */
#endif
577
		(ctx->memfree)(ctx->arg, mem);
Bob Halley's avatar
base  
Bob Halley committed
578
579
		INSIST(ctx->stats[ctx->max_size].gets != 0);
		ctx->stats[ctx->max_size].gets--;
Bob Halley's avatar
Bob Halley committed
580
		INSIST(size <= ctx->total);
581
		ctx->inuse -= size;
Bob Halley's avatar
Bob Halley committed
582
		ctx->total -= size;
Michael Graff's avatar
Michael Graff committed
583
		return;
Bob Halley's avatar
base  
Bob Halley committed
584
585
	}

586
587
#if ISC_MEM_FILL
#if ISC_MEM_CHECKOVERRUN
588
589
	check_overrun(mem, size, new_size);
#endif
Mark Andrews's avatar
Mark Andrews committed
590
591
	memset(mem, 0xde, new_size); /* Mnemonic for "dead". */
#endif
592

593
594
595
	/*
	 * The free list uses the "rounded-up" size "new_size".
	 */
Mark Andrews's avatar
Mark Andrews committed
596
597
	((element *)mem)->next = ctx->freelists[new_size];
	ctx->freelists[new_size] = (element *)mem;
Bob Halley's avatar
base  
Bob Halley committed
598

599
	/*
Bob Halley's avatar
base  
Bob Halley committed
600
601
602
603
604
605
606
607
	 * 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++;
608
	ctx->inuse -= new_size;
Bob Halley's avatar
base  
Bob Halley committed
609
610
}

David Lawrence's avatar
David Lawrence committed
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
/*
 * Private.
 */

static void *
default_memalloc(void *arg, size_t size) {
	UNUSED(arg);
	return (malloc(size));
}

static void
default_memfree(void *arg, void *ptr) {
	UNUSED(arg);
	free(ptr);
}

/*
 * Public.
 */

isc_result_t
isc_mem_createx(size_t init_max_size, size_t target_size,
		isc_memalloc_t memalloc, isc_memfree_t memfree, void *arg,
		isc_mem_t **ctxp)
{
	isc_mem_t *ctx;

	REQUIRE(ctxp != NULL && *ctxp == NULL);
	REQUIRE(memalloc != NULL);
	REQUIRE(memfree != NULL);

642
643
	INSIST((ALIGNMENT_SIZE & (ALIGNMENT_SIZE - 1)) == 0);

David Lawrence's avatar
David Lawrence committed
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
	ctx = (memalloc)(arg, sizeof *ctx);
	if (ctx == NULL)
		return (ISC_R_NOMEMORY);

	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;
	ctx->memalloc = memalloc;
	ctx->memfree = memfree;
	ctx->arg = arg;
	ctx->freelists = (memalloc)(arg, ctx->max_size * sizeof (element *));
	if (ctx->freelists == NULL) {
		(memfree)(arg, ctx);
		return (ISC_R_NOMEMORY);
	}
	ctx->checkfree = ISC_TRUE;
	ctx->trysplit = ISC_FALSE;
	memset(ctx->freelists, 0,
	       ctx->max_size * sizeof (element *));
	ctx->stats = (memalloc)(arg,
				(ctx->max_size+1) * sizeof (struct stats));
	if (ctx->stats == NULL) {
		(memfree)(arg, ctx->freelists);
		(memfree)(arg, ctx);
		return (ISC_R_NOMEMORY);
	}
	memset(ctx->stats, 0, (ctx->max_size + 1) * sizeof (struct stats));
	ctx->basic_blocks = NULL;
	ctx->basic_table = NULL;
	ctx->basic_table_count = 0;
	ctx->basic_table_size = 0;
	ctx->lowest = NULL;
	ctx->highest = NULL;
	if (isc_mutex_init(&ctx->lock) != ISC_R_SUCCESS) {
		(memfree)(arg, ctx->stats);
		(memfree)(arg, ctx->freelists);
		(memfree)(arg, ctx);
		UNEXPECTED_ERROR(__FILE__, __LINE__,
687
688
689
				 "isc_mutex_init() %s",
				 isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
						ISC_MSG_FAILED, "failed"));
David Lawrence's avatar
David Lawrence committed
690
691
692
693
694
695
		return (ISC_R_UNEXPECTED);
	}
	ctx->references = 1;
	ctx->quota = 0;
	ctx->total = 0;
	ctx->inuse = 0;
696
697
698
699
700
	ctx->hi_water = 0;
	ctx->lo_water = 0;
	ctx->hi_called = ISC_FALSE;
	ctx->water = NULL;
	ctx->water_arg = NULL;
David Lawrence's avatar
David Lawrence committed
701
702
703
	ctx->magic = MEM_MAGIC;
	isc_ondestroy_init(&ctx->ondestroy);
	ISC_LIST_INIT(ctx->pools);
704
#if ISC_MEM_TRACKLINES
Michael Graff's avatar
Michael Graff committed
705
706
	ISC_LIST_INIT(ctx->debuglist);
#endif
David Lawrence's avatar
David Lawrence committed
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728

	*ctxp = ctx;
	return (ISC_R_SUCCESS);
}

isc_result_t
isc_mem_create(size_t init_max_size, size_t target_size,
	       isc_mem_t **ctxp)
{
	return (isc_mem_createx(init_max_size, target_size,
				default_memalloc, default_memfree, NULL,
				ctxp));
}

static void
destroy(isc_mem_t *ctx) {
	unsigned int i;
	isc_ondestroy_t ondest;

	ctx->magic = 0;

	INSIST(ISC_LIST_EMPTY(ctx->pools));
729
#if ISC_MEM_TRACKLINES
730
731
	if (ctx->checkfree)
		INSIST(ISC_LIST_EMPTY(ctx->debuglist));
732
733
734
735
736
737
738
739
740
741
	else {
		debuglink_t *dl;

		for (dl = ISC_LIST_HEAD(ctx->debuglist);
		     dl != NULL;
		     dl = ISC_LIST_HEAD(ctx->debuglist)) {
			ISC_LIST_UNLINK(ctx->debuglist, dl, link);
			free(dl);
		}
	}
Michael Graff's avatar
Michael Graff committed
742
#endif
David Lawrence's avatar
David Lawrence committed
743
744
745
746
747
748
749
750
751
752
753
754
	INSIST(ctx->references == 0);

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

#if 0					/* XXX brister debugging */
	for (i = 0; i < ctx->basic_table_count; i++)
		memset(ctx->basic_table[i], 0x0,
		       NUM_BASIC_BLOCKS * ctx->mem_target);
#endif
755

David Lawrence's avatar
David Lawrence committed
756
757
758
759
760
761
762
763
764

	for (i = 0; i < ctx->basic_table_count; i++)
		(ctx->memfree)(ctx->arg, ctx->basic_table[i]);
	(ctx->memfree)(ctx->arg, ctx->freelists);
	(ctx->memfree)(ctx->arg, ctx->stats);
	(ctx->memfree)(ctx->arg, ctx->basic_table);

	ondest = ctx->ondestroy;

765
	DESTROYLOCK(&ctx->lock);
David Lawrence's avatar
David Lawrence committed
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
	(ctx->memfree)(ctx->arg, ctx);

	isc_ondestroy_notify(&ondest, ctx);
}

void
isc_mem_attach(isc_mem_t *source, isc_mem_t **targetp) {
	REQUIRE(VALID_CONTEXT(source));
	REQUIRE(targetp != NULL && *targetp == NULL);

	LOCK(&source->lock);
	source->references++;
	UNLOCK(&source->lock);

	*targetp = source;
}

void
isc_mem_detach(isc_mem_t **ctxp) {
	isc_mem_t *ctx;
	isc_boolean_t want_destroy = ISC_FALSE;

	REQUIRE(ctxp != NULL);
	ctx = *ctxp;
	REQUIRE(VALID_CONTEXT(ctx));

	LOCK(&ctx->lock);
	INSIST(ctx->references > 0);
	ctx->references--;
	if (ctx->references == 0)
		want_destroy = ISC_TRUE;
	UNLOCK(&ctx->lock);

	if (want_destroy)
		destroy(ctx);

	*ctxp = NULL;
}

805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
/*
 * isc_mem_putanddetach() is the equivalent of:
 *
 * mctx = NULL;
 * isc_mem_attach(ptr->mctx, &mctx);
 * isc_mem_detach(&ptr->mctx);
 * isc_mem_put(mctx, ptr, sizeof(*ptr);
 * isc_mem_detach(&mctx);
 */

void
isc__mem_putanddetach(isc_mem_t **ctxp, void *ptr, size_t size FLARG) {
	isc_mem_t *ctx;
	isc_boolean_t want_destroy = ISC_FALSE;

	REQUIRE(ctxp != NULL);
	ctx = *ctxp;
	REQUIRE(VALID_CONTEXT(ctx));
	REQUIRE(ptr != NULL);

	/*
	 * Must be before mem_putunlocked() as ctxp is usually within
	 * [ptr..ptr+size).
	 */
	*ctxp = NULL;

	LOCK(&ctx->lock);
	DELETE_TRACE(ctx, ptr, size, file, line);
	mem_putunlocked(ctx, ptr, size);
	INSIST(ctx->references > 0);
	ctx->references--;
	if (ctx->references == 0)
		want_destroy = ISC_TRUE;
	UNLOCK(&ctx->lock);

	if (want_destroy)
		destroy(ctx);
}

David Lawrence's avatar
David Lawrence committed
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
void
isc_mem_destroy(isc_mem_t **ctxp) {
	isc_mem_t *ctx;

	/*
	 * This routine provides legacy support for callers who use mctxs
	 * without attaching/detaching.
	 */

	REQUIRE(ctxp != NULL);
	ctx = *ctxp;
	REQUIRE(VALID_CONTEXT(ctx));

	LOCK(&ctx->lock);
	REQUIRE(ctx->references == 1);
	ctx->references--;
	UNLOCK(&ctx->lock);

Brian Wellington's avatar
Brian Wellington committed
862
	destroy(ctx);
David Lawrence's avatar
David Lawrence committed
863
864
865
866
867
868
869

	*ctxp = NULL;
}

isc_result_t
isc_mem_ondestroy(isc_mem_t *ctx, isc_task_t *task, isc_event_t **event) {
	isc_result_t res;
870

David Lawrence's avatar
David Lawrence committed
871
872
873
874
875
876
877
878
879
880
881
882
	LOCK(&ctx->lock);
	res = isc_ondestroy_register(&ctx->ondestroy, task, event);
	UNLOCK(&ctx->lock);

	return (res);
}


isc_result_t
isc_mem_restore(isc_mem_t *ctx) {
	isc_result_t result;

883
	result = isc_mutex_init(&ctx->lock);
David Lawrence's avatar
David Lawrence committed
884
885
886
887
888
889
	if (result != ISC_R_SUCCESS)
		ctx->magic = 0;

	return (result);
}

Michael Graff's avatar
Michael Graff committed
890
891
892
void *
isc__mem_get(isc_mem_t *ctx, size_t size FLARG) {
	void *ptr;
893
	isc_boolean_t call_water = ISC_FALSE;
Michael Graff's avatar
Michael Graff committed
894

David Lawrence's avatar
David Lawrence committed
895
896
897
	REQUIRE(VALID_CONTEXT(ctx));

	LOCK(&ctx->lock);
Michael Graff's avatar
Michael Graff committed
898
899
	ptr = mem_getunlocked(ctx, size);
	ADD_TRACE(ctx, ptr, size, file, line);
900
901
902
903
904
	if (ctx->hi_water != 0 && !ctx->hi_called &&
	    ctx->inuse > ctx->hi_water) {
		ctx->hi_called = ISC_TRUE;
		call_water = ISC_TRUE;
	}
David Lawrence's avatar
David Lawrence committed
905
	UNLOCK(&ctx->lock);
906
907
908
909
910
911
912

	/* XXX remove */
	if (ctx->hi_water)
		fprintf(stderr,"inuse %u, total %u\n", ctx->inuse, ctx->total);

	if (call_water) {
		/* XXX remove */
913
914
915
916
		fprintf(stderr, "%s water(%p, ISC_MEM_HIWATER)\n",
			isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
				       ISC_MSG_CALLING, "calling"),
			ctx->water_arg);
917
918
919
		(ctx->water)(ctx->water_arg, ISC_MEM_HIWATER);
	}

Bob Halley's avatar
base  
Bob Halley committed
920
921
922
923
	return (ptr);
}

void
Michael Graff's avatar
Michael Graff committed
924
isc__mem_put(isc_mem_t *ctx, void *ptr, size_t size FLARG)
Bob Halley's avatar
base  
Bob Halley committed
925
{
926
927
	isc_boolean_t call_water = ISC_FALSE;

Michael Graff's avatar
Michael Graff committed
928
929
930
931
932
933
	REQUIRE(VALID_CONTEXT(ctx));
	REQUIRE(ptr != NULL);

	LOCK(&ctx->lock);
	DELETE_TRACE(ctx, ptr, size, file, line);
	mem_putunlocked(ctx, ptr, size);
934
935
936
937
	if (ctx->hi_called && ctx->inuse < ctx->lo_water) {
		ctx->hi_called = ISC_FALSE;
		call_water = ISC_TRUE;
	}
Michael Graff's avatar
Michael Graff committed
938
	UNLOCK(&ctx->lock);
939
940
941
942
943
944
945

	/* XXX remove */
	if (ctx->hi_water)
		fprintf(stderr,"inuse %u, total %u\n", ctx->inuse, ctx->total);

	if (call_water) {
		/* XXX remove */
946
947
948
949
		fprintf(stderr, "%s water(%p,ISC_MEM_LOWATER)\n",
			isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
				       ISC_MSG_CALLING, "calling"),
			ctx->water_arg);
950
951
		(ctx->water)(ctx->water_arg, ISC_MEM_LOWATER);
	}
Bob Halley's avatar
base  
Bob Halley committed
952
953
}

954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
isc_result_t
isc_mem_preallocate(isc_mem_t *ctx) {
	size_t i;
	isc_result_t result = ISC_R_SUCCESS;
	void *ptr;

	REQUIRE(VALID_CONTEXT(ctx));

	LOCK(&ctx->lock);

	for (i = 0; i < ctx->max_size; i += ALIGNMENT_SIZE) {
		ptr = mem_getunlocked(ctx, i);
		if (ptr == NULL) {
			result = ISC_R_NOMEMORY;
			break;
		}
		mem_putunlocked(ctx, ptr, i);
	}
972

973
974
975
976
977
	UNLOCK(&ctx->lock);

	return (result);
}

Bob Halley's avatar
base  
Bob Halley committed
978
979
980
981
/*
 * Print the stats[] on the stream "out" with suitable formatting.
 */
void
982
isc_mem_stats(isc_mem_t *ctx, FILE *out) {
Bob Halley's avatar
base  
Bob Halley committed
983
	size_t i;
Michael Graff's avatar
Michael Graff committed
984
985
	const struct stats *s;
	const isc_mempool_t *pool;
Bob Halley's avatar
base  
Bob Halley committed
986

Bob Halley's avatar
Bob Halley committed
987
988
	REQUIRE(VALID_CONTEXT(ctx));
	LOCK(&ctx->lock);
Bob Halley's avatar
base  
Bob Halley committed
989

Michael Graff's avatar
Michael Graff committed
990
	if (ctx->freelists != NULL) {
991
		for (i = 0; i <= ctx->max_size; i++) {
Michael Graff's avatar
Michael Graff committed
992
993
994
995
			s = &ctx->stats[i];

			if (s->totalgets == 0 && s->gets == 0)
				continue;
996
			fprintf(out, "%s%5lu: %11lu gets, %11lu rem",
Michael Graff's avatar
Michael Graff committed
997
				(i == ctx->max_size) ? ">=" : "  ",
998
				(unsigned long) i, s->totalgets, s->gets);
999
			if (s->blocks != 0 || s->freefrags != 0)
Michael Graff's avatar
Michael Graff committed
1000
1001
1002
1003
1004
1005
				fprintf(out, " (%lu bl, %lu ff)",
					s->blocks, s->freefrags);
			fputc('\n', out);
		}
	}

Michael Graff's avatar
Michael Graff committed
1006
1007
1008
1009
1010
1011
1012
	/*
	 * Note that since a pool can be locked now, these stats might be
	 * somewhat off if the pool is in active use at the time the stats
	 * are dumped.  The link fields are protected by the isc_mem_t's
	 * lock, however, so walking this list and extracting integers from
	 * stats fields is always safe.
	 */
Michael Graff's avatar
Michael Graff committed
1013
1014
	pool = ISC_LIST_HEAD(ctx->pools);
	if (pool != NULL) {
1015
1016
1017
		fprintf(out, isc_msgcat_get(isc_msgcat, ISC_MSGSET_MEM,
					    ISC_MSG_POOLSTATS,
					    "[Pool statistics]\n"));
Michael Graff's avatar
Michael Graff committed
1018
		fprintf(out, "%15s %10s %10s %10s %10s %10s %10s %10s %1s\n",
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
			isc_msgcat_get(isc_msgcat, ISC_MSGSET_MEM,
				       ISC_MSG_POOLNAME, "name"),
			isc_msgcat_get(isc_msgcat, ISC_MSGSET_MEM,
				       ISC_MSG_POOLSIZE, "size"),
			isc_msgcat_get(isc_msgcat, ISC_MSGSET_MEM,
				       ISC_MSG_POOLMAXALLOC, "maxalloc"),
			isc_msgcat_get(isc_msgcat, ISC_MSGSET_MEM,
				       ISC_MSG_POOLALLOCATED, "allocated"),
			isc_msgcat_get(isc_msgcat, ISC_MSGSET_MEM,
				       ISC_MSG_POOLFREECOUNT, "freecount"),
			isc_msgcat_get(isc_msgcat, ISC_MSGSET_MEM,
				       ISC_MSG_POOLFREEMAX, "freemax"),
			isc_msgcat_get(isc_msgcat, ISC_MSGSET_MEM,
				       ISC_MSG_POOLFILLCOUNT, "fillcount"),
			isc_msgcat_get(isc_msgcat, ISC_MSGSET_MEM,
				       ISC_MSG_POOLGETS, "gets"),
			"L");
Michael Graff's avatar
Michael Graff committed
1036
1037
	}
	while (pool != NULL) {
1038
1039
		fprintf(out, "%15s %10lu %10u %10u %10u %10u %10u %10u %s\n",
			pool->name, (unsigned long) pool->size, pool->maxalloc,
Michael Graff's avatar
Michael Graff committed
1040
1041
			pool->allocated, pool->freecount, pool->freemax,
			pool->fillcount, pool->gets,
Michael Graff's avatar
Michael Graff committed
1042
			(pool->lock == NULL ? "N" : "Y"));
Michael Graff's avatar
Michael Graff committed
1043
		pool = ISC_LIST_NEXT(pool, link);
Bob Halley's avatar
base  
Bob Halley committed
1044
1045
	}

1046
#if ISC_MEM_TRACKLINES
1047
	if (MEM_RECORD) {
Michael Graff's avatar
Michael Graff committed
1048
1049
1050
		debuglink_t *dl;
		unsigned int i;

1051
1052
1053
		fprintf(out, isc_msgcat_get(isc_msgcat, ISC_MSGSET_MEM,
					    ISC_MSG_DUMPALLOC,
					    "DUMP OF ALL OUTSTANDING "
1054
					    "MEMORY ALLOCATIONS\n"));
Michael Graff's avatar
Michael Graff committed
1055
1056
		dl = ISC_LIST_HEAD(ctx->debuglist);
		if (dl == NULL)
1057
1058
1059
			fprintf(out, isc_msgcat_get(isc_msgcat, ISC_MSGSET_MEM,
						    ISC_MSG_NONE,
						    "\tNone.\n"));
Michael Graff's avatar
Michael Graff committed
1060
1061
1062
1063
		while (dl != NULL) {
			for (i = 0 ; i < DEBUGLIST_COUNT ; i++)
				if (dl->ptr[i] != NULL)
					fprintf(out,
1064
1065
1066
1067
1068
1069
						isc_msgcat_get(isc_msgcat,
							   ISC_MSGSET_MEM,
							   ISC_MSG_PTRFILELINE,
							   "\tptr %p "
							   "file %s "
							   "line %u\n"),
Michael Graff's avatar
Michael Graff committed
1070
1071
1072
1073
1074
1075
1076
						dl->ptr[i], dl->file[i],
						dl->line[i]);
			dl = ISC_LIST_NEXT(dl, link);
		}
	}
#endif

Bob Halley's avatar
Bob Halley committed
1077
	UNLOCK(&ctx->lock);
Bob Halley's avatar
base  
Bob Halley committed
1078
1079
}

Bob Halley's avatar
Bob Halley committed
1080
isc_boolean_t
1081
isc_mem_valid(isc_mem_t *ctx, void *ptr) {
Bob Halley's avatar
Bob Halley committed
1082
	unsigned char *cp = ptr;
Bob Halley's avatar
Bob Halley committed
1083
	isc_boolean_t result = ISC_FALSE;
Bob Halley's avatar
base  
Bob Halley committed
1084

Bob Halley's avatar
Bob Halley committed
1085
1086
	REQUIRE(VALID_CONTEXT(ctx));
	LOCK(&ctx->lock);
Bob Halley's avatar
base  
Bob Halley committed
1087
1088

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

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

Bob Halley's avatar
Bob Halley committed
1093
	return (result);
Bob Halley's avatar
base  
Bob Halley committed
1094
1095
1096
}

/*
1097
1098
 * Replacements for malloc() and free() -- they implicitly remember the
 * size of the object allocated (with some additional overhead).
Bob Halley's avatar
base  
Bob Halley committed
1099
1100
 */

Michael Graff's avatar
Michael Graff committed
1101
1102
static void *
isc__mem_allocateunlocked(isc_mem_t *ctx, size_t size) {
Bob Halley's avatar
Bob Halley committed
1103
	size_info *si;
Bob Halley's avatar
base  
Bob Halley committed
1104
1105

	size += ALIGNMENT_SIZE;
Michael Graff's avatar
Michael Graff committed
1106
	si = mem_getunlocked(ctx, size);
Bob Halley's avatar
base  
Bob Halley committed
1107
1108
	if (si == NULL)
		return (NULL);
1109
	si->u.size = size;
Bob Halley's avatar
base  
Bob Halley committed
1110
1111
1112
	return (&si[1]);
}

1113
void *
Michael Graff's avatar
Michael Graff committed
1114
isc__mem_allocate(isc_mem_t *ctx, size_t size FLARG) {
1115
1116
	size_info *si;

Michael Graff's avatar
Michael Graff committed
1117
	REQUIRE(VALID_CONTEXT(ctx));
1118

Michael Graff's avatar
Michael Graff committed
1119
1120
	LOCK(&ctx->lock);
	si = isc__mem_allocateunlocked(ctx, size);
1121
#if ISC_MEM_TRACKLINES
Michael Graff's avatar
Michael Graff committed
1122
1123
1124
1125
	if (si != NULL)
		ADD_TRACE(ctx, si, si[-1].u.size, file, line);
#endif
	UNLOCK(&ctx->lock);
1126

Michael Graff's avatar
Michael Graff committed
1127
	return (si);
1128
1129
}

Bob Halley's avatar
base  
Bob Halley committed
1130
void
Michael Graff's avatar
Michael Graff committed
1131
isc__mem_free(isc_mem_t *ctx, void *ptr FLARG) {
Bob Halley's avatar
Bob Halley committed
1132
	size_info *si;
Bob Halley's avatar
base  
Bob Halley committed
1133

Michael Graff's avatar
Michael Graff committed
1134
1135
1136
	REQUIRE(VALID_CONTEXT(ctx));
	REQUIRE(ptr != NULL);

Bob Halley's avatar
Bob Halley committed
1137
	si = &(((size_info *)ptr)[-1]);
Michael Graff's avatar
Michael Graff committed
1138
1139
1140
1141
	LOCK(&ctx->lock);
	DELETE_TRACE(ctx, ptr, si->u.size, file, line);
	mem_putunlocked(ctx, si, si->u.size);
	UNLOCK(&ctx->lock);
Bob Halley's avatar
base  
Bob Halley committed
1142
1143
}

Bob Halley's avatar
Bob Halley committed
1144
1145
1146
1147
/*
 * Other useful things.
 */

Bob Halley's avatar
Bob Halley committed
1148
char *
Michael Graff's avatar
Michael Graff committed
1149
isc__mem_strdup(isc_mem_t *mctx, const char *s FLARG) {
Bob Halley's avatar
Bob Halley committed
1150
1151
1152
	size_t len;
	char *ns;

Michael Graff's avatar
Michael Graff committed
1153
1154
1155
	REQUIRE(VALID_CONTEXT(mctx));
	REQUIRE(s != NULL);

Bob Halley's avatar
Bob Halley committed
1156
1157
	len = strlen(s);

Michael Graff's avatar
Michael Graff committed
1158
	ns = isc__mem_allocate(mctx, len + 1 FLARG_PASS);
1159

Michael Graff's avatar
Michael Graff committed
1160
1161
	if (ns != NULL)
		strncpy(ns, s, len + 1);
1162

Michael Graff's avatar
Michael Graff committed
1163
	return (ns);
1164
1165
}

1166
1167
1168
1169
void
isc_mem_setdestroycheck(isc_mem_t *ctx, isc_boolean_t flag) {
	REQUIRE(VALID_CONTEXT(ctx));
	LOCK(&ctx->lock);
1170

1171
	ctx->checkfree = flag;
1172

1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
	UNLOCK(&ctx->lock);
}

void
isc_mem_setsplit(isc_mem_t *ctx, isc_boolean_t flag) {
	REQUIRE(VALID_CONTEXT(ctx));
	LOCK(&ctx->lock);

	ctx->trysplit = flag;

	UNLOCK(&ctx->lock);
1184
1185
1186
}


1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
/*
 * 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);
}

1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
size_t
isc_mem_inuse(isc_mem_t *ctx) {
	size_t inuse;

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

	inuse = ctx->inuse;

	UNLOCK(&ctx->lock);

	return (inuse);
}

1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
void
isc_mem_setwater(isc_mem_t *ctx, isc_mem_water_t water, void *water_arg,
                 size_t hiwater, size_t lowater)
{
	REQUIRE(VALID_CONTEXT(ctx));

	if (water != NULL) {
		REQUIRE(hiwater > lowater);
		REQUIRE(hiwater > 0);
		REQUIRE(lowater > 0);
	}

	LOCK(&ctx->lock);
	if (water == NULL) {
		ctx->water = NULL;
		ctx->water_arg = NULL;
Brian Wellington's avatar
Brian Wellington committed
1245
1246
		ctx->hi_water = 0;
		ctx->lo_water = 0;
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
		ctx->hi_called = ISC_FALSE;
	} else {
		ctx->water = water;
		ctx->water_arg = water_arg;
		ctx->hi_water = hiwater;
		ctx->lo_water = lowater;
		ctx->hi_called = ISC_FALSE;
	}
	UNLOCK(&ctx->lock);
}

Michael Graff's avatar
Michael Graff committed
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
/*
 * Memory pool stuff
 */


#if 0
/*
 * Free all but "n" items from the pool's free list.  If n == 0, all items
 * will be returned to the mctx.
 */
static void
1269
mempool_release(isc_mempool_t *mpctx, unsigned int n) {
Michael Graff's avatar
Michael Graff committed
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
	isc_mem_t *mctx;
	element *item;
	element *next;
	unsigned int count;

	mctx = mpctx->mctx;

	if (mpctx->freecount <= n)
		return;

	INSIST(mpctx->items != NULL);
	item = mpctx->items;
	for (count = 0 ; count < n ; count++) {
Michael Graff's avatar
Michael Graff committed
1283
		item = item->next;
Michael Graff's avatar
Michael Graff committed
1284
1285
1286
1287
1288
1289
1290
1291
1292
		INSIST(item != NULL);
	}

	/*
	 * All remaining items are to be freed.  Lock the context once,
	 * free them all, and unlock the context.
	 */
	LOCK(&mctx->lock);
	do {
Michael Graff's avatar
Michael Graff committed
1293
		next = item->next;
Michael Graff's avatar
Michael Graff committed
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
		mem_putunlocked(mctx, item, mpctx->size);
		INSIST(mpctx->freecount > 0);
		mpctx->freecount--;
		item = next;
	} while (item != NULL);
	UNLOCK(&mctx->lock);
}
#endif

/*
 * Release all items on the free list.  No locking is done, the memory
Michael Graff's avatar
Michael Graff committed
1305
 * context must be locked, and the pool if needed.
Michael Graff's avatar
Michael Graff committed
1306
1307
 */
static void
1308
mempool_releaseall(isc_mempool_t *mpctx) {
Michael Graff's avatar
Michael Graff committed
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
	isc_mem_t *mctx;
	element *item;
	element *next;

	mctx = mpctx->mctx;

	if (mpctx->freecount == 0)
		return;

	INSIST(mpctx->items != NULL);
	item = mpctx->items;

	do {
Michael Graff's avatar
Michael Graff committed
1322
		next = item->next;
Mark Andrews's avatar
Mark Andrews committed
1323
		mem_putunlocked(mctx, item, mpctx->size);
Michael Graff's avatar
Michael Graff committed
1324
1325
1326
1327
1328
1329
1330
		INSIST(mpctx->freecount > 0);
		mpctx->freecount--;
		item = next;
	} while (item != NULL);
}

isc_result_t
1331
isc_mempool_create(isc_mem_t *mctx, size_t size, isc_mempool_t **mpctxp) {
Michael Graff's avatar
Michael Graff committed
1332
1333
1334
	isc_mempool_t *mpctx;

	REQUIRE(VALID_CONTEXT(mctx));
Michael Graff's avatar
Michael Graff committed
1335
	REQUIRE(size > 0);
Michael Graff's avatar
Michael Graff committed
1336
1337
1338
1339
1340
1341
1342
1343
	REQUIRE(mpctxp != NULL && *mpctxp == NULL);

	/*
	 * Allocate space for this pool, initialize values, and if all works
	 * well, attach to the memory context.
	 */
	LOCK(&mctx->lock);

Mark Andrews's avatar
Mark Andrews committed
1344
	mpctx = mem_getunlocked(mctx, sizeof(isc_mempool_t));
Michael Graff's avatar
Michael Graff committed
1345
1346
1347
1348
1349
1350
	if (mpctx == NULL) {
		UNLOCK(&mctx->lock);
		return (ISC_R_NOMEMORY);
	}

	mpctx->magic = MEMPOOL_MAGIC;
Michael Graff's avatar
Michael Graff committed
1351
	mpctx->lock = NULL;
Michael Graff's avatar
Michael Graff committed
1352
	mpctx->mctx = mctx;
Michael Graff's avatar
Michael Graff committed
1353
	mpctx->size = size;
Michael Graff's avatar
Michael Graff committed
1354
1355
1356
1357
1358
1359
	mpctx->maxalloc = UINT_MAX;
	mpctx->allocated = 0;
	mpctx->freecount = 0;
	mpctx->freemax = 1;
	mpctx->fillcount = 1;
	mpctx->gets = 0;
1360
#if ISC_MEMPOOL_NAMES
Michael Graff's avatar
Michael Graff committed
1361
1362
	mpctx->name[0] = 0;
#endif
Michael Graff's avatar
Michael Graff committed
1363
1364
1365
1366
	mpctx->items = NULL;

	*mpctxp = mpctx;

1367
	ISC_LIST_INITANDAPPEND(mctx->pools, mpctx, link);
Michael Graff's avatar
Michael Graff committed
1368
1369
1370
1371
1372
1373

	UNLOCK(&mctx->lock);

	return (ISC_R_SUCCESS);
}

Michael Graff's avatar
Michael Graff committed
1374
void