shaba/lvm2
1
0
Fork 0
mirror of git://sourceware.org/git/lvm2.git synced 2025-01-09 01:18:39 +03:00
Code Releases Activity

export bitset, pool, hash, malloc

Browse Source
This commit is contained in:
Alasdair Kergon 2005-10-16 22:57:20 +00:00
parent 1170dfac05
commit 251d138474
14 changed files with 465 additions and 224 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
WHATS_NEW_DM
View File

@ -1,6 +1,7 @@
Version 1.02.00 - Version 1.02.00 -
============================= =============================
Added dependency tree functions to library. Added dependency tree functions to library.
Added hash, bitset, pool, dbg_malloc to library.
Added ls --tree to dmsetup. Added ls --tree to dmsetup.
Added dmsetup --nolockfs support for suspend/reload. Added dmsetup --nolockfs support for suspend/reload.

40
libdm/.exported_symbols
View File

@ -41,3 +41,43 @@ dm_deptree_find_node
dm_deptree_next_child dm_deptree_next_child
dm_deptree_next_parent dm_deptree_next_parent
dm_is_dm_major 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

37
libdm/datastruct/bitset.c
View File

@ -14,21 +14,20 @@
*/ */
#include "lib.h" #include "lib.h"
#include "bitset.h"
/* FIXME: calculate this. */ /* FIXME: calculate this. */
#define INT_SHIFT 5 #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; size_t size = sizeof(int) * n;
bitset_t bs; dm_bitset_t bs;
if (mem) if (mem)
bs = pool_zalloc(mem, size); bs = dm_pool_zalloc(mem, size);
else else
bs = dbg_malloc(size); bs = dm_malloc(size);
if (!bs) if (!bs)
return NULL; return NULL;
@ -36,20 +35,20 @@ bitset_t bitset_create(struct pool *mem, unsigned num_bits)
*bs = num_bits; *bs = num_bits;
if (!mem) if (!mem)
bit_clear_all(bs); dm_bit_clear_all(bs);
return 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; 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]; 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) 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)) if (test & (0x1 << bit))
return bit; return bit;
bit++; bit++;
@ -67,7 +66,7 @@ static inline int _test_word(uint32_t test, int bit)
return -1; 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; int bit, word;
uint32_t test; uint32_t test;
@ -77,19 +76,19 @@ int bit_get_next(bitset_t bs, int last_bit)
while (last_bit < bs[0]) { while (last_bit < bs[0]) {
word = last_bit >> INT_SHIFT; word = last_bit >> INT_SHIFT;
test = bs[word + 1]; 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) 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)) + last_bit = last_bit - (last_bit & (DM_BITS_PER_INT - 1)) +
BITS_PER_INT; DM_BITS_PER_INT;
} }
return -1; 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);
} }

91
libdm/datastruct/hash.c
View File

