apr-util/misc/apr_rmm.c

25  * be empty).  The base pointer, rmm->base, points at the beginning of
29  * "offset from rmm->base".
42  * i.e. rmm->base is *not* a valid address for a block, since the
76 static apr_rmm_off_t find_block_by_offset(apr_rmm_t *rmm, apr_rmm_off_t next,
82         struct rmm_block_t *blk = (rmm_block_t*)((char*)rmm->base + next);
97 static apr_rmm_off_t find_block_of_size(apr_rmm_t *rmm, apr_size_t size)
99     apr_rmm_off_t next = rmm->base->firstfree;
104         struct rmm_block_t *blk = (rmm_block_t*)((char*)rmm->base + next);
112              * never grow our rmm, we are SOL when we hit the wall.
124         struct rmm_block_t *blk = (rmm_block_t*)((char*)rmm->base + best);
125         struct rmm_block_t *new = (rmm_block_t*)((char*)rmm->base + best + size);
135             blk = (rmm_block_t*)((char*)rmm->base + new->next);
143 static void move_block(apr_rmm_t *rmm, apr_rmm_off_t this, int free)
145     struct rmm_block_t *blk = (rmm_block_t*)((char*)rmm->base + this);
149         struct rmm_block_t *prev = (rmm_block_t*)((char*)rmm->base + blk->prev);
154             rmm->base->firstused = blk->next;
157             rmm->base->firstfree = blk->next;
161         struct rmm_block_t *next = (rmm_block_t*)((char*)rmm->base + blk->next);
167         blk->prev = find_block_by_offset(rmm, rmm->base->firstfree, this, 1);
169             blk->next = rmm->base->firstfree;
170             rmm->base->firstfree = this;
174         blk->prev = find_block_by_offset(rmm, rmm->base->firstused, this, 1);
176             blk->next = rmm->base->firstused;
177             rmm->base->firstused = this;
183         struct rmm_block_t *prev = (rmm_block_t*)((char*)rmm->base + blk->prev);
197         struct rmm_block_t *next = (rmm_block_t*)((char*)rmm->base + blk->next);
203                 next = (rmm_block_t*)((char*)rmm->base + blk->next);
213 APU_DECLARE(apr_status_t) apr_rmm_init(apr_rmm_t **rmm, apr_anylock_t *lock,
229     (*rmm) = (apr_rmm_t *)apr_pcalloc(p, sizeof(apr_rmm_t));
230     (*rmm)->p = p;
231     (*rmm)->base = base;
232     (*rmm)->size = size;
233     (*rmm)->lock = *lock;
235     (*rmm)->base->abssize = size;
236     (*rmm)->base->firstused = 0;
237     (*rmm)->base->firstfree = RMM_HDR_BLOCK_SIZE;
239     blk = (rmm_block_t *)((char*)base + (*rmm)->base->firstfree);
241     blk->size = size - (*rmm)->base->firstfree;
248 APU_DECLARE(apr_status_t) apr_rmm_destroy(apr_rmm_t *rmm)
253     if ((rv = APR_ANYLOCK_LOCK(&rmm->lock)) != APR_SUCCESS) {
257     if (rmm->base->firstused) {
258         apr_rmm_off_t this = rmm->base->firstused;
260             blk = (rmm_block_t *)((char*)rmm->base + this);
264         rmm->base->firstused = 0;
266     if (rmm->base->firstfree) {
267         apr_rmm_off_t this = rmm->base->firstfree;
269             blk = (rmm_block_t *)((char*)rmm->base + this);
273         rmm->base->firstfree = 0;
275     rmm->base->abssize = 0;
276     rmm->size = 0;
278     return APR_ANYLOCK_UNLOCK(&rmm->lock);
281 APU_DECLARE(apr_status_t) apr_rmm_attach(apr_rmm_t **rmm, apr_anylock_t *lock,
293     (*rmm) = (apr_rmm_t *)apr_pcalloc(p, sizeof(apr_rmm_t));
294     (*rmm)->p = p;
295     (*rmm)->base = base;
296     (*rmm)->size = (*rmm)->base->abssize;
297     (*rmm)->lock = *lock;
301 APU_DECLARE(apr_status_t) apr_rmm_detach(apr_rmm_t *rmm)
307 APU_DECLARE(apr_rmm_off_t) apr_rmm_malloc(apr_rmm_t *rmm, apr_size_t reqsize)
317     APR_ANYLOCK_LOCK(&rmm->lock);
319     this = find_block_of_size(rmm, size);
322         move_block(rmm, this, 0);
326     APR_ANYLOCK_UNLOCK(&rmm->lock);
330 APU_DECLARE(apr_rmm_off_t) apr_rmm_calloc(apr_rmm_t *rmm, apr_size_t reqsize)
340     APR_ANYLOCK_LOCK(&rmm->lock);
342     this = find_block_of_size(rmm, size);
345         move_block(rmm, this, 0);
347         memset((char*)rmm->base + this, 0, size - RMM_BLOCK_SIZE);
350     APR_ANYLOCK_UNLOCK(&rmm->lock);
354 APU_DECLARE(apr_rmm_off_t) apr_rmm_realloc(apr_rmm_t *rmm, void *entity,
363         return apr_rmm_malloc(rmm, reqsize);
370     old = apr_rmm_offset_get(rmm, entity);
372     if ((this = apr_rmm_malloc(rmm, size)) == 0) {
376     blk = (rmm_block_t*)((char*)rmm->base + old - RMM_BLOCK_SIZE);
379     memcpy(apr_rmm_addr_get(rmm, this),
380            apr_rmm_addr_get(rmm, old), oldsize < size ? oldsize : size);
381     apr_rmm_free(rmm, old);
386 APU_DECLARE(apr_status_t) apr_rmm_free(apr_rmm_t *rmm, apr_rmm_off_t this)
400     blk = (rmm_block_t*)((char*)rmm->base + this);
402     if ((rv = APR_ANYLOCK_LOCK(&rmm->lock)) != APR_SUCCESS) {
406         struct rmm_block_t *prev = (rmm_block_t*)((char*)rmm->base + blk->prev);
408             APR_ANYLOCK_UNLOCK(&rmm->lock);
413         if (rmm->base->firstused != this) {
414             APR_ANYLOCK_UNLOCK(&rmm->lock);
420         struct rmm_block_t *next = (rmm_block_t*)((char*)rmm->base + blk->next);
422             APR_ANYLOCK_UNLOCK(&rmm->lock);
429     move_block(rmm, this, 1);
431     return APR_ANYLOCK_UNLOCK(&rmm->lock);
434 APU_DECLARE(void *) apr_rmm_addr_get(apr_rmm_t *rmm, apr_rmm_off_t entity)
438     return (void*)((char*)rmm->base + entity);
441 APU_DECLARE(apr_rmm_off_t) apr_rmm_offset_get(apr_rmm_t *rmm, void* entity)
448     return ((char*)entity - (char*)rmm->base);