mir/bind
2
0
Fork 0
mirror of https://gitlab.isc.org/isc-projects/bind9 synced 2025-09-02 07:35:26 +00:00
Code Issues Releases Wiki Activity

Cleanup the failure handling in isc_mem_allocate

Browse Source
This commit is contained in:
Ondřej Surý
2019-07-23 14:34:19 -04:00
parent 9123da5362
commit 19eb5d0e83
1 changed files with 22 additions and 32 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54
lib/isc/mem.c
View File

@@ -347,14 +347,13 @@ quantize(size_t size) {
return ((size + ALIGNMENT_SIZE - 1) & (~(ALIGNMENT_SIZE - 1))); return ((size + ALIGNMENT_SIZE - 1) & (~(ALIGNMENT_SIZE - 1)));
} }
static inline bool static inline void
more_basic_blocks(isc__mem_t *ctx) { more_basic_blocks(isc__mem_t *ctx) {
void *tmp; void *tmp;
unsigned char *curr, *next; unsigned char *curr, *next;
unsigned char *first, *last; unsigned char *first, *last;
unsigned char **table; unsigned char **table;
unsigned int table_size; unsigned int table_size;
int i;
/* Require: we hold the context lock. */ /* Require: we hold the context lock. */
@@ -385,12 +384,13 @@ more_basic_blocks(isc__mem_t *ctx) {
ctx->basic_table[ctx->basic_table_count] = tmp; ctx->basic_table[ctx->basic_table_count] = tmp;
ctx->basic_table_count++; ctx->basic_table_count++;
ctx->malloced += NUM_BASIC_BLOCKS * ctx->mem_target; ctx->malloced += NUM_BASIC_BLOCKS * ctx->mem_target;
if (ctx->malloced > ctx->maxmalloced) if (ctx->malloced > ctx->maxmalloced) {
ctx->maxmalloced = ctx->malloced; ctx->maxmalloced = ctx->malloced;
}
curr = tmp; curr = tmp;
next = curr + ctx->mem_target; next = curr + ctx->mem_target;
for (i = 0; i < (NUM_BASIC_BLOCKS - 1); i++) { for (int i = 0; i < (NUM_BASIC_BLOCKS - 1); i++) {
((element *)curr)->next = (element *)next; ((element *)curr)->next = (element *)next;
curr = next; curr = next;
next += ctx->mem_target; next += ctx->mem_target;
@@ -402,18 +402,18 @@ more_basic_blocks(isc__mem_t *ctx) {
((element *)curr)->next = NULL; ((element *)curr)->next = NULL;
first = tmp; first = tmp;
last = first + NUM_BASIC_BLOCKS * ctx->mem_target - 1; last = first + NUM_BASIC_BLOCKS * ctx->mem_target - 1;
if (first < ctx->lowest || ctx->lowest == NULL) if (first < ctx->lowest || ctx->lowest == NULL) {
ctx->lowest = first; ctx->lowest = first;
if (last > ctx->highest) }
if (last > ctx->highest) {
ctx->highest = last; ctx->highest = last;
}
ctx->basic_blocks = tmp; ctx->basic_blocks = tmp;
return (true);
} }
static inline bool static inline void
more_frags(isc__mem_t *ctx, size_t new_size) { more_frags(isc__mem_t *ctx, size_t new_size) {
int i, frags; int frags;
size_t total_size; size_t total_size;
void *tmp; void *tmp;
unsigned char *curr, *next; unsigned char *curr, *next;
@@ -423,16 +423,7 @@ more_frags(isc__mem_t *ctx, size_t new_size) {
*/ */
if (ctx->basic_blocks == NULL) { if (ctx->basic_blocks == NULL) {
if (!more_basic_blocks(ctx)) { more_basic_blocks(ctx);
/*
* We can't get more memory from the OS, or we've
* hit the quota for this context.
*/
/*
* XXXRTH "At quota" notification here.
*/
return (false);
}
} }
total_size = ctx->mem_target; total_size = ctx->mem_target;
@@ -448,7 +439,7 @@ more_frags(isc__mem_t *ctx, size_t new_size) {
curr = tmp; curr = tmp;
next = curr + new_size; next = curr + new_size;
total_size -= new_size; total_size -= new_size;
for (i = 0; i < (frags - 1); i++) { for (int i = 0; i < (frags - 1); i++) {
((element *)curr)->next = (element *)next; ((element *)curr)->next = (element *)next;
curr = next; curr = next;
next += new_size; next += new_size;
@@ -469,8 +460,6 @@ more_frags(isc__mem_t *ctx, size_t new_size) {
*/ */
((element *)curr)->next = NULL; ((element *)curr)->next = NULL;
ctx->freelists[new_size] = tmp; ctx->freelists[new_size] = tmp;
return (true);
} }
static inline void * static inline void *
@@ -504,8 +493,9 @@ mem_getunlocked(isc__mem_t *ctx, size_t size) {
* of memory and then break it up into "new_size"-sized blocks, adding * of memory and then break it up into "new_size"-sized blocks, adding
* them to the free list. * them to the free list.
*/ */
if (ctx->freelists[new_size] == NULL && !more_frags(ctx, new_size)) if (ctx->freelists[new_size] == NULL) {
return (NULL); more_frags(ctx, new_size);
}
/* /*
* The free list uses the "rounded-up" size "new_size". * The free list uses the "rounded-up" size "new_size".
@@ -514,7 +504,6 @@ mem_getunlocked(isc__mem_t *ctx, size_t size) {
ret = ctx->freelists[new_size]; ret = ctx->freelists[new_size];
ctx->freelists[new_size] = ctx->freelists[new_size]->next; ctx->freelists[new_size] = ctx->freelists[new_size]->next;
/* /*
* The stats[] uses the _actual_ "size" requested by the * The stats[] uses the _actual_ "size" requested by the
* caller, with the caveat (in the code above) that "size" >= the * caller, with the caveat (in the code above) that "size" >= the
@@ -1245,13 +1234,12 @@ mem_allocateunlocked(isc_mem_t *ctx0, size_t size) {
if (ISC_UNLIKELY((isc_mem_debugging & ISC_MEM_DEBUGCTX) != 0)) if (ISC_UNLIKELY((isc_mem_debugging & ISC_MEM_DEBUGCTX) != 0))
size += ALIGNMENT_SIZE; size += ALIGNMENT_SIZE;
if ((ctx->flags & ISC_MEMFLAG_INTERNAL) != 0) if ((ctx->flags & ISC_MEMFLAG_INTERNAL) != 0) {
si = mem_getunlocked(ctx, size); si = mem_getunlocked(ctx, size);
else } else {
si = mem_get(ctx, size); si = mem_get(ctx, size);
}
if (si == NULL)
return (NULL);
if (ISC_UNLIKELY((isc_mem_debugging & ISC_MEM_DEBUGCTX) != 0)) { if (ISC_UNLIKELY((isc_mem_debugging & ISC_MEM_DEBUGCTX) != 0)) {
si->u.ctx = ctx; si->u.ctx = ctx;
si++; si++;
@@ -1270,8 +1258,9 @@ isc___mem_allocate(isc_mem_t *ctx0, size_t size FLARG) {
MCTXLOCK(ctx, &ctx->lock); MCTXLOCK(ctx, &ctx->lock);
si = mem_allocateunlocked((isc_mem_t *)ctx, size); si = mem_allocateunlocked((isc_mem_t *)ctx, size);
if (((ctx->flags & ISC_MEMFLAG_INTERNAL) == 0) && (si != NULL)) if (((ctx->flags & ISC_MEMFLAG_INTERNAL) == 0)) {
mem_getstats(ctx, si[-1].u.size); mem_getstats(ctx, si[-1].u.size);
}
ADD_TRACE(ctx, si, si[-1].u.size, file, line); ADD_TRACE(ctx, si, si[-1].u.size, file, line);
if (ctx->hi_water != 0U && ctx->inuse > ctx->hi_water && if (ctx->hi_water != 0U && ctx->inuse > ctx->hi_water &&
@@ -1294,8 +1283,9 @@ isc___mem_allocate(isc_mem_t *ctx0, size_t size FLARG) {
} }
MCTXUNLOCK(ctx, &ctx->lock); MCTXUNLOCK(ctx, &ctx->lock);
if (call_water) if (call_water) {
(ctx->water)(ctx->water_arg, ISC_MEM_HIWATER); (ctx->water)(ctx->water_arg, ISC_MEM_HIWATER);
}
return (si); return (si);
} }