@ -14,19 +14,18 @@
*/ */
#include "lib.h" #include "lib.h"
#include "hash.h"
struct hash_node { struct dm_hash_node {
struct hash_node *next; struct dm_hash_node *next;
void *data; void *data;
int keylen; int keylen;
char key[0]; char key[0];
}; };
struct hash_table { struct dm_hash_table {
int num_nodes; int num_nodes;
int num_slots; int num_slots;
struct hash_node **slots; struct dm_hash_node **slots;
}; };
/* Permutation of the Integers 0 through 255 */ /* Permutation of the Integers 0 through 255 */
@ -57,9 +56,9 @@ static unsigned char _nums[] = {
209 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) { if (n) {
memcpy(n->key, str, len); memcpy(n->key, str, len);
@ -86,11 +85,11 @@ static unsigned _hash(const char *str, uint32_t len)
return h; return h;
} }
struct hash_table *hash_create(unsigned size_hint) struct dm_hash_table *dm_hash_create(unsigned size_hint)
{ {
size_t len; size_t len;
unsigned new_size = 16u; unsigned new_size = 16u;
struct hash_table *hc = dbg_malloc(sizeof(*hc)); struct dm_hash_table *hc = dm_malloc(sizeof(*hc));
if (!hc) { if (!hc) {
stack; stack;
@ -105,7 +104,7 @@ struct hash_table *hash_create(unsigned size_hint)
hc->num_slots = new_size; hc->num_slots = new_size;
len = sizeof(*(hc->slots)) * new_size; len = sizeof(*(hc->slots)) * new_size;
if (!(hc->slots = dbg_malloc(len))) { if (!(hc->slots = dm_malloc(len))) {
stack; stack;
goto bad; goto bad;
} }
@ -113,35 +112,35 @@ struct hash_table *hash_create(unsigned size_hint)
return hc; return hc;
bad: bad:
dbg_free(hc->slots); dm_free(hc->slots);
dbg_free(hc); dm_free(hc);
return 0; 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; int i;
for (i = 0; i < t->num_slots; i++) for (i = 0; i < t->num_slots; i++)
for (c = t->slots[i]; c; c = n) { for (c = t->slots[i]; c; c = n) {
n = c->next; 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); _free_nodes(t);
dbg_free(t->slots); dm_free(t->slots);
dbg_free(t); 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) uint32_t len)
{ {
unsigned h = _hash(key, len) & (t->num_slots - 1); 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)) for (c = &t->slots[h]; *c; c = &((*c)->next))
if (!memcmp(key, (*c)->key, len)) 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; 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) 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; 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) uint32_t len, void *data)
{ {
struct hash_node **c = _find(t, key, len); struct dm_hash_node **c = _find(t, key, len);
if (*c) if (*c)
(*c)->data = data; (*c)->data = data;
else { else {
struct hash_node *n = _create_node(key, len); struct dm_hash_node *n = _create_node(key, len);
if (!n) if (!n)
return 0; return 0;
@ -179,42 +178,42 @@ int hash_insert_binary(struct hash_table *t, const char *key,
return 1; 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) uint32_t len)
{ {
struct hash_node **c = _find(t, key, len); struct dm_hash_node **c = _find(t, key, len);
if (*c) { if (*c) {
struct hash_node *old = *c; struct dm_hash_node *old = *c;
*c = (*c)->next; *c = (*c)->next;
dbg_free(old); dm_free(old);
t->num_nodes--; 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; 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; int i;
for (i = 0; i < t->num_slots; 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); f(c->data);
} }
void hash_wipe(struct hash_table *t) void dm_hash_wipe(struct dm_hash_table *t)
{ {
_free_nodes(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; 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; 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; 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; int i;
for (i = s; i < t->num_slots && !c; 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; 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); 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); unsigned h = _hash(n->key, n->keylen) & (t->num_slots - 1);
return n->next ? n->next : _next_slot(t, h + 1); return n->next ? n->next : _next_slot(t, h + 1);

69
libdm/ioctl/libdm-iface.c
View File

@ -17,7 +17,6 @@
#include "libdm-targets.h" #include "libdm-targets.h"
#include "libdm-common.h" #include "libdm-common.h"
#include "libdm-file.h" #include "libdm-file.h"
#include "bitset.h"
#ifdef DM_COMPAT #ifdef DM_COMPAT
# include "libdm-compat.h" # include "libdm-compat.h"
@ -63,7 +62,7 @@
static int _dm_version = DM_VERSION_MAJOR; static int _dm_version = DM_VERSION_MAJOR;
static int _log_suppress = 0; 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 _control_fd = -1;
static int _version_checked = 0; static int _version_checked = 0;
static int _version_ok = 1; static int _version_ok = 1;
@ -148,7 +147,7 @@ static int _get_proc_number(const char *file, const char *name,
fclose(fl); fclose(fl);
return 1; return 1;
} }
bit_set(_dm_bitset, num); dm_bit_set(_dm_bitset, num);
} }
} else do { } else do {
c = fgetc(fl); c = fgetc(fl);
@ -253,11 +252,11 @@ static int _create_dm_bitset(void)
if (_dm_bitset) if (_dm_bitset)
return 1; return 1;
if (!(_dm_bitset = bitset_create(NULL, NUMBER_OF_MAJORS))) if (!(_dm_bitset = dm_bitset_create(NULL, NUMBER_OF_MAJORS)))
return 0; return 0;
if (!_get_proc_number(PROC_DEVICES, DM_NAME, NULL)) { if (!_get_proc_number(PROC_DEVICES, DM_NAME, NULL)) {
bitset_destroy(_dm_bitset); dm_bitset_destroy(_dm_bitset);
_dm_bitset = NULL; _dm_bitset = NULL;
return 0; return 0;
} }
@ -273,7 +272,7 @@ int dm_is_dm_major(uint32_t major)
if (!_create_dm_bitset()) if (!_create_dm_bitset())
return 0; return 0;
return bit(_dm_bitset, major) ? 1 : 0; return dm_bit(_dm_bitset, major) ? 1 : 0;
} }
static int _open_control(void) static int _open_control(void)
@ -320,27 +319,27 @@ void dm_task_destroy(struct dm_task *dmt)
for (t = dmt->head; t; t = n) { for (t = dmt->head; t; t = n) {
n = t->next; n = t->next;
dbg_free(t->params); dm_free(t->params);
dbg_free(t->type); dm_free(t->type);
dbg_free(t); dm_free(t);
} }
if (dmt->dev_name) if (dmt->dev_name)
dbg_free(dmt->dev_name); dm_free(dmt->dev_name);
if (dmt->newname) if (dmt->newname)
dbg_free(dmt->newname); dm_free(dmt->newname);
if (dmt->message) if (dmt->message)
dbg_free(dmt->message); dm_free(dmt->message);
if (dmt->dmi.v4) if (dmt->dmi.v4)
dbg_free(dmt->dmi.v4); dm_free(dmt->dmi.v4);
if (dmt->uuid) 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) if (len < min_size)
len = min_size; len = min_size;
if (!(dmi = dbg_malloc(len))) if (!(dmi = dm_malloc(len)))
return NULL; return NULL;
memset(dmi, 0, len); memset(dmi, 0, len);
@ -570,7 +569,7 @@ static struct dm_ioctl_v1 *_flatten_v1(struct dm_task *dmt)
return dmi; return dmi;
bad: bad:
dbg_free(dmi); dm_free(dmi);
return NULL; return NULL;
} }
@ -721,7 +720,7 @@ static int _dm_task_run_v1(struct dm_task *dmt)
dmt->type = DM_DEVICE_INFO; dmt->type = DM_DEVICE_INFO;
if (!dm_task_run(dmt)) if (!dm_task_run(dmt))
goto bad; goto bad;
dbg_free(dmi); /* We'll use what info returned */ dm_free(dmi); /* We'll use what info returned */
return 1; return 1;
} }
@ -729,7 +728,7 @@ static int _dm_task_run_v1(struct dm_task *dmt)
return 1; return 1;
bad: bad:
dbg_free(dmi); dm_free(dmi);
return 0; 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) 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); log_error("dm_task_set_newname: strdup(%s) failed", newname);
return 0; 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) 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); log_error("dm_task_set_message: strdup(%s) failed", message);
return 0; 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, struct target *create_target(uint64_t start, uint64_t len, const char *type,
const char *params) const char *params)
{ {
struct target *t = dbg_malloc(sizeof(*t)); struct target *t = dm_malloc(sizeof(*t));
if (!t) { if (!t) {
log_error("create_target: malloc(%d) failed", sizeof(*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)); memset(t, 0, sizeof(*t));
if (!(t->params = dbg_strdup(params))) { if (!(t->params = dm_strdup(params))) {
log_error("create_target: strdup(params) failed"); log_error("create_target: strdup(params) failed");
goto bad; goto bad;
} }
if (!(t->type = dbg_strdup(type))) { if (!(t->type = dm_strdup(type))) {
log_error("create_target: strdup(type) failed"); log_error("create_target: strdup(type) failed");
goto bad; goto bad;
} }
@ -1042,9 +1041,9 @@ struct target *create_target(uint64_t start, uint64_t len, const char *type,
return t; return t;
bad: bad:
dbg_free(t->params); dm_free(t->params);
dbg_free(t->type); dm_free(t->type);
dbg_free(t); dm_free(t);
return NULL; return NULL;
} }
@ -1142,7 +1141,7 @@ static struct dm_ioctl *_flatten(struct dm_task *dmt, unsigned repeat_count)
while (repeat_count--) while (repeat_count--)
len *= 2; len *= 2;
if (!(dmi = dbg_malloc(len))) if (!(dmi = dm_malloc(len)))
return NULL; return NULL;
memset(dmi, 0, len); memset(dmi, 0, len);
@ -1200,7 +1199,7 @@ static struct dm_ioctl *_flatten(struct dm_task *dmt, unsigned repeat_count)
return dmi; return dmi;
bad: bad:
dbg_free(dmi); dm_free(dmi);
return NULL; 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 */ /* Use the original structure last so the info will be correct */
dmt->type = DM_DEVICE_RESUME; dmt->type = DM_DEVICE_RESUME;
dbg_free(dmt->uuid); dm_free(dmt->uuid);
dmt->uuid = NULL; dmt->uuid = NULL;
r = dm_task_run(dmt); 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 " log_error("device-mapper ioctl "
"cmd %d failed: %s", "cmd %d failed: %s",
_IOC_NR(command), strerror(errno)); _IOC_NR(command), strerror(errno));
dbg_free(dmi); dm_free(dmi);
return NULL; return NULL;
} }
} }
@ -1435,7 +1434,7 @@ repeat_ioctl:
case DM_DEVICE_TABLE: case DM_DEVICE_TABLE:
case DM_DEVICE_WAITEVENT: case DM_DEVICE_WAITEVENT:
_ioctl_buffer_double_factor++; _ioctl_buffer_double_factor++;
dbg_free(dmi); dm_free(dmi);
goto repeat_ioctl; goto repeat_ioctl;
default: default:
log_error("Warning: libdevmapper buffer too small for data"); log_error("Warning: libdevmapper buffer too small for data");
@ -1481,7 +1480,7 @@ repeat_ioctl:
return 1; return 1;
bad: bad:
dbg_free(dmi); dm_free(dmi);
return 0; return 0;
} }
@ -1498,9 +1497,9 @@ void dm_lib_exit(void)
{ {
dm_lib_release(); dm_lib_release();
if (_dm_bitset) if (_dm_bitset)
bitset_destroy(_dm_bitset); dm_bitset_destroy(_dm_bitset);
_dm_bitset = NULL; _dm_bitset = NULL;
dump_memory(); dm_dump_memory();
_version_ok = 1; _version_ok = 1;
_version_checked = 0; _version_checked = 0;
} }

