From f859f35d857ba99d0fff548db6d568499a58de63 Mon Sep 17 00:00:00 2001 From: Mark Andrews Date: Fri, 29 Oct 1999 07:18:53 +0000 Subject: [PATCH] Reverse previous commit. --- lib/isc/include/isc/mem.h | 14 +--- lib/isc/mem.c | 151 +++++++++----------------------------- 2 files changed, 37 insertions(+), 128 deletions(-) diff --git a/lib/isc/include/isc/mem.h b/lib/isc/include/isc/mem.h index c1037c275d..3d00e21100 100644 --- a/lib/isc/include/isc/mem.h +++ b/lib/isc/include/isc/mem.h @@ -45,18 +45,16 @@ typedef void (*isc_memfree_t)(void *, void *); #define isc_mempool_put(c, p) __isc_mempool_putdebug(c, p, \ __FILE__, __LINE__) #else -#define isc_mem_get(c, s) __isc_mem_get(c, s, __FILE__, __LINE__) -#define isc_mem_put(c, p, s) __isc_mem_put(c, p, s, __FILE__, __LINE__) +#define isc_mem_get __isc_mem_get +#define isc_mem_put __isc_mem_put #define isc_mempool_get __isc_mempool_get #define isc_mempool_put __isc_mempool_put #endif /* ISC_MEM_DEBUG */ isc_result_t isc_mem_create(size_t, size_t, isc_mem_t **); void isc_mem_destroy(isc_mem_t **); -void * __isc_mem_get(isc_mem_t *, size_t, - const char *, int); -void __isc_mem_put(isc_mem_t *, void *, size_t, - const char *, int); +void * __isc_mem_get(isc_mem_t *, size_t); +void __isc_mem_put(isc_mem_t *, void *, size_t); void * __isc_mem_getdebug(isc_mem_t *, size_t, const char *, int); void __isc_mem_putdebug(isc_mem_t *, void *, @@ -251,10 +249,6 @@ void isc_mempool_setfillcount(isc_mempool_t *mpctx, * limit > 0 */ -void isc_mem_allocated(isc_mem_t *ctx, FILE *file); -/* - * Report allocated memory. - */ ISC_LANG_ENDDECLS #endif /* MEM_H */ diff --git a/lib/isc/mem.c b/lib/isc/mem.c index b1ca7a2a26..521bf8a826 100644 --- a/lib/isc/mem.c +++ b/lib/isc/mem.c @@ -69,10 +69,8 @@ * Types. */ -typedef struct element { +typedef struct { void * next; - const char * file; - int line; } element; typedef struct { @@ -105,7 +103,6 @@ struct isc_mem { size_t mem_target; element ** freelists; element * basic_blocks; - element ** allocated; unsigned char ** basic_table; unsigned int basic_table_count; unsigned int basic_table_size; @@ -149,10 +146,8 @@ struct isc_mempool { */ static inline size_t quantize(size_t); -static inline void mem_putunlocked(isc_mem_t *, void *, size_t, - const char *, int); -static inline void * mem_getunlocked(isc_mem_t *, size_t, - const char *, int); +static inline void mem_putunlocked(isc_mem_t *, void *, size_t); +static inline void * mem_getunlocked(isc_mem_t *, size_t); /* * Private Inline-able. @@ -168,7 +163,7 @@ quantize(size_t size) { * byte boundaries. */ - temp = size + sizeof(element) + (ALIGNMENT_SIZE - 1); + temp = size + (ALIGNMENT_SIZE - 1); return (temp - temp % ALIGNMENT_SIZE); } @@ -219,25 +214,17 @@ isc_mem_createx(size_t init_max_size, size_t target_size, ctx->memfree = memfree; ctx->arg = arg; ctx->freelists = (memalloc)(arg, ctx->max_size * sizeof (element *)); - ctx->allocated = (memalloc)(arg, ctx->max_size * sizeof (element *)); - if (ctx->freelists == NULL || ctx->allocated == NULL) { - if (ctx->freelists != NULL) - (memfree)(arg, ctx->freelists); - if (ctx->allocated != NULL) - (memfree)(arg, ctx->allocated); + if (ctx->freelists == NULL) { (memfree)(arg, ctx); return (ISC_R_NOMEMORY); } ctx->checkfree = ISC_TRUE; memset(ctx->freelists, 0, ctx->max_size * sizeof (element *)); - memset(ctx->allocated, 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->allocated); (memfree)(arg, ctx); return (ISC_R_NOMEMORY); } @@ -251,7 +238,6 @@ isc_mem_createx(size_t init_max_size, size_t target_size, if (isc_mutex_init(&ctx->lock) != ISC_R_SUCCESS) { (memfree)(arg, ctx->stats); (memfree)(arg, ctx->freelists); - (memfree)(arg, ctx->allocated); (memfree)(arg, ctx); UNEXPECTED_ERROR(__FILE__, __LINE__, "isc_mutex_init() failed"); @@ -266,31 +252,6 @@ isc_mem_createx(size_t init_max_size, size_t target_size, return (ISC_R_SUCCESS); } -void -isc_mem_allocated(isc_mem_t *ctx, FILE *file) { - unsigned int i; - element *el; - - REQUIRE(VALID_CONTEXT(ctx)); - REQUIRE(file != NULL); - - fflush(stdout); - fflush(stderr); - fflush(file); - for (i = 0 ; i <= ctx->max_size; i++) { - el = ctx->allocated[i]; - while (el != NULL) { - fprintf(file, - "bytes %d: address %p: file %s: line %d\n", - i, el + 1, - (el->file != NULL) ? el->file : "", - el->line); - el = el->next; - } - } - fflush(file); -} - isc_result_t isc_mem_create(size_t init_max_size, size_t target_size, isc_mem_t **ctxp) @@ -309,8 +270,6 @@ isc_mem_destroy(isc_mem_t **ctxp) { ctx = *ctxp; REQUIRE(VALID_CONTEXT(ctx)); - isc_mem_allocated(ctx, stderr); - ctx->magic = 0; INSIST(ISC_LIST_EMPTY(ctx->pools)); @@ -330,7 +289,6 @@ isc_mem_destroy(isc_mem_t **ctxp) { 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->allocated); (ctx->memfree)(ctx->arg, ctx->stats); (ctx->memfree)(ctx->arg, ctx->basic_table); @@ -416,7 +374,7 @@ more_basic_blocks(isc_mem_t *ctx) { } void * -__isc_mem_get(isc_mem_t *ctx, size_t size, const char *file, int line) +__isc_mem_get(isc_mem_t *ctx, size_t size) { void *ret; @@ -424,18 +382,17 @@ __isc_mem_get(isc_mem_t *ctx, size_t size, const char *file, int line) REQUIRE(VALID_CONTEXT(ctx)); LOCK(&ctx->lock); - ret = mem_getunlocked(ctx, size, file, line); + ret = mem_getunlocked(ctx, size); UNLOCK(&ctx->lock); return (ret); } static inline void * -mem_getunlocked(isc_mem_t *ctx, size_t size, const char *file, int line) +mem_getunlocked(isc_mem_t *ctx, size_t size) { size_t new_size = quantize(size); void *ret; - element *el; if (size >= ctx->max_size || new_size >= ctx->max_size) { /* memget() was called on something beyond our upper limit. */ @@ -443,18 +400,18 @@ mem_getunlocked(isc_mem_t *ctx, size_t size, const char *file, int line) ret = NULL; goto done; } - ret = (ctx->memalloc)(ctx->arg, new_size); + ret = (ctx->memalloc)(ctx->arg, size); if (ret != NULL) { ctx->total += size; ctx->stats[ctx->max_size].gets++; ctx->stats[ctx->max_size].totalgets++; - el = ret; - el->file = file; - el->line = line; - el->next = ctx->allocated[ctx->max_size]; - ctx->allocated[ctx->max_size] = el; + /* + * 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; } - goto done; } @@ -487,15 +444,11 @@ mem_getunlocked(isc_mem_t *ctx, size_t size, const char *file, int line) next = curr + new_size; for (i = 0; i < (frags - 1); i++) { ((element *)curr)->next = next; - ((element *)curr)->file = NULL; - ((element *)curr)->line = -1; curr = next; next += new_size; } /* curr is now pointing at the last block in the array. */ ((element *)curr)->next = NULL; - ((element *)curr)->file = NULL; - ((element *)curr)->line = -1; ctx->freelists[new_size] = new; } @@ -511,17 +464,10 @@ mem_getunlocked(isc_mem_t *ctx, size_t size, const char *file, int line) */ ctx->stats[size].gets++; ctx->stats[size].totalgets++; - el = ret; - el->file = file; - el->line = line; - el->next = ctx->allocated[size]; - ctx->allocated[size] = el; ctx->stats[new_size].freefrags--; done: - ret = (element *)ret + 1; - new_size -= sizeof(element); #if ISC_MEM_FILL if (ret != NULL) memset(ret, 0xbe, new_size); /* Mnemonic for "beef". */ @@ -531,44 +477,26 @@ mem_getunlocked(isc_mem_t *ctx, size_t size, const char *file, int line) } void -__isc_mem_put(isc_mem_t *ctx, void *mem, size_t size, - const char *file, int line) +__isc_mem_put(isc_mem_t *ctx, void *mem, size_t size) { REQUIRE(size > 0); REQUIRE(VALID_CONTEXT(ctx)); LOCK(&ctx->lock); - mem_putunlocked(ctx, mem, size, file, line); + mem_putunlocked(ctx, mem, size); UNLOCK(&ctx->lock); } static inline void -mem_putunlocked(isc_mem_t *ctx, void *mem, size_t size, - const char *file, int line) +mem_putunlocked(isc_mem_t *ctx, void *mem, size_t size) { size_t new_size = quantize(size); - element *el, *e, *p; -#if ISC_MEM_FILL - /* Mnemonic for "dead". */ - memset(mem, 0xde, new_size - sizeof(element)); -#endif - - mem = (element *)mem - 1; - el = mem; if (size == ctx->max_size || new_size >= ctx->max_size) { /* memput() called on something beyond our upper limit */ - e = ctx->allocated[ctx->max_size]; - p = NULL; - while (e != NULL && e != el) { - p = e; - e = e->next; - } - INSIST(e != NULL); - if (p == NULL) - ctx->allocated[ctx->max_size] = el->next; - else - p->next = el->next; +#if ISC_MEM_FILL + memset(mem, 0xde, size); /* Mnemonic for "dead". */ +#endif (ctx->memfree)(ctx->arg, mem); INSIST(ctx->stats[ctx->max_size].gets != 0); ctx->stats[ctx->max_size].gets--; @@ -577,24 +505,13 @@ mem_putunlocked(isc_mem_t *ctx, void *mem, size_t size, return; } - /* Remove element from allocated list */ - e = ctx->allocated[size]; - p = NULL; - while (e != NULL && e != el) { - p = e; - e = e->next; - } - INSIST(e != NULL); - if (p == NULL) - ctx->allocated[size] = el->next; - else - p->next = el->next; +#if ISC_MEM_FILL + memset(mem, 0xde, new_size); /* Mnemonic for "dead". */ +#endif /* The free list uses the "rounded-up" size "new_size": */ - el->next = ctx->freelists[new_size]; - el->file = file; - el->line = line; - ctx->freelists[new_size] = el; + ((element *)mem)->next = ctx->freelists[new_size]; + ctx->freelists[new_size] = (element *)mem; /* * The stats[] uses the _actual_ "size" requested by the @@ -611,7 +528,7 @@ void * __isc_mem_getdebug(isc_mem_t *ctx, size_t size, const char *file, int line) { void *ptr; - ptr = __isc_mem_get(ctx, size, file, line); + ptr = __isc_mem_get(ctx, size); fprintf(stderr, "%s:%d: mem_get(%p, %lu) -> %p\n", file, line, ctx, (unsigned long)size, ptr); return (ptr); @@ -623,7 +540,7 @@ __isc_mem_putdebug(isc_mem_t *ctx, void *ptr, size_t size, const char *file, { fprintf(stderr, "%s:%d: mem_put(%p, %p, %lu)\n", file, line, ctx, ptr, (unsigned long)size); - __isc_mem_put(ctx, ptr, size, file, line); + __isc_mem_put(ctx, ptr, size); } /* @@ -918,7 +835,7 @@ mempool_releaseall(isc_mempool_t *mpctx) do { next = item->next; - mem_putunlocked(mctx, item, mpctx->size, __FILE__, __LINE__); + mem_putunlocked(mctx, item, mpctx->size); INSIST(mpctx->freecount > 0); mpctx->freecount--; item = next; @@ -940,8 +857,7 @@ isc_mempool_create(isc_mem_t *mctx, size_t size, isc_mempool_t **mpctxp) */ LOCK(&mctx->lock); - mpctx = mem_getunlocked(mctx, sizeof(isc_mempool_t), - __FILE__, __LINE__); + mpctx = mem_getunlocked(mctx, sizeof(isc_mempool_t)); if (mpctx == NULL) { UNLOCK(&mctx->lock); return (ISC_R_NOMEMORY); @@ -1024,8 +940,7 @@ isc_mempool_destroy(isc_mempool_t **mpctxp) mpctx->magic = 0; - mem_putunlocked(mpctx->mctx, mpctx, sizeof(isc_mempool_t), - __FILE__, __LINE__); + mem_putunlocked(mpctx->mctx, mpctx, sizeof(isc_mempool_t)); UNLOCK(&mctx->lock); @@ -1086,7 +1001,7 @@ __isc_mempool_get(isc_mempool_t *mpctx) */ LOCK(&mctx->lock); for (i = 0 ; i < mpctx->fillcount ; i++) { - item = mem_getunlocked(mctx, mpctx->size, __FILE__, __LINE__); + item = mem_getunlocked(mctx, mpctx->size); if (item == NULL) break; item->next = mpctx->items; @@ -1135,7 +1050,7 @@ __isc_mempool_put(isc_mempool_t *mpctx, void *mem) * If our free list is full, return this to the mctx directly. */ if (mpctx->freecount >= mpctx->freemax) { - __isc_mem_put(mctx, mem, mpctx->size, __FILE__, __LINE__); + __isc_mem_put(mctx, mem, mpctx->size); if (mpctx->lock != NULL) UNLOCK(mpctx->lock); return;