2  * Copyright (c) 2000-2004 Proofpoint, Inc. and its suppliers.
11 SM_RCSID("@(#)$Id: rpool.c,v 1.29 2013-11-22 20:51:43 ca Exp $")
46 **  SM_RPOOL_ALLOCBLOCK_X -- allocate a new block for an rpool.
49 **		rpool -- rpool to which the block should be added.
50 **		size -- size of block.
53 **		Pointer to block.
56 **		F:sm_heap -- out of memory
60 sm_rpool_allocblock_x(rpool, size)  in sm_rpool_allocblock_x()  argument
62 	size_t size;
66 	p = sm_malloc_x(sizeof(SM_POOLHDR_T) + size);
67 	p->sm_pnext = rpool->sm_pools;
68 	rpool->sm_pools = p;
73 **  SM_RPOOL_ALLOCBLOCK -- allocate a new block for an rpool.
76 **		rpool -- rpool to which the block should be added.
77 **		size -- size of block.
80 **		Pointer to block, NULL on failure.
84 sm_rpool_allocblock(rpool, size)  in sm_rpool_allocblock()  argument
86 	size_t size;
90 	p = sm_malloc(sizeof(SM_POOLHDR_T) + size);
93 	p->sm_pnext = rpool->sm_pools;
94 	rpool->sm_pools = p;
99 **  SM_RPOOL_MALLOC_TAGGED_X -- allocate memory from rpool
102 **		rpool -- rpool from which memory should be allocated;
104 **		size -- size of block.
105 **		file -- filename.
106 **		line -- line number in file.
107 **		group -- heap group for debugging.
110 **		Pointer to block.
113 **		F:sm_heap -- out of memory
116 **		if size == 0 and the rpool is new (no memory
119 **		- wasting 1 byte (size < avail)
120 **		- checking for rpool->sm_poolptr != NULL
121 **		- not asking for 0 sized buffer
126 sm_rpool_malloc_tagged_x(rpool, size, file, line, group)  in sm_rpool_malloc_tagged_x()  argument
128 	size_t size;
133 sm_rpool_malloc_x(rpool, size)
135 	size_t size;
141 		return sm_malloc_tagged_x(size, file, line, group);
143 	/* Ensure that size is properly aligned. */
144 	if (size & SM_ALIGN_BITS)
145 		size = (size & ~SM_ALIGN_BITS) + SM_ALIGN_SIZE;
148 	if (size <= rpool->sm_poolavail)
150 		ptr = rpool->sm_poolptr;
151 		rpool->sm_poolptr += size;
152 		rpool->sm_poolavail -= size;
159 	**  That's okay: we set rpool->sm_poolavail to 0 when we free an rpool,
163 	SM_REQUIRE(rpool->sm_magic == SmRpoolMagic);
166 	**  If size > sm_poolsize, then malloc a new block especially for
174 	**  we malloc a block just for the current request if size >
177 	**  is sm_bigobjectsize - 1.
180 	if (size > rpool->sm_bigobjectsize)
183 		++rpool->sm_nbigblocks;
185 		return sm_rpool_allocblock_x(rpool, size);
187 	SM_ASSERT(rpool->sm_bigobjectsize <= rpool->sm_poolsize);
188 	ptr = sm_rpool_allocblock_x(rpool, rpool->sm_poolsize);
189 	rpool->sm_poolptr = ptr + size;
190 	rpool->sm_poolavail = rpool->sm_poolsize - size;
192 	++rpool->sm_npools;
198 **  SM_RPOOL_MALLOC_TAGGED -- allocate memory from rpool
201 **		rpool -- rpool from which memory should be allocated;
203 **		size -- size of block.
204 **		file -- filename.
205 **		line -- line number in file.
206 **		group -- heap group for debugging.
209 **		Pointer to block, NULL on failure.
212 **		if size == 0 and the rpool is new (no memory
215 **		- wasting 1 byte (size < avail)
216 **		- checking for rpool->sm_poolptr != NULL
217 **		- not asking for 0 sized buffer
222 sm_rpool_malloc_tagged(rpool, size, file, line, group)  in sm_rpool_malloc_tagged()  argument
224 	size_t size;
229 sm_rpool_malloc(rpool, size)
231 	size_t size;
237 		return sm_malloc_tagged(size, file, line, group);
239 	/* Ensure that size is properly aligned. */
240 	if (size & SM_ALIGN_BITS)
241 		size = (size & ~SM_ALIGN_BITS) + SM_ALIGN_SIZE;
244 	if (size <= rpool->sm_poolavail)
246 		ptr = rpool->sm_poolptr;
247 		rpool->sm_poolptr += size;
248 		rpool->sm_poolavail -= size;
255 	**  That's okay: we set rpool->sm_poolavail to 0 when we free an rpool,
259 	SM_REQUIRE(rpool->sm_magic == SmRpoolMagic);
262 	**  If size > sm_poolsize, then malloc a new block especially for
270 	**  we malloc a block just for the current request if size >
273 	**  is sm_bigobjectsize - 1.
276 	if (size > rpool->sm_bigobjectsize)
279 		++rpool->sm_nbigblocks;
281 		return sm_rpool_allocblock(rpool, size);
283 	SM_ASSERT(rpool->sm_bigobjectsize <= rpool->sm_poolsize);
284 	ptr = sm_rpool_allocblock(rpool, rpool->sm_poolsize);
287 	rpool->sm_poolptr = ptr + size;
288 	rpool->sm_poolavail = rpool->sm_poolsize - size;
290 	++rpool->sm_npools;
296 **  SM_RPOOL_NEW_X -- create a new rpool.
299 **		parent -- pointer to parent rpool, can be NULL.
313 		rpool->sm_parentlink = NULL;
317 			rpool->sm_parentlink = sm_rpool_attach_x(parent,
325 	rpool->sm_magic = SmRpoolMagic;
327 	rpool->sm_poolsize = POOLSIZE - sizeof(SM_POOLHDR_T);
328 	rpool->sm_bigobjectsize = rpool->sm_poolsize / BIG_OBJECT_RATIO;
329 	rpool->sm_poolptr = NULL;
330 	rpool->sm_poolavail = 0;
331 	rpool->sm_pools = NULL;
333 	rpool->sm_rptr = NULL;
334 	rpool->sm_ravail = 0;
335 	rpool->sm_rlists = NULL;
337 	rpool->sm_nbigblocks = 0;
338 	rpool->sm_npools = 0;
345 **  SM_RPOOL_SETSIZES -- set sizes for rpool.
348 **		poolsize -- size of a single rpool block.
349 **		bigobjectsize -- if this size is exceeded, an individual
350 **			block is allocated (must be less or equal poolsize).
364 		poolsize = POOLSIZE - sizeof(SM_POOLHDR_T);
367 	rpool->sm_poolsize = poolsize;
368 	rpool->sm_bigobjectsize = bigobjectsize;
372 **  SM_RPOOL_FREE -- free an rpool and release all of its resources.
375 **		rpool -- rpool to free.
398 	rl = rpool->sm_rlists;
401 		rmax = rpool->sm_rptr;
404 			for (r = rl->sm_rvec; r < rmax; ++r)
406 				if (r->sm_rfree != NULL)
407 					r->sm_rfree(r->sm_rcontext);
409 			rnext = rl->sm_rnext;
414 			rmax = &rl->sm_rvec[SM_RLIST_MAX];
422 	for (pp = rpool->sm_pools; pp != NULL; pp = pnext)
424 		pnext = pp->sm_pnext;
432 	if (rpool->sm_parentlink != NULL)
433 		*rpool->sm_parentlink = NULL;
440 	rpool->sm_magic = NULL;
441 	rpool->sm_poolavail = 0;
442 	rpool->sm_ravail = 0;
445 	if (rpool->sm_nbigblocks > 0 || rpool->sm_npools > 1)
448 			(long) rpool, rpool->sm_nbigblocks, rpool->sm_npools);
449 	rpool->sm_nbigblocks = 0;
450 	rpool->sm_npools = 0;
456 **  SM_RPOOL_ATTACH_X -- attach a resource to an rpool.
459 **		rpool -- rpool to which resource should be attached.
460 **		rfree -- function to call when rpool is freed.
461 **		rcontext -- argument for function to call when rpool is freed.
467 **		F:sm_heap -- out of memory
481 	if (rpool->sm_ravail == 0)
484 		rl->sm_rnext = rpool->sm_rlists;
485 		rpool->sm_rlists = rl;
486 		rpool->sm_rptr = rl->sm_rvec;
487 		rpool->sm_ravail = SM_RLIST_MAX;
490 	a = &rpool->sm_rptr->sm_rfree;
491 	rpool->sm_rptr->sm_rfree = rfree;
492 	rpool->sm_rptr->sm_rcontext = rcontext;
493 	++rpool->sm_rptr;
494 	--rpool->sm_ravail;
500 **  SM_RPOOL_STRDUP_X -- Create a copy of a C string
503 **		rpool -- rpool to use.
504 **		s -- the string to copy.