211
libdm/libdevmapper.h
View File

@ -23,6 +23,10 @@
# include <linux/types.h> # include <linux/types.h>
#endif #endif
#include <limits.h>
#include <string.h>
#include <stdlib.h>
/* /*
* Since it is quite laborious to build the ioctl * Since it is quite laborious to build the ioctl
* arguments for the device-mapper people are * 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_release(void);
void dm_lib_exit(void) __attribute((destructor)); void dm_lib_exit(void) __attribute((destructor));
/***********************************************************************
* Wrappers
***********************************************************************/
/*
* Use NULL for all devices.
*/
int dm_mknodes(const char *name);
/***************************** /*****************************
* Dependency tree functions * * 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); 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 */ #endif /* LIB_DEVICE_MAPPER_H */

35
libdm/libdm-common.c
View File

@ -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 *dm_task_create(int type)
{ {
struct dm_task *dmt = dbg_malloc(sizeof(*dmt)); struct dm_task *dmt = dm_malloc(sizeof(*dmt));
if (!dmt) { if (!dmt) {
log_error("dm_task_create: malloc(%d) failed", sizeof(*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; struct stat st1, st2;
if (dmt->dev_name) { if (dmt->dev_name) {
dbg_free(dmt->dev_name); dm_free(dmt->dev_name);
dmt->dev_name = NULL; dmt->dev_name = NULL;
} }
@ -143,7 +143,7 @@ int dm_task_set_name(struct dm_task *dmt, const char *name)
name = pos + 1; 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); log_error("dm_task_set_name: strdup(%s) failed", name);
return 0; 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) int dm_task_set_uuid(struct dm_task *dmt, const char *uuid)
{ {
if (dmt->uuid) { if (dmt->uuid) {
dbg_free(dmt->uuid); dm_free(dmt->uuid);
dmt->uuid = NULL; 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); log_error("dm_task_set_uuid: strdup(%s) failed", uuid);
return 0; 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; size_t len = strlen(dev_name) + strlen(old_name) + 2;
char *pos; char *pos;
if (!(nop = dbg_malloc(sizeof(*nop) + len))) { if (!(nop = dm_malloc(sizeof(*nop) + len))) {
log_error("Insufficient memory to stack mknod operation"); log_error("Insufficient memory to stack mknod operation");
return 0; return 0;
} }
@ -412,7 +412,7 @@ static void _pop_node_ops(void)
_do_node_op(nop->type, nop->dev_name, nop->major, nop->minor, _do_node_op(nop->type, nop->dev_name, nop->major, nop->minor,
nop->uid, nop->gid, nop->mode, nop->old_name); nop->uid, nop->gid, nop->mode, nop->old_name);
list_del(&nop->list); list_del(&nop->list);
dbg_free(nop); dm_free(nop);
} }
} }
@ -448,3 +448,24 @@ const char *dm_dir(void)
{ {
return _dm_dir; 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;
}

40
libdm/libdm-deptree.c
View File

@ -17,8 +17,6 @@
#include "libdm-common.h" #include "libdm-common.h"
#include "list.h" #include "list.h"
#include "kdev_t.h" #include "kdev_t.h"
#include "pool.h"
#include "hash.h"
#include <stdarg.h> #include <stdarg.h>
#include <sys/param.h> #include <sys/param.h>
@ -37,8 +35,8 @@ struct deptree_node {
}; };
struct deptree { struct deptree {
struct pool *mem; struct dm_pool *mem;
struct hash_table *devs; struct dm_hash_table *devs;
struct deptree_node root; struct deptree_node root;
}; };
@ -51,7 +49,7 @@ struct deptree *dm_deptree_create(void)
{ {
struct deptree *deptree; struct deptree *deptree;
if (!(deptree = dbg_malloc(sizeof(*deptree)))) { if (!(deptree = dm_malloc(sizeof(*deptree)))) {
log_error("dm_deptree_create malloc failed"); log_error("dm_deptree_create malloc failed");
return NULL; return NULL;
} }
@ -61,16 +59,16 @@ struct deptree *dm_deptree_create(void)
list_init(&deptree->root.uses); list_init(&deptree->root.uses);
list_init(&deptree->root.used_by); 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"); log_error("deptree pool creation failed");
dbg_free(deptree); dm_free(deptree);
return NULL; return NULL;
} }
if (!(deptree->devs = hash_create(8))) { if (!(deptree->devs = dm_hash_create(8))) {
log_error("deptree hash creation failed"); log_error("deptree hash creation failed");
pool_destroy(deptree->mem); dm_pool_destroy(deptree->mem);
dbg_free(deptree); dm_free(deptree);
return NULL; return NULL;
} }
@ -82,9 +80,9 @@ void dm_deptree_free(struct deptree *deptree)
if (!deptree) if (!deptree)
return; return;
hash_destroy(deptree->devs); dm_hash_destroy(deptree->devs);
pool_destroy(deptree->mem); dm_pool_destroy(deptree->mem);
dbg_free(deptree); dm_free(deptree);
} }
static int _nodes_are_linked(struct deptree_node *parent, 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; 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"); log_error("deptree link allocation failed");
return 0; return 0;
} }
@ -171,7 +169,7 @@ static struct deptree_node *_create_deptree_node(struct deptree *deptree,
struct deptree_node *node; struct deptree_node *node;
uint64_t dev; 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"); log_error("_create_deptree_node alloc failed");
return NULL; return NULL;
} }
@ -187,10 +185,10 @@ static struct deptree_node *_create_deptree_node(struct deptree *deptree,
dev = MKDEV(info->major, info->minor); 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)) { sizeof(dev), node)) {
log_error("deptree node hash insertion failed"); log_error("deptree node hash insertion failed");
pool_free(deptree->mem, node); dm_pool_free(deptree->mem, node);
return NULL; return NULL;
} }
@ -202,11 +200,11 @@ static struct deptree_node *_find_deptree_node(struct deptree *deptree,
{ {
uint64_t dev = MKDEV(major, minor); 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)); 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, const char **name, const char **uuid,
struct dm_info *info, struct dm_deps **deps) 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); minor, info->minor);
goto failed; 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"); log_error("name pool_strdup failed");
goto 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"); log_error("uuid pool_strdup failed");
goto failed; goto failed;
} }

