From 7e6198da4d64fd6b0478217fcb5f182c2eefcb84 Mon Sep 17 00:00:00 2001 From: Alasdair Kergon Date: Sun, 16 Oct 2005 22:57:20 +0000 Subject: [PATCH] export bitset, pool, hash, malloc --- VERSION | 2 +- WHATS_NEW | 1 + dmsetup/dmsetup.c | 28 +----- include/.symlinks | 4 - include/lib.h | 1 - lib/.exported_symbols | 40 ++++++++ lib/datastruct/bitset.c | 37 ++++--- lib/datastruct/hash.c | 91 +++++++++-------- lib/ioctl/libdm-iface.c | 69 +++++++------ lib/libdevmapper.h | 211 ++++++++++++++++++++++++++++++++++++++++ lib/libdm-common.c | 35 +++++-- lib/libdm-deptree.c | 40 ++++---- lib/mm/dbg_malloc.c | 25 +++-- lib/mm/dbg_malloc.h | 6 +- lib/mm/pool-debug.c | 51 +++++----- lib/mm/pool-fast.c | 43 ++++---- lib/mm/pool.c | 12 +-- 17 files changed, 466 insertions(+), 230 deletions(-) diff --git a/VERSION b/VERSION index 18923ff..45a7849 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.02.00-cvs (2005-10-04) +1.02.00-cvs (2005-10-16) diff --git a/WHATS_NEW b/WHATS_NEW index 3c06368..99283d6 100644 --- a/WHATS_NEW +++ b/WHATS_NEW @@ -1,6 +1,7 @@ Version 1.02.00 - ============================= Added dependency tree functions to library. + Added hash, bitset, pool, dbg_malloc to library. Added ls --tree to dmsetup. Added dmsetup --nolockfs support for suspend/reload. diff --git a/dmsetup/dmsetup.c b/dmsetup/dmsetup.c index 366d68e..4b2d7c0 100644 --- a/dmsetup/dmsetup.c +++ b/dmsetup/dmsetup.c @@ -645,33 +645,9 @@ static void _display_dev(struct dm_task *dmt, char *name) printf("%s\t(%u, %u)\n", name, info.major, info.minor); } -static int _mknodes_single(char *name) -{ - struct dm_task *dmt; - int r = 0; - - if (!(dmt = dm_task_create(DM_DEVICE_MKNODES))) - return 0; - - if (!_set_task_device(dmt, name, 1)) - goto out; - - if (_switches[NOOPENCOUNT_ARG] && !dm_task_no_open_count(dmt)) - goto out; - - if (!dm_task_run(dmt)) - goto out; - - r = 1; - - out: - dm_task_destroy(dmt); - return r; -} - static int _mknodes(int argc, char **argv, void *data) { - return _mknodes_single(argc > 1 ? argv[1] : NULL); + return dm_mknodes(argc > 1 ? argv[1] : NULL); } static int _exec_command(char *name) @@ -686,7 +662,7 @@ static int _exec_command(char *name) if (argc < 0) return 0; - if (!_mknodes_single(name)) + if (!dm_mknodes(name)) return 0; n = snprintf(path, sizeof(path), "%s/%s", dm_dir(), name); diff --git a/include/.symlinks b/include/.symlinks index f71ec84..696e46d 100644 --- a/include/.symlinks +++ b/include/.symlinks @@ -1,9 +1,5 @@ -../lib/datastruct/bitset.h -../lib/datastruct/hash.h ../lib/libdevmapper.h ../lib/libdm-file.h ../lib/libdm-event.h -../lib/mm/dbg_malloc.h -../lib/mm/pool.h ../multilog/libmultilog.h ../po/pogen.h diff --git a/include/lib.h b/include/lib.h index 290ec0c..dbc2ef9 100644 --- a/include/lib.h +++ b/include/lib.h @@ -25,7 +25,6 @@ #include "log.h" #include "intl.h" -#include "dbg_malloc.h" #include #include diff --git a/lib/.exported_symbols b/lib/.exported_symbols index eadcd46..85374dd 100644 --- a/lib/.exported_symbols +++ b/lib/.exported_symbols @@ -41,3 +41,43 @@ dm_deptree_find_node dm_deptree_next_child dm_deptree_next_parent dm_is_dm_major +dm_mknodes +dm_malloc_aux +dm_strdup +dm_free_aux +dm_realloc_aux +dm_dump_memory +dm_bounds_check +dm_pool_create +dm_pool_destroy +dm_pool_alloc +dm_pool_alloc_aligned +dm_pool_empty +dm_pool_free +dm_pool_begin_object +dm_pool_grow_object +dm_pool_end_object +dm_pool_abandon_object +dm_pool_strdup +dm_pool_strndup +dm_pool_zalloc +dm_bitset_create +dm_bitset_destroy +dm_bit_union +dm_bit_get_first +dm_bit_get_next +dm_hash_create +dm_hash_destroy +dm_hash_wipe +dm_hash_lookup +dm_hash_insert +dm_hash_remove +dm_hash_lookup_binary +dm_hash_insert_binary +dm_hash_remove_binary +dm_hash_get_num_entries +dm_hash_iter +dm_hash_get_key +dm_hash_get_data +dm_hash_get_first +dm_hash_get_next diff --git a/lib/datastruct/bitset.c b/lib/datastruct/bitset.c index 4962245..bb05e5e 100644 --- a/lib/datastruct/bitset.c +++ b/lib/datastruct/bitset.c @@ -14,21 +14,20 @@ */ #include "lib.h" -#include "bitset.h" /* FIXME: calculate this. */ #define INT_SHIFT 5 -bitset_t bitset_create(struct pool *mem, unsigned num_bits) +dm_bitset_t dm_bitset_create(struct dm_pool *mem, unsigned num_bits) { - unsigned n = (num_bits / BITS_PER_INT) + 2; + unsigned n = (num_bits / DM_BITS_PER_INT) + 2; size_t size = sizeof(int) * n; - bitset_t bs; + dm_bitset_t bs; if (mem) - bs = pool_zalloc(mem, size); + bs = dm_pool_zalloc(mem, size); else - bs = dbg_malloc(size); + bs = dm_malloc(size); if (!bs) return NULL; @@ -36,20 +35,20 @@ bitset_t bitset_create(struct pool *mem, unsigned num_bits) *bs = num_bits; if (!mem) - bit_clear_all(bs); + dm_bit_clear_all(bs); return bs; } -void bitset_destroy(bitset_t bs) +void dm_bitset_destroy(dm_bitset_t bs) { - dbg_free(bs); + dm_free(bs); } -void bit_union(bitset_t out, bitset_t in1, bitset_t in2) +void dm_bit_union(dm_bitset_t out, dm_bitset_t in1, dm_bitset_t in2) { int i; - for (i = (in1[0] / BITS_PER_INT) + 1; i; i--) + for (i = (in1[0] / DM_BITS_PER_INT) + 1; i; i--) out[i] = in1[i] | in2[i]; } @@ -58,7 +57,7 @@ void bit_union(bitset_t out, bitset_t in1, bitset_t in2) */ static inline int _test_word(uint32_t test, int bit) { - while (bit < BITS_PER_INT) { + while (bit < DM_BITS_PER_INT) { if (test & (0x1 << bit)) return bit; bit++; @@ -67,7 +66,7 @@ static inline int _test_word(uint32_t test, int bit) return -1; } -int bit_get_next(bitset_t bs, int last_bit) +int dm_bit_get_next(dm_bitset_t bs, int last_bit) { int bit, word; uint32_t test; @@ -77,19 +76,19 @@ int bit_get_next(bitset_t bs, int last_bit) while (last_bit < bs[0]) { word = last_bit >> INT_SHIFT; test = bs[word + 1]; - bit = last_bit & (BITS_PER_INT - 1); + bit = last_bit & (DM_BITS_PER_INT - 1); if ((bit = _test_word(test, bit)) >= 0) - return (word * BITS_PER_INT) + bit; + return (word * DM_BITS_PER_INT) + bit; - last_bit = last_bit - (last_bit & (BITS_PER_INT - 1)) + - BITS_PER_INT; + last_bit = last_bit - (last_bit & (DM_BITS_PER_INT - 1)) + + DM_BITS_PER_INT; } return -1; } -int bit_get_first(bitset_t bs) +int dm_bit_get_first(dm_bitset_t bs) { - return bit_get_next(bs, -1); + return dm_bit_get_next(bs, -1); } diff --git a/lib/datastruct/hash.c b/lib/datastruct/hash.c index 6753ca7..d5564e0 100644 --- a/lib/datastruct/hash.c +++ b/lib/datastruct/hash.c @@ -14,19 +14,18 @@ */ #include "lib.h" -#include "hash.h" -struct hash_node { - struct hash_node *next; +struct dm_hash_node { + struct dm_hash_node *next; void *data; int keylen; char key[0]; }; -struct hash_table { +struct dm_hash_table { int num_nodes; int num_slots; - struct hash_node **slots; + struct dm_hash_node **slots; }; /* Permutation of the Integers 0 through 255 */ @@ -57,9 +56,9 @@ static unsigned char _nums[] = { 209 }; -static struct hash_node *_create_node(const char *str, int len) +static struct dm_hash_node *_create_node(const char *str, int len) { - struct hash_node *n = dbg_malloc(sizeof(*n) + len); + struct dm_hash_node *n = dm_malloc(sizeof(*n) + len); if (n) { memcpy(n->key, str, len); @@ -86,11 +85,11 @@ static unsigned _hash(const char *str, uint32_t len) return h; } -struct hash_table *hash_create(unsigned size_hint) +struct dm_hash_table *dm_hash_create(unsigned size_hint) { size_t len; unsigned new_size = 16u; - struct hash_table *hc = dbg_malloc(sizeof(*hc)); + struct dm_hash_table *hc = dm_malloc(sizeof(*hc)); if (!hc) { stack; @@ -105,7 +104,7 @@ struct hash_table *hash_create(unsigned size_hint) hc->num_slots = new_size; len = sizeof(*(hc->slots)) * new_size; - if (!(hc->slots = dbg_malloc(len))) { + if (!(hc->slots = dm_malloc(len))) { stack; goto bad; } @@ -113,35 +112,35 @@ struct hash_table *hash_create(unsigned size_hint) return hc; bad: - dbg_free(hc->slots); - dbg_free(hc); + dm_free(hc->slots); + dm_free(hc); return 0; } -static void _free_nodes(struct hash_table *t) +static void _free_nodes(struct dm_hash_table *t) { - struct hash_node *c, *n; + struct dm_hash_node *c, *n; int i; for (i = 0; i < t->num_slots; i++) for (c = t->slots[i]; c; c = n) { n = c->next; - dbg_free(c); + dm_free(c); } } -void hash_destroy(struct hash_table *t) +void dm_hash_destroy(struct dm_hash_table *t) { _free_nodes(t); - dbg_free(t->slots); - dbg_free(t); + dm_free(t->slots); + dm_free(t); } -static inline struct hash_node **_find(struct hash_table *t, const char *key, +static inline struct dm_hash_node **_find(struct dm_hash_table *t, const char *key, uint32_t len) { unsigned h = _hash(key, len) & (t->num_slots - 1); - struct hash_node **c; + struct dm_hash_node **c; for (c = &t->slots[h]; *c; c = &((*c)->next)) if (!memcmp(key, (*c)->key, len)) @@ -150,22 +149,22 @@ static inline struct hash_node **_find(struct hash_table *t, const char *key, return c; } -void *hash_lookup_binary(struct hash_table *t, const char *key, +void *dm_hash_lookup_binary(struct dm_hash_table *t, const char *key, uint32_t len) { - struct hash_node **c = _find(t, key, len); + struct dm_hash_node **c = _find(t, key, len); return *c ? (*c)->data : 0; } -int hash_insert_binary(struct hash_table *t, const char *key, +int dm_hash_insert_binary(struct dm_hash_table *t, const char *key, uint32_t len, void *data) { - struct hash_node **c = _find(t, key, len); + struct dm_hash_node **c = _find(t, key, len); if (*c) (*c)->data = data; else { - struct hash_node *n = _create_node(key, len); + struct dm_hash_node *n = _create_node(key, len); if (!n) return 0; @@ -179,42 +178,42 @@ int hash_insert_binary(struct hash_table *t, const char *key, return 1; } -void hash_remove_binary(struct hash_table *t, const char *key, +void dm_hash_remove_binary(struct dm_hash_table *t, const char *key, uint32_t len) { - struct hash_node **c = _find(t, key, len); + struct dm_hash_node **c = _find(t, key, len); if (*c) { - struct hash_node *old = *c; + struct dm_hash_node *old = *c; *c = (*c)->next; - dbg_free(old); + dm_free(old); t->num_nodes--; } } -void *hash_lookup(struct hash_table *t, const char *key) +void *dm_hash_lookup(struct dm_hash_table *t, const char *key) { - return hash_lookup_binary(t, key, strlen(key) + 1); + return dm_hash_lookup_binary(t, key, strlen(key) + 1); } -int hash_insert(struct hash_table *t, const char *key, void *data) +int dm_hash_insert(struct dm_hash_table *t, const char *key, void *data) { - return hash_insert_binary(t, key, strlen(key) + 1, data); + return dm_hash_insert_binary(t, key, strlen(key) + 1, data); } -void hash_remove(struct hash_table *t, const char *key) +void dm_hash_remove(struct dm_hash_table *t, const char *key) { - hash_remove_binary(t, key, strlen(key) + 1); + dm_hash_remove_binary(t, key, strlen(key) + 1); } -unsigned hash_get_num_entries(struct hash_table *t) +unsigned dm_hash_get_num_entries(struct dm_hash_table *t) { return t->num_nodes; } -void hash_iter(struct hash_table *t, iterate_fn f) +void dm_hash_iter(struct dm_hash_table *t, dm_hash_iterate_fn f) { - struct hash_node *c; + struct dm_hash_node *c; int i; for (i = 0; i < t->num_slots; i++) @@ -222,26 +221,26 @@ void hash_iter(struct hash_table *t, iterate_fn f) f(c->data); } -void hash_wipe(struct hash_table *t) +void dm_hash_wipe(struct dm_hash_table *t) { _free_nodes(t); - memset(t->slots, 0, sizeof(struct hash_node *) * t->num_slots); + memset(t->slots, 0, sizeof(struct dm_hash_node *) * t->num_slots); t->num_nodes = 0; } -char *hash_get_key(struct hash_table *t, struct hash_node *n) +char *dm_hash_get_key(struct dm_hash_table *t, struct dm_hash_node *n) { return n->key; } -void *hash_get_data(struct hash_table *t, struct hash_node *n) +void *dm_hash_get_data(struct dm_hash_table *t, struct dm_hash_node *n) { return n->data; } -static struct hash_node *_next_slot(struct hash_table *t, unsigned s) +static struct dm_hash_node *_next_slot(struct dm_hash_table *t, unsigned s) { - struct hash_node *c = NULL; + struct dm_hash_node *c = NULL; int i; for (i = s; i < t->num_slots && !c; i++) @@ -250,12 +249,12 @@ static struct hash_node *_next_slot(struct hash_table *t, unsigned s) return c; } -struct hash_node *hash_get_first(struct hash_table *t) +struct dm_hash_node *dm_hash_get_first(struct dm_hash_table *t) { return _next_slot(t, 0); } -struct hash_node *hash_get_next(struct hash_table *t, struct hash_node *n) +struct dm_hash_node *dm_hash_get_next(struct dm_hash_table *t, struct dm_hash_node *n) { unsigned h = _hash(n->key, n->keylen) & (t->num_slots - 1); return n->next ? n->next : _next_slot(t, h + 1); diff --git a/lib/ioctl/libdm-iface.c b/lib/ioctl/libdm-iface.c index b034038..02354c8 100644 --- a/lib/ioctl/libdm-iface.c +++ b/lib/ioctl/libdm-iface.c @@ -17,7 +17,6 @@ #include "libdm-targets.h" #include "libdm-common.h" #include "libdm-file.h" -#include "bitset.h" #ifdef DM_COMPAT # include "libdm-compat.h" @@ -63,7 +62,7 @@ static int _dm_version = DM_VERSION_MAJOR; static int _log_suppress = 0; -static bitset_t _dm_bitset = NULL; +static dm_bitset_t _dm_bitset = NULL; static int _control_fd = -1; static int _version_checked = 0; static int _version_ok = 1; @@ -148,7 +147,7 @@ static int _get_proc_number(const char *file, const char *name, fclose(fl); return 1; } - bit_set(_dm_bitset, num); + dm_bit_set(_dm_bitset, num); } } else do { c = fgetc(fl); @@ -253,11 +252,11 @@ static int _create_dm_bitset(void) if (_dm_bitset) return 1; - if (!(_dm_bitset = bitset_create(NULL, NUMBER_OF_MAJORS))) + if (!(_dm_bitset = dm_bitset_create(NULL, NUMBER_OF_MAJORS))) return 0; if (!_get_proc_number(PROC_DEVICES, DM_NAME, NULL)) { - bitset_destroy(_dm_bitset); + dm_bitset_destroy(_dm_bitset); _dm_bitset = NULL; return 0; } @@ -273,7 +272,7 @@ int dm_is_dm_major(uint32_t major) if (!_create_dm_bitset()) return 0; - return bit(_dm_bitset, major) ? 1 : 0; + return dm_bit(_dm_bitset, major) ? 1 : 0; } static int _open_control(void) @@ -320,27 +319,27 @@ void dm_task_destroy(struct dm_task *dmt) for (t = dmt->head; t; t = n) { n = t->next; - dbg_free(t->params); - dbg_free(t->type); - dbg_free(t); + dm_free(t->params); + dm_free(t->type); + dm_free(t); } if (dmt->dev_name) - dbg_free(dmt->dev_name); + dm_free(dmt->dev_name); if (dmt->newname) - dbg_free(dmt->newname); + dm_free(dmt->newname); if (dmt->message) - dbg_free(dmt->message); + dm_free(dmt->message); if (dmt->dmi.v4) - dbg_free(dmt->dmi.v4); + dm_free(dmt->dmi.v4); if (dmt->uuid) - dbg_free(dmt->uuid); + dm_free(dmt->uuid); - dbg_free(dmt); + dm_free(dmt); } /* @@ -521,7 +520,7 @@ static struct dm_ioctl_v1 *_flatten_v1(struct dm_task *dmt) if (len < min_size) len = min_size; - if (!(dmi = dbg_malloc(len))) + if (!(dmi = dm_malloc(len))) return NULL; memset(dmi, 0, len); @@ -570,7 +569,7 @@ static struct dm_ioctl_v1 *_flatten_v1(struct dm_task *dmt) return dmi; bad: - dbg_free(dmi); + dm_free(dmi); return NULL; } @@ -721,7 +720,7 @@ static int _dm_task_run_v1(struct dm_task *dmt) dmt->type = DM_DEVICE_INFO; if (!dm_task_run(dmt)) goto bad; - dbg_free(dmi); /* We'll use what info returned */ + dm_free(dmi); /* We'll use what info returned */ return 1; } @@ -729,7 +728,7 @@ static int _dm_task_run_v1(struct dm_task *dmt) return 1; bad: - dbg_free(dmi); + dm_free(dmi); return 0; } @@ -969,7 +968,7 @@ int dm_task_set_ro(struct dm_task *dmt) int dm_task_set_newname(struct dm_task *dmt, const char *newname) { - if (!(dmt->newname = dbg_strdup(newname))) { + if (!(dmt->newname = dm_strdup(newname))) { log_error("dm_task_set_newname: strdup(%s) failed", newname); return 0; } @@ -979,7 +978,7 @@ int dm_task_set_newname(struct dm_task *dmt, const char *newname) int dm_task_set_message(struct dm_task *dmt, const char *message) { - if (!(dmt->message = dbg_strdup(message))) { + if (!(dmt->message = dm_strdup(message))) { log_error("dm_task_set_message: strdup(%s) failed", message); return 0; } @@ -1018,7 +1017,7 @@ int dm_task_set_event_nr(struct dm_task *dmt, uint32_t event_nr) struct target *create_target(uint64_t start, uint64_t len, const char *type, const char *params) { - struct target *t = dbg_malloc(sizeof(*t)); + struct target *t = dm_malloc(sizeof(*t)); if (!t) { log_error("create_target: malloc(%d) failed", sizeof(*t)); @@ -1027,12 +1026,12 @@ struct target *create_target(uint64_t start, uint64_t len, const char *type, memset(t, 0, sizeof(*t)); - if (!(t->params = dbg_strdup(params))) { + if (!(t->params = dm_strdup(params))) { log_error("create_target: strdup(params) failed"); goto bad; } - if (!(t->type = dbg_strdup(type))) { + if (!(t->type = dm_strdup(type))) { log_error("create_target: strdup(type) failed"); goto bad; } @@ -1042,9 +1041,9 @@ struct target *create_target(uint64_t start, uint64_t len, const char *type, return t; bad: - dbg_free(t->params); - dbg_free(t->type); - dbg_free(t); + dm_free(t->params); + dm_free(t->type); + dm_free(t); return NULL; } @@ -1142,7 +1141,7 @@ static struct dm_ioctl *_flatten(struct dm_task *dmt, unsigned repeat_count) while (repeat_count--) len *= 2; - if (!(dmi = dbg_malloc(len))) + if (!(dmi = dm_malloc(len))) return NULL; memset(dmi, 0, len); @@ -1200,7 +1199,7 @@ static struct dm_ioctl *_flatten(struct dm_task *dmt, unsigned repeat_count) return dmi; bad: - dbg_free(dmi); + dm_free(dmi); return NULL; } @@ -1335,7 +1334,7 @@ static int _create_and_load_v4(struct dm_task *dmt) /* Use the original structure last so the info will be correct */ dmt->type = DM_DEVICE_RESUME; - dbg_free(dmt->uuid); + dm_free(dmt->uuid); dmt->uuid = NULL; r = dm_task_run(dmt); @@ -1383,7 +1382,7 @@ static struct dm_ioctl *_do_dm_ioctl(struct dm_task *dmt, unsigned command, log_error("device-mapper ioctl " "cmd %d failed: %s", _IOC_NR(command), strerror(errno)); - dbg_free(dmi); + dm_free(dmi); return NULL; } } @@ -1435,7 +1434,7 @@ repeat_ioctl: case DM_DEVICE_TABLE: case DM_DEVICE_WAITEVENT: _ioctl_buffer_double_factor++; - dbg_free(dmi); + dm_free(dmi); goto repeat_ioctl; default: log_error("Warning: libdevmapper buffer too small for data"); @@ -1481,7 +1480,7 @@ repeat_ioctl: return 1; bad: - dbg_free(dmi); + dm_free(dmi); return 0; } @@ -1498,9 +1497,9 @@ void dm_lib_exit(void) { dm_lib_release(); if (_dm_bitset) - bitset_destroy(_dm_bitset); + dm_bitset_destroy(_dm_bitset); _dm_bitset = NULL; - dump_memory(); + dm_dump_memory(); _version_ok = 1; _version_checked = 0; } diff --git a/lib/libdevmapper.h b/lib/libdevmapper.h index cfee262..a1fa6ee 100644 --- a/lib/libdevmapper.h +++ b/lib/libdevmapper.h @@ -23,6 +23,10 @@ # include #endif +#include +#include +#include + /* * Since it is quite laborious to build the ioctl * arguments for the device-mapper people are @@ -176,6 +180,15 @@ int dm_is_dm_major(uint32_t major); void dm_lib_release(void); void dm_lib_exit(void) __attribute((destructor)); +/*********************************************************************** + * Wrappers + ***********************************************************************/ + +/* + * Use NULL for all devices. + */ +int dm_mknodes(const char *name); + /***************************** * Dependency tree functions * *****************************/ @@ -232,4 +245,202 @@ const struct dm_info *dm_deptree_node_get_info(struct deptree_node *node); */ int dm_deptree_node_num_children(struct deptree_node *node, uint32_t inverted); +/***************************************************************************** + * Library functions + *****************************************************************************/ + +void *dm_malloc_aux(size_t s, const char *file, int line); +#define dm_malloc(s) dm_malloc_aux((s), __FILE__, __LINE__) + +char *dm_strdup(const char *str); + +#ifdef DEBUG_MEM + +void dm_free_aux(void *p); +void *dm_realloc_aux(void *p, unsigned int s, const char *file, int line); +int dm_dump_memory(void); +void dm_bounds_check(void); + +# define dm_free(p) dm_free_aux(p) +# define dm_realloc(p, s) dm_realloc_aux(p, s, __FILE__, __LINE__) + +#else + +# define dm_free(p) free(p) +# define dm_realloc(p, s) realloc(p, s) +# define dm_dump_memory() +# define dm_bounds_check() + +#endif + +/****************** + * pool functions + ******************/ + +/* + * The pool allocator is useful when you are going to allocate + * lots of memory, use the memory for a bit, and then free the + * memory in one go. A surprising amount of code has this usage + * profile. + * + * You should think of the pool as an infinite, contiguous chunk + * of memory. The front of this chunk of memory contains + * allocated objects, the second half is free. dm_pool_alloc grabs + * the next 'size' bytes from the free half, in effect moving it + * into the allocated half. This operation is very efficient. + * + * dm_pool_free frees the allocated object *and* all objects + * allocated after it. It is important to note this semantic + * difference from malloc/free. This is also extremely + * efficient, since a single dm_pool_free can dispose of a large + * complex object. + * + * dm_pool_destroy frees all allocated memory. + * + * eg, If you are building a binary tree in your program, and + * know that you are only ever going to insert into your tree, + * and not delete (eg, maintaining a symbol table for a + * compiler). You can create yourself a pool, allocate the nodes + * from it, and when the tree becomes redundant call dm_pool_destroy + * (no nasty iterating through the tree to free nodes). + * + * eg, On the other hand if you wanted to repeatedly insert and + * remove objects into the tree, you would be better off + * allocating the nodes from a free list; you cannot free a + * single arbitrary node with pool. + */ + +struct dm_pool; + +/* constructor and destructor */ +struct dm_pool *dm_pool_create(const char *name, size_t chunk_hint); +void dm_pool_destroy(struct dm_pool *p); + +/* simple allocation/free routines */ +void *dm_pool_alloc(struct dm_pool *p, size_t s); +void *dm_pool_alloc_aligned(struct dm_pool *p, size_t s, unsigned alignment); +void dm_pool_empty(struct dm_pool *p); +void dm_pool_free(struct dm_pool *p, void *ptr); + +/* + * Object building routines: + * + * These allow you to 'grow' an object, useful for + * building strings, or filling in dynamic + * arrays. + * + * It's probably best explained with an example: + * + * char *build_string(struct dm_pool *mem) + * { + * int i; + * char buffer[16]; + * + * if (!dm_pool_begin_object(mem, 128)) + * return NULL; + * + * for (i = 0; i < 50; i++) { + * snprintf(buffer, sizeof(buffer), "%d, ", i); + * if (!dm_pool_grow_object(mem, buffer, strlen(buffer))) + * goto bad; + * } + * + * // add null + * if (!dm_pool_grow_object(mem, "\0", 1)) + * goto bad; + * + * return dm_pool_end_object(mem); + * + * bad: + * + * dm_pool_abandon_object(mem); + * return NULL; + *} + * + * So start an object by calling dm_pool_begin_object + * with a guess at the final object size - if in + * doubt make the guess too small. + * + * Then append chunks of data to your object with + * dm_pool_grow_object. Finally get your object with + * a call to dm_pool_end_object. + * + */ +int dm_pool_begin_object(struct dm_pool *p, size_t hint); +int dm_pool_grow_object(struct dm_pool *p, const void *extra, size_t delta); +void *dm_pool_end_object(struct dm_pool *p); +void dm_pool_abandon_object(struct dm_pool *p); + +/* utilities */ +char *dm_pool_strdup(struct dm_pool *p, const char *str); +char *dm_pool_strndup(struct dm_pool *p, const char *str, size_t n); +void *dm_pool_zalloc(struct dm_pool *p, size_t s); + +/****************** + * bitset functions + ******************/ + +typedef uint32_t *dm_bitset_t; + +dm_bitset_t dm_bitset_create(struct dm_pool *mem, unsigned num_bits); +void dm_bitset_destroy(dm_bitset_t bs); + +void dm_bit_union(dm_bitset_t out, dm_bitset_t in1, dm_bitset_t in2); +int dm_bit_get_first(dm_bitset_t bs); +int dm_bit_get_next(dm_bitset_t bs, int last_bit); + +#define DM_BITS_PER_INT (sizeof(int) * CHAR_BIT) + +#define dm_bit(bs, i) \ + (bs[(i / DM_BITS_PER_INT) + 1] & (0x1 << (i & (DM_BITS_PER_INT - 1)))) + +#define dm_bit_set(bs, i) \ + (bs[(i / DM_BITS_PER_INT) + 1] |= (0x1 << (i & (DM_BITS_PER_INT - 1)))) + +#define dm_bit_clear(bs, i) \ + (bs[(i / DM_BITS_PER_INT) + 1] &= ~(0x1 << (i & (DM_BITS_PER_INT - 1)))) + +#define dm_bit_set_all(bs) \ + memset(bs + 1, -1, ((*bs / DM_BITS_PER_INT) + 1) * sizeof(int)) + +#define dm_bit_clear_all(bs) \ + memset(bs + 1, 0, ((*bs / DM_BITS_PER_INT) + 1) * sizeof(int)) + +#define dm_bit_copy(bs1, bs2) \ + memcpy(bs1 + 1, bs2 + 1, ((*bs1 / DM_BITS_PER_INT) + 1) * sizeof(int)) + +/**************** + * hash functions + ****************/ + +struct dm_hash_table; +struct dm_hash_node; + +typedef void (*dm_hash_iterate_fn) (void *data); + +struct dm_hash_table *dm_hash_create(unsigned size_hint); +void dm_hash_destroy(struct dm_hash_table *t); +void dm_hash_wipe(struct dm_hash_table *t); + +void *dm_hash_lookup(struct dm_hash_table *t, const char *key); +int dm_hash_insert(struct dm_hash_table *t, const char *key, void *data); +void dm_hash_remove(struct dm_hash_table *t, const char *key); + +void *dm_hash_lookup_binary(struct dm_hash_table *t, const char *key, uint32_t len); +int dm_hash_insert_binary(struct dm_hash_table *t, const char *key, uint32_t len, + void *data); +void dm_hash_remove_binary(struct dm_hash_table *t, const char *key, uint32_t len); + +unsigned dm_hash_get_num_entries(struct dm_hash_table *t); +void dm_hash_iter(struct dm_hash_table *t, dm_hash_iterate_fn f); + +char *dm_hash_get_key(struct dm_hash_table *t, struct dm_hash_node *n); +void *dm_hash_get_data(struct dm_hash_table *t, struct dm_hash_node *n); +struct dm_hash_node *dm_hash_get_first(struct dm_hash_table *t); +struct dm_hash_node *dm_hash_get_next(struct dm_hash_table *t, struct dm_hash_node *n); + +#define dm_hash_iterate(v, h) \ + for (v = dm_hash_get_first(h); v; \ + v = dm_hash_get_next(h, v)) + #endif /* LIB_DEVICE_MAPPER_H */ diff --git a/lib/libdm-common.c b/lib/libdm-common.c index e9ea1bc..4c11856 100644 --- a/lib/libdm-common.c +++ b/lib/libdm-common.c @@ -93,7 +93,7 @@ int dm_get_library_version(char *version, size_t size) struct dm_task *dm_task_create(int type) { - struct dm_task *dmt = dbg_malloc(sizeof(*dmt)); + struct dm_task *dmt = dm_malloc(sizeof(*dmt)); if (!dmt) { log_error("dm_task_create: malloc(%d) failed", sizeof(*dmt)); @@ -123,7 +123,7 @@ int dm_task_set_name(struct dm_task *dmt, const char *name) struct stat st1, st2; if (dmt->dev_name) { - dbg_free(dmt->dev_name); + dm_free(dmt->dev_name); dmt->dev_name = NULL; } @@ -143,7 +143,7 @@ int dm_task_set_name(struct dm_task *dmt, const char *name) name = pos + 1; } - if (!(dmt->dev_name = dbg_strdup(name))) { + if (!(dmt->dev_name = dm_strdup(name))) { log_error("dm_task_set_name: strdup(%s) failed", name); return 0; } @@ -154,11 +154,11 @@ int dm_task_set_name(struct dm_task *dmt, const char *name) int dm_task_set_uuid(struct dm_task *dmt, const char *uuid) { if (dmt->uuid) { - dbg_free(dmt->uuid); + dm_free(dmt->uuid); dmt->uuid = NULL; } - if (!(dmt->uuid = dbg_strdup(uuid))) { + if (!(dmt->uuid = dm_strdup(uuid))) { log_error("dm_task_set_uuid: strdup(%s) failed", uuid); return 0; } @@ -381,7 +381,7 @@ static int _stack_node_op(node_op_t type, const char *dev_name, uint32_t major, size_t len = strlen(dev_name) + strlen(old_name) + 2; char *pos; - if (!(nop = dbg_malloc(sizeof(*nop) + len))) { + if (!(nop = dm_malloc(sizeof(*nop) + len))) { log_error("Insufficient memory to stack mknod operation"); return 0; } @@ -412,7 +412,7 @@ static void _pop_node_ops(void) _do_node_op(nop->type, nop->dev_name, nop->major, nop->minor, nop->uid, nop->gid, nop->mode, nop->old_name); list_del(&nop->list); - dbg_free(nop); + dm_free(nop); } } @@ -448,3 +448,24 @@ const char *dm_dir(void) { return _dm_dir; } + +int dm_mknodes(const char *name) +{ + struct dm_task *dmt; + int r = 0; + + if (!(dmt = dm_task_create(DM_DEVICE_MKNODES))) + return 0; + + if (name && !dm_task_set_name(dmt, name)) + goto out; + + if (!dm_task_no_open_count(dmt)) + goto out; + + r = dm_task_run(dmt); + +out: + dm_task_destroy(dmt); + return r; +} diff --git a/lib/libdm-deptree.c b/lib/libdm-deptree.c index daa5936..e8969d4 100644 --- a/lib/libdm-deptree.c +++ b/lib/libdm-deptree.c @@ -17,8 +17,6 @@ #include "libdm-common.h" #include "list.h" #include "kdev_t.h" -#include "pool.h" -#include "hash.h" #include #include @@ -37,8 +35,8 @@ struct deptree_node { }; struct deptree { - struct pool *mem; - struct hash_table *devs; + struct dm_pool *mem; + struct dm_hash_table *devs; struct deptree_node root; }; @@ -51,7 +49,7 @@ struct deptree *dm_deptree_create(void) { struct deptree *deptree; - if (!(deptree = dbg_malloc(sizeof(*deptree)))) { + if (!(deptree = dm_malloc(sizeof(*deptree)))) { log_error("dm_deptree_create malloc failed"); return NULL; } @@ -61,16 +59,16 @@ struct deptree *dm_deptree_create(void) list_init(&deptree->root.uses); list_init(&deptree->root.used_by); - if (!(deptree->mem = pool_create("deptree", 1024))) { + if (!(deptree->mem = dm_pool_create("deptree", 1024))) { log_error("deptree pool creation failed"); - dbg_free(deptree); + dm_free(deptree); return NULL; } - if (!(deptree->devs = hash_create(8))) { + if (!(deptree->devs = dm_hash_create(8))) { log_error("deptree hash creation failed"); - pool_destroy(deptree->mem); - dbg_free(deptree); + dm_pool_destroy(deptree->mem); + dm_free(deptree); return NULL; } @@ -82,9 +80,9 @@ void dm_deptree_free(struct deptree *deptree) if (!deptree) return; - hash_destroy(deptree->devs); - pool_destroy(deptree->mem); - dbg_free(deptree); + dm_hash_destroy(deptree->devs); + dm_pool_destroy(deptree->mem); + dm_free(deptree); } static int _nodes_are_linked(struct deptree_node *parent, @@ -104,7 +102,7 @@ static int _link(struct list *list, struct deptree_node *node) { struct deptree_link *dlink; - if (!(dlink = pool_alloc(node->deptree->mem, sizeof(*dlink)))) { + if (!(dlink = dm_pool_alloc(node->deptree->mem, sizeof(*dlink)))) { log_error("deptree link allocation failed"); return 0; } @@ -171,7 +169,7 @@ static struct deptree_node *_create_deptree_node(struct deptree *deptree, struct deptree_node *node; uint64_t dev; - if (!(node = pool_zalloc(deptree->mem, sizeof(*node)))) { + if (!(node = dm_pool_zalloc(deptree->mem, sizeof(*node)))) { log_error("_create_deptree_node alloc failed"); return NULL; } @@ -187,10 +185,10 @@ static struct deptree_node *_create_deptree_node(struct deptree *deptree, dev = MKDEV(info->major, info->minor); - if (!hash_insert_binary(deptree->devs, (const char *) &dev, + if (!dm_hash_insert_binary(deptree->devs, (const char *) &dev, sizeof(dev), node)) { log_error("deptree node hash insertion failed"); - pool_free(deptree->mem, node); + dm_pool_free(deptree->mem, node); return NULL; } @@ -202,11 +200,11 @@ static struct deptree_node *_find_deptree_node(struct deptree *deptree, { uint64_t dev = MKDEV(major, minor); - return hash_lookup_binary(deptree->devs, (const char *) &dev, + return dm_hash_lookup_binary(deptree->devs, (const char *) &dev, sizeof(dev)); } -static int _deps(struct dm_task **dmt, struct pool *mem, uint32_t major, uint32_t minor, +static int _deps(struct dm_task **dmt, struct dm_pool *mem, uint32_t major, uint32_t minor, const char **name, const char **uuid, struct dm_info *info, struct dm_deps **deps) { @@ -254,11 +252,11 @@ static int _deps(struct dm_task **dmt, struct pool *mem, uint32_t major, uint32_ minor, info->minor); goto failed; } - if (!(*name = pool_strdup(mem, dm_task_get_name(*dmt)))) { + if (!(*name = dm_pool_strdup(mem, dm_task_get_name(*dmt)))) { log_error("name pool_strdup failed"); goto failed; } - if (!(*uuid = pool_strdup(mem, dm_task_get_uuid(*dmt)))) { + if (!(*uuid = dm_pool_strdup(mem, dm_task_get_uuid(*dmt)))) { log_error("uuid pool_strdup failed"); goto failed; } diff --git a/lib/mm/dbg_malloc.c b/lib/mm/dbg_malloc.c index 6c2b4d1..2e9ac94 100644 --- a/lib/mm/dbg_malloc.c +++ b/lib/mm/dbg_malloc.c @@ -14,14 +14,13 @@ */ #include "lib.h" -#include "dbg_malloc.h" #include #include -char *dbg_strdup(const char *str) +char *dm_strdup(const char *str) { - char *ret = dbg_malloc(strlen(str) + 1); + char *ret = dm_malloc(strlen(str) + 1); if (ret) strcpy(ret, str); @@ -52,7 +51,7 @@ static struct { static struct memblock *_head = 0; static struct memblock *_tail = 0; -void *malloc_aux(size_t s, const char *file, int line) +void *dm_malloc_aux(size_t s, const char *file, int line) { struct memblock *nb; size_t tsize = s + sizeof(*nb) + sizeof(unsigned long); @@ -74,7 +73,7 @@ void *malloc_aux(size_t s, const char *file, int line) nb->line = line; #ifdef BOUNDS_CHECK - bounds_check(); + dm_bounds_check(); #endif /* setup fields */ @@ -118,7 +117,7 @@ void *malloc_aux(size_t s, const char *file, int line) return nb + 1; } -void free_aux(void *p) +void dm_free_aux(void *p) { char *ptr; size_t i; @@ -127,7 +126,7 @@ void free_aux(void *p) return; #ifdef BOUNDS_CHECK - bounds_check(); + dm_bounds_check(); #endif /* sanity check */ @@ -167,22 +166,22 @@ void free_aux(void *p) free(mb); } -void *realloc_aux(void *p, unsigned int s, const char *file, int line) +void *dm_realloc_aux(void *p, unsigned int s, const char *file, int line) { void *r; struct memblock *mb = ((struct memblock *) p) - 1; - r = malloc_aux(s, file, line); + r = dm_malloc_aux(s, file, line); if (p) { memcpy(r, p, mb->length); - free_aux(p); + dm_free_aux(p); } return r; } -int dump_memory(void) +int dm_dump_memory(void) { unsigned long tot = 0; struct memblock *mb; @@ -217,7 +216,7 @@ int dump_memory(void) return 1; } -void bounds_check(void) +void dm_bounds_check(void) { struct memblock *mb = _head; while (mb) { @@ -233,7 +232,7 @@ void bounds_check(void) #else -void *malloc_aux(size_t s, const char *file, int line) +void *dm_malloc_aux(size_t s, const char *file, int line) { if (s > 50000000) { log_error("Huge memory allocation (size %" PRIsize_t diff --git a/lib/mm/dbg_malloc.h b/lib/mm/dbg_malloc.h index 3f6d08d..a655307 100644 --- a/lib/mm/dbg_malloc.h +++ b/lib/mm/dbg_malloc.h @@ -20,7 +20,7 @@ #include void *malloc_aux(size_t s, const char *file, int line); -#define dbg_malloc(s) malloc_aux((s), __FILE__, __LINE__) +#define dm_malloc(s) malloc_aux((s), __FILE__, __LINE__) char *dbg_strdup(const char *str); @@ -31,12 +31,12 @@ void *realloc_aux(void *p, unsigned int s, const char *file, int line); int dump_memory(void); void bounds_check(void); -# define dbg_free(p) free_aux(p) +# define dm_free(p) free_aux(p) # define dbg_realloc(p, s) realloc_aux(p, s, __FILE__, __LINE__) #else -# define dbg_free(p) free(p) +# define dm_free(p) free(p) # define dbg_realloc(p, s) realloc(p, s) # define dump_memory() # define bounds_check() diff --git a/lib/mm/pool-debug.c b/lib/mm/pool-debug.c index de3525d..d680768 100644 --- a/lib/mm/pool-debug.c +++ b/lib/mm/pool-debug.c @@ -14,7 +14,6 @@ */ #include "lib.h" -#include "pool.h" struct block { struct block *next; @@ -29,7 +28,7 @@ typedef struct { unsigned int bytes, maxbytes; } pool_stats; -struct pool { +struct dm_pool { const char *name; int begun; @@ -44,9 +43,9 @@ struct pool { /* by default things come out aligned for doubles */ #define DEFAULT_ALIGNMENT __alignof__ (double) -struct pool *pool_create(const char *name, size_t chunk_hint) +struct pool *dm_pool_create(const char *name, size_t chunk_hint) { - struct pool *mem = dbg_malloc(sizeof(*mem)); + struct dm_pool *mem = dm_malloc(sizeof(*mem)); if (!mem) { log_error("Couldn't create memory pool %s (size %" @@ -72,7 +71,7 @@ struct pool *pool_create(const char *name, size_t chunk_hint) return mem; } -static void _free_blocks(struct pool *p, struct block *b) +static void _free_blocks(struct dm_pool *p, struct block *b) { struct block *n; @@ -81,13 +80,13 @@ static void _free_blocks(struct pool *p, struct block *b) p->stats.blocks_allocated--; n = b->next; - dbg_free(b->data); - dbg_free(b); + dm_free(b->data); + dm_free(b); b = n; } } -static void _pool_stats(struct pool *p, const char *action) +static void _pool_stats(struct dm_pool *p, const char *action) { #ifdef DEBUG_POOL log_debug("%s mempool %s: %u/%u bytes, %u/%u blocks, " @@ -99,19 +98,19 @@ static void _pool_stats(struct pool *p, const char *action) #endif } -void pool_destroy(struct pool *p) +void dm_pool_destroy(struct dm_pool *p) { _pool_stats(p, "Destroying"); _free_blocks(p, p->blocks); - dbg_free(p); + dm_free(p); } -void *pool_alloc(struct pool *p, size_t s) +void *dm_pool_alloc(struct dm_pool *p, size_t s) { - return pool_alloc_aligned(p, s, DEFAULT_ALIGNMENT); + return dm_pool_alloc_aligned(p, s, DEFAULT_ALIGNMENT); } -static void _append_block(struct pool *p, struct block *b) +static void _append_block(struct dm_pool *p, struct block *b) { if (p->tail) { p->tail->next = b; @@ -135,7 +134,7 @@ static struct block *_new_block(size_t s, unsigned alignment) /* FIXME: I'm currently ignoring the alignment arg. */ size_t len = sizeof(struct block) + s; - struct block *b = dbg_malloc(len); + struct block *b = dm_malloc(len); /* * Too lazy to implement alignment for debug version, and @@ -149,9 +148,9 @@ static struct block *_new_block(size_t s, unsigned alignment) return NULL; } - if (!(b->data = dbg_malloc(s))) { + if (!(b->data = dm_malloc(s))) { log_err(_oom); - dbg_free(b); + dm_free(b); return NULL; } @@ -161,7 +160,7 @@ static struct block *_new_block(size_t s, unsigned alignment) return b; } -void *pool_alloc_aligned(struct pool *p, size_t s, unsigned alignment) +void *dm_pool_alloc_aligned(struct dm_pool *p, size_t s, unsigned alignment) { struct block *b = _new_block(s, alignment); @@ -173,14 +172,14 @@ void *pool_alloc_aligned(struct pool *p, size_t s, unsigned alignment) return b->data; } -void pool_empty(struct pool *p) +void dm_pool_empty(struct dm_pool *p) { _pool_stats(p, "Emptying"); _free_blocks(p, p->blocks); p->blocks = p->tail = NULL; } -void pool_free(struct pool *p, void *ptr) +void dm_pool_free(struct dm_pool *p, void *ptr) { struct block *b, *prev = NULL; @@ -210,14 +209,14 @@ void pool_free(struct pool *p, void *ptr) _pool_stats(p, "Freeing (after)"); } -int pool_begin_object(struct pool *p, size_t init_size) +int dm_pool_begin_object(struct dm_pool *p, size_t init_size) { assert(!p->begun); p->begun = 1; return 1; } -int pool_grow_object(struct pool *p, const void *buffer, size_t delta) +int dm_pool_grow_object(struct dm_pool *p, const void *buffer, size_t delta) { struct block *new; size_t size = delta; @@ -234,8 +233,8 @@ int pool_grow_object(struct pool *p, const void *buffer, size_t delta) if (p->object) { memcpy(new->data, p->object->data, p->object->size); - dbg_free(p->object->data); - dbg_free(p->object); + dm_free(p->object->data); + dm_free(p->object); } p->object = new; @@ -244,7 +243,7 @@ int pool_grow_object(struct pool *p, const void *buffer, size_t delta) return 1; } -void *pool_end_object(struct pool *p) +void *dm_pool_end_object(struct dm_pool *p) { assert(p->begun); _append_block(p, p->object); @@ -254,10 +253,10 @@ void *pool_end_object(struct pool *p) return p->tail->data; } -void pool_abandon_object(struct pool *p) +void dm_pool_abandon_object(struct dm_pool *p) { assert(p->begun); - dbg_free(p->object); + dm_free(p->object); p->begun = 0; p->object = NULL; } diff --git a/lib/mm/pool-fast.c b/lib/mm/pool-fast.c index 56102e5..028af02 100644 --- a/lib/mm/pool-fast.c +++ b/lib/mm/pool-fast.c @@ -14,14 +14,13 @@ */ #include "lib.h" -#include "pool.h" struct chunk { char *begin, *end; struct chunk *prev; }; -struct pool { +struct dm_pool { struct chunk *chunk, *spare_chunk; /* spare_chunk is a one entry free list to stop 'bobbling' */ size_t chunk_size; @@ -30,15 +29,15 @@ struct pool { }; void _align_chunk(struct chunk *c, unsigned alignment); -struct chunk *_new_chunk(struct pool *p, size_t s); +struct chunk *_new_chunk(struct dm_pool *p, size_t s); /* by default things come out aligned for doubles */ #define DEFAULT_ALIGNMENT __alignof__ (double) -struct pool *pool_create(const char *name, size_t chunk_hint) +struct dm_pool *dm_pool_create(const char *name, size_t chunk_hint) { size_t new_size = 1024; - struct pool *p = dbg_malloc(sizeof(*p)); + struct dm_pool *p = dm_malloc(sizeof(*p)); if (!p) { log_error("Couldn't create memory pool %s (size %" @@ -55,26 +54,26 @@ struct pool *pool_create(const char *name, size_t chunk_hint) return p; } -void pool_destroy(struct pool *p) +void dm_pool_destroy(struct dm_pool *p) { struct chunk *c, *pr; - dbg_free(p->spare_chunk); + dm_free(p->spare_chunk); c = p->chunk; while (c) { pr = c->prev; - dbg_free(c); + dm_free(c); c = pr; } - dbg_free(p); + dm_free(p); } -void *pool_alloc(struct pool *p, size_t s) +void *dm_pool_alloc(struct dm_pool *p, size_t s) { - return pool_alloc_aligned(p, s, DEFAULT_ALIGNMENT); + return dm_pool_alloc_aligned(p, s, DEFAULT_ALIGNMENT); } -void *pool_alloc_aligned(struct pool *p, size_t s, unsigned alignment) +void *dm_pool_alloc_aligned(struct dm_pool *p, size_t s, unsigned alignment) { struct chunk *c = p->chunk; void *r; @@ -101,7 +100,7 @@ void *pool_alloc_aligned(struct pool *p, size_t s, unsigned alignment) return r; } -void pool_empty(struct pool *p) +void dm_pool_empty(struct dm_pool *p) { struct chunk *c; @@ -109,10 +108,10 @@ void pool_empty(struct pool *p) ; if (c) - pool_free(p, (char *) (c + 1)); + dm_pool_free(p, (char *) (c + 1)); } -void pool_free(struct pool *p, void *ptr) +void dm_pool_free(struct dm_pool *p, void *ptr) { struct chunk *c = p->chunk; @@ -124,7 +123,7 @@ void pool_free(struct pool *p, void *ptr) } if (p->spare_chunk) - dbg_free(p->spare_chunk); + dm_free(p->spare_chunk); p->spare_chunk = c; c = c->prev; } @@ -136,7 +135,7 @@ void pool_free(struct pool *p, void *ptr) p->chunk = c; } -int pool_begin_object(struct pool *p, size_t hint) +int dm_pool_begin_object(struct dm_pool *p, size_t hint) { struct chunk *c = p->chunk; const size_t align = DEFAULT_ALIGNMENT; @@ -163,7 +162,7 @@ int pool_begin_object(struct pool *p, size_t hint) return 1; } -int pool_grow_object(struct pool *p, const void *extra, size_t n) +int dm_pool_grow_object(struct dm_pool *p, const void *extra, size_t n) { struct chunk *c = p->chunk, *nc; @@ -187,7 +186,7 @@ int pool_grow_object(struct pool *p, const void *extra, size_t n) return 1; } -void *pool_end_object(struct pool *p) +void *dm_pool_end_object(struct dm_pool *p) { struct chunk *c = p->chunk; void *r = c->begin; @@ -197,7 +196,7 @@ void *pool_end_object(struct pool *p) return r; } -void pool_abandon_object(struct pool *p) +void dm_pool_abandon_object(struct dm_pool *p) { p->object_len = 0; p->object_alignment = DEFAULT_ALIGNMENT; @@ -208,7 +207,7 @@ void _align_chunk(struct chunk *c, unsigned alignment) c->begin += alignment - ((unsigned long) c->begin & (alignment - 1)); } -struct chunk *_new_chunk(struct pool *p, size_t s) +struct chunk *_new_chunk(struct dm_pool *p, size_t s) { struct chunk *c; @@ -218,7 +217,7 @@ struct chunk *_new_chunk(struct pool *p, size_t s) c = p->spare_chunk; p->spare_chunk = 0; } else { - if (!(c = dbg_malloc(s))) { + if (!(c = dm_malloc(s))) { log_error("Out of memory. Requested %" PRIsize_t " bytes.", s); return NULL; diff --git a/lib/mm/pool.c b/lib/mm/pool.c index daefcf8..f951804 100644 --- a/lib/mm/pool.c +++ b/lib/mm/pool.c @@ -19,9 +19,9 @@ #include "pool-fast.c" #endif -char *pool_strdup(struct pool *p, const char *str) +char *dm_pool_strdup(struct dm_pool *p, const char *str) { - char *ret = pool_alloc(p, strlen(str) + 1); + char *ret = dm_pool_alloc(p, strlen(str) + 1); if (ret) strcpy(ret, str); @@ -29,9 +29,9 @@ char *pool_strdup(struct pool *p, const char *str) return ret; } -char *pool_strndup(struct pool *p, const char *str, size_t n) +char *dm_pool_strndup(struct dm_pool *p, const char *str, size_t n) { - char *ret = pool_alloc(p, n + 1); + char *ret = dm_pool_alloc(p, n + 1); if (ret) { strncpy(ret, str, n); @@ -41,9 +41,9 @@ char *pool_strndup(struct pool *p, const char *str, size_t n) return ret; } -void *pool_zalloc(struct pool *p, size_t s) +void *dm_pool_zalloc(struct dm_pool *p, size_t s) { - void *ptr = pool_alloc(p, s); + void *ptr = dm_pool_alloc(p, s); if (ptr) memset(ptr, 0, s); -- 2.43.5