25
libdm/mm/dbg_malloc.c
View File

@ -14,14 +14,13 @@
*/ */
#include "lib.h" #include "lib.h"
#include "dbg_malloc.h"
#include <assert.h> #include <assert.h>
#include <stdarg.h> #include <stdarg.h>
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) if (ret)
strcpy(ret, str); strcpy(ret, str);
@ -52,7 +51,7 @@ static struct {
static struct memblock *_head = 0; static struct memblock *_head = 0;
static struct memblock *_tail = 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; struct memblock *nb;
size_t tsize = s + sizeof(*nb) + sizeof(unsigned long); 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; nb->line = line;
#ifdef BOUNDS_CHECK #ifdef BOUNDS_CHECK
bounds_check(); dm_bounds_check();
#endif #endif
/* setup fields */ /* setup fields */
@ -118,7 +117,7 @@ void *malloc_aux(size_t s, const char *file, int line)
return nb + 1; return nb + 1;
} }
void free_aux(void *p) void dm_free_aux(void *p)
{ {
char *ptr; char *ptr;
size_t i; size_t i;
@ -127,7 +126,7 @@ void free_aux(void *p)
return; return;
#ifdef BOUNDS_CHECK #ifdef BOUNDS_CHECK
bounds_check(); dm_bounds_check();
#endif #endif
/* sanity check */ /* sanity check */
@ -167,22 +166,22 @@ void free_aux(void *p)
free(mb); 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; void *r;
struct memblock *mb = ((struct memblock *) p) - 1; struct memblock *mb = ((struct memblock *) p) - 1;
r = malloc_aux(s, file, line); r = dm_malloc_aux(s, file, line);
if (p) { if (p) {
memcpy(r, p, mb->length); memcpy(r, p, mb->length);
free_aux(p); dm_free_aux(p);
} }
return r; return r;
} }
int dump_memory(void) int dm_dump_memory(void)
{ {
unsigned long tot = 0; unsigned long tot = 0;
struct memblock *mb; struct memblock *mb;
@ -217,7 +216,7 @@ int dump_memory(void)
return 1; return 1;
} }
void bounds_check(void) void dm_bounds_check(void)
{ {
struct memblock *mb = _head; struct memblock *mb = _head;
while (mb) { while (mb) {
@ -233,7 +232,7 @@ void bounds_check(void)
#else #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) { if (s > 50000000) {
log_error("Huge memory allocation (size %" PRIsize_t log_error("Huge memory allocation (size %" PRIsize_t

6
libdm/mm/dbg_malloc.h
View File

@ -20,7 +20,7 @@
#include <string.h> #include <string.h>
void *malloc_aux(size_t s, const char *file, int line); 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); 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); int dump_memory(void);
void bounds_check(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__) # define dbg_realloc(p, s) realloc_aux(p, s, __FILE__, __LINE__)
#else #else
# define dbg_free(p) free(p) # define dm_free(p) free(p)
# define dbg_realloc(p, s) realloc(p, s) # define dbg_realloc(p, s) realloc(p, s)
# define dump_memory() # define dump_memory()
# define bounds_check() # define bounds_check()

51
libdm/mm/pool-debug.c
View File

@ -14,7 +14,6 @@
*/ */
#include "lib.h" #include "lib.h"
#include "pool.h"
struct block { struct block {
struct block *next; struct block *next;
@ -29,7 +28,7 @@ typedef struct {
unsigned int bytes, maxbytes; unsigned int bytes, maxbytes;
} pool_stats; } pool_stats;
struct pool { struct dm_pool {
const char *name; const char *name;
int begun; int begun;
@ -44,9 +43,9 @@ struct pool {
/* by default things come out aligned for doubles */ /* by default things come out aligned for doubles */
#define DEFAULT_ALIGNMENT __alignof__ (double) #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) { if (!mem) {
log_error("Couldn't create memory pool %s (size %" 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; 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; struct block *n;
@ -81,13 +80,13 @@ static void _free_blocks(struct pool *p, struct block *b)
p->stats.blocks_allocated--; p->stats.blocks_allocated--;
n = b->next; n = b->next;
dbg_free(b->data); dm_free(b->data);
dbg_free(b); dm_free(b);
b = n; 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 #ifdef DEBUG_POOL
log_debug("%s mempool %s: %u/%u bytes, %u/%u blocks, " 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 #endif
} }
void pool_destroy(struct pool *p) void dm_pool_destroy(struct dm_pool *p)
{ {
_pool_stats(p, "Destroying"); _pool_stats(p, "Destroying");
_free_blocks(p, p->blocks); _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) { if (p->tail) {
p->tail->next = b; 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. */ /* FIXME: I'm currently ignoring the alignment arg. */
size_t len = sizeof(struct block) + s; 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 * 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; return NULL;
} }
if (!(b->data = dbg_malloc(s))) { if (!(b->data = dm_malloc(s))) {
log_err(_oom); log_err(_oom);
dbg_free(b); dm_free(b);
return NULL; return NULL;
} }
@ -161,7 +160,7 @@ static struct block *_new_block(size_t s, unsigned alignment)
return b; 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); 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; return b->data;
} }
void pool_empty(struct pool *p) void dm_pool_empty(struct dm_pool *p)
{ {
_pool_stats(p, "Emptying"); _pool_stats(p, "Emptying");
_free_blocks(p, p->blocks); _free_blocks(p, p->blocks);
p->blocks = p->tail = NULL; 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; struct block *b, *prev = NULL;
@ -210,14 +209,14 @@ void pool_free(struct pool *p, void *ptr)
_pool_stats(p, "Freeing (after)"); _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); assert(!p->begun);
p->begun = 1; p->begun = 1;
return 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; struct block *new;
size_t size = delta; size_t size = delta;
@ -234,8 +233,8 @@ int pool_grow_object(struct pool *p, const void *buffer, size_t delta)
if (p->object) { if (p->object) {
memcpy(new->data, p->object->data, p->object->size); memcpy(new->data, p->object->data, p->object->size);
dbg_free(p->object->data); dm_free(p->object->data);
dbg_free(p->object); dm_free(p->object);
} }
p->object = new; p->object = new;
@ -244,7 +243,7 @@ int pool_grow_object(struct pool *p, const void *buffer, size_t delta)
return 1; return 1;
} }
void *pool_end_object(struct pool *p) void *dm_pool_end_object(struct dm_pool *p)
{ {
assert(p->begun); assert(p->begun);
_append_block(p, p->object); _append_block(p, p->object);
@ -254,10 +253,10 @@ void *pool_end_object(struct pool *p)
return p->tail->data; return p->tail->data;
} }
void pool_abandon_object(struct pool *p) void dm_pool_abandon_object(struct dm_pool *p)
{ {
assert(p->begun); assert(p->begun);
dbg_free(p->object); dm_free(p->object);
p->begun = 0; p->begun = 0;
p->object = NULL; p->object = NULL;
} }

43
libdm/mm/pool-fast.c
View File

@ -14,14 +14,13 @@
*/ */
#include "lib.h" #include "lib.h"
#include "pool.h"
struct chunk { struct chunk {
char *begin, *end; char *begin, *end;
struct chunk *prev; struct chunk *prev;
}; };
struct pool { struct dm_pool {
struct chunk *chunk, *spare_chunk; /* spare_chunk is a one entry free struct chunk *chunk, *spare_chunk; /* spare_chunk is a one entry free
list to stop 'bobbling' */ list to stop 'bobbling' */
size_t chunk_size; size_t chunk_size;
@ -30,15 +29,15 @@ struct pool {
}; };
void _align_chunk(struct chunk *c, unsigned alignment); 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 */ /* by default things come out aligned for doubles */
#define DEFAULT_ALIGNMENT __alignof__ (double) #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; size_t new_size = 1024;
struct pool *p = dbg_malloc(sizeof(*p)); struct dm_pool *p = dm_malloc(sizeof(*p));
if (!p) { if (!p) {
log_error("Couldn't create memory pool %s (size %" 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; return p;
} }
void pool_destroy(struct pool *p) void dm_pool_destroy(struct dm_pool *p)
{ {
struct chunk *c, *pr; struct chunk *c, *pr;
dbg_free(p->spare_chunk); dm_free(p->spare_chunk);
c = p->chunk; c = p->chunk;
while (c) { while (c) {
pr = c->prev; pr = c->prev;
dbg_free(c); dm_free(c);
c = pr; 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; struct chunk *c = p->chunk;
void *r; void *r;
@ -101,7 +100,7 @@ void *pool_alloc_aligned(struct pool *p, size_t s, unsigned alignment)
return r; return r;
} }
void pool_empty(struct pool *p) void dm_pool_empty(struct dm_pool *p)
{ {
struct chunk *c; struct chunk *c;
@ -109,10 +108,10 @@ void pool_empty(struct pool *p)
; ;
if (c) 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; struct chunk *c = p->chunk;
@ -124,7 +123,7 @@ void pool_free(struct pool *p, void *ptr)
} }
if (p->spare_chunk) if (p->spare_chunk)
dbg_free(p->spare_chunk); dm_free(p->spare_chunk);
p->spare_chunk = c; p->spare_chunk = c;
c = c->prev; c = c->prev;
} }
@ -136,7 +135,7 @@ void pool_free(struct pool *p, void *ptr)
p->chunk = c; 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; struct chunk *c = p->chunk;
const size_t align = DEFAULT_ALIGNMENT; const size_t align = DEFAULT_ALIGNMENT;
@ -163,7 +162,7 @@ int pool_begin_object(struct pool *p, size_t hint)
return 1; 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; 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; return 1;
} }
void *pool_end_object(struct pool *p) void *dm_pool_end_object(struct dm_pool *p)
{ {
struct chunk *c = p->chunk; struct chunk *c = p->chunk;
void *r = c->begin; void *r = c->begin;
@ -197,7 +196,7 @@ void *pool_end_object(struct pool *p)
return r; return r;
} }
void pool_abandon_object(struct pool *p) void dm_pool_abandon_object(struct dm_pool *p)
{ {
p->object_len = 0; p->object_len = 0;
p->object_alignment = DEFAULT_ALIGNMENT; 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)); 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; struct chunk *c;
@ -218,7 +217,7 @@ struct chunk *_new_chunk(struct pool *p, size_t s)
c = p->spare_chunk; c = p->spare_chunk;
p->spare_chunk = 0; p->spare_chunk = 0;
} else { } else {
if (!(c = dbg_malloc(s))) { if (!(c = dm_malloc(s))) {
log_error("Out of memory. Requested %" PRIsize_t log_error("Out of memory. Requested %" PRIsize_t
" bytes.", s); " bytes.", s);
return NULL; return NULL;

12
libdm/mm/pool.c
View File

@ -19,9 +19,9 @@
#include "pool-fast.c" #include "pool-fast.c"
#endif #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) if (ret)
strcpy(ret, str); strcpy(ret, str);
@ -29,9 +29,9 @@ char *pool_strdup(struct pool *p, const char *str)
return ret; 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) { if (ret) {
strncpy(ret, str, n); strncpy(ret, str, n);
@ -41,9 +41,9 @@ char *pool_strndup(struct pool *p, const char *str, size_t n)
return ret; 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) if (ptr)
memset(ptr, 0, s); memset(ptr, 0, s);

28
tools/dmsetup.c
View File

@ -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); 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) 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) static int _exec_command(char *name)
@ -686,7 +662,7 @@ static int _exec_command(char *name)
if (argc < 0) if (argc < 0)
return 0; return 0;
if (!_mknodes_single(name)) if (!dm_mknodes(name))
return 0; return 0;
n = snprintf(path, sizeof(path), "%s/%s", dm_dir(), name); n = snprintf(path, sizeof(path), "%s/%s", dm_dir(), name);