shaba/lvm2
1
0
Fork 0
mirror of git://sourceware.org/git/lvm2.git synced 2024-12-21 13:34:40 +03:00
Code Releases Activity

Move the core of the lib/config/config.c functionality into libdevmapper,

Browse Source 
leaving behind the LVM-specific parts of the code (convenience wrappers that
handle `struct device` and `struct cmd_context`, basically). A number of
functions have been renamed (in addition to getting a dm_ prefix) -- namely,
all of the config interface now has a dm_config_ prefix.
This commit is contained in:
Petr Rockai 2011-08-30 14:55:15 +00:00
parent d35188058b
commit e59e2f7c3c
53 changed files with 1988 additions and 1858 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
lib/activate/activate.c
View File

@ -273,8 +273,8 @@ int activation(void)
static int _passes_activation_filter(struct cmd_context *cmd, static int _passes_activation_filter(struct cmd_context *cmd,
struct logical_volume *lv) struct logical_volume *lv)
{ {
const struct config_node *cn; const struct dm_config_node *cn;
const struct config_value *cv; const struct dm_config_value *cv;
const char *str; const char *str;
char path[PATH_MAX]; char path[PATH_MAX];
@ -304,7 +304,7 @@ static int _passes_activation_filter(struct cmd_context *cmd,
lv->vg->name, lv->name); lv->vg->name, lv->name);
for (cv = cn->v; cv; cv = cv->next) { for (cv = cn->v; cv; cv = cv->next) {
if (cv->type != CFG_STRING) { if (cv->type != DM_CFG_STRING) {
log_error("Ignoring invalid string in config file " log_error("Ignoring invalid string in config file "
"activation/volume_list"); "activation/volume_list");
continue; continue;

18
lib/activate/dev_manager.c
View File

@ -269,7 +269,7 @@ int dev_manager_info(struct dm_pool *mem, const struct logical_volume *lv,
char *dlid, *name; char *dlid, *name;
int r; int r;
if (!(name = build_dm_name(mem, lv->vg->name, lv->name, layer))) { if (!(name = dm_build_dm_name(mem, lv->vg->name, lv->name, layer))) {
log_error("name build failed for %s", lv->name); log_error("name build failed for %s", lv->name);
return 0; return 0;
} }
@ -723,7 +723,7 @@ int dev_manager_snapshot_percent(struct dev_manager *dm,
/* /*
* Build a name for the top layer. * Build a name for the top layer.
*/ */
if (!(name = build_dm_name(dm->mem, lv->vg->name, lv->name, NULL))) if (!(name = dm_build_dm_name(dm->mem, lv->vg->name, lv->name, NULL)))
return_0; return_0;
if (!(dlid = build_dm_uuid(dm->mem, lv->lvid.s, NULL))) if (!(dlid = build_dm_uuid(dm->mem, lv->lvid.s, NULL)))
@ -757,7 +757,7 @@ int dev_manager_mirror_percent(struct dev_manager *dm,
/* /*
* Build a name for the top layer. * Build a name for the top layer.
*/ */
if (!(name = build_dm_name(dm->mem, lv->vg->name, lv->name, layer))) if (!(name = dm_build_dm_name(dm->mem, lv->vg->name, lv->name, layer)))
return_0; return_0;
/* FIXME dm_pool_free ? */ /* FIXME dm_pool_free ? */
@ -800,7 +800,7 @@ int dev_manager_mirror_percent(struct dev_manager *dm,
/* Rename? */ /* Rename? */
if ((suffix = strrchr(dl->dlid + sizeof(UUID_PREFIX) - 1, '-'))) if ((suffix = strrchr(dl->dlid + sizeof(UUID_PREFIX) - 1, '-')))
suffix++; suffix++;
new_name = build_dm_name(dm->mem, dm->vg_name, dl->lv->name, new_name = dm_build_dm_name(dm->mem, dm->vg_name, dl->lv->name,
suffix); suffix);
static int _belong_to_vg(const char *vgname, const char *name) static int _belong_to_vg(const char *vgname, const char *name)
@ -843,7 +843,7 @@ static int _dev_manager_lv_mknodes(const struct logical_volume *lv)
{ {
char *name; char *name;
if (!(name = build_dm_name(lv->vg->cmd->mem, lv->vg->name, if (!(name = dm_build_dm_name(lv->vg->cmd->mem, lv->vg->name,
lv->name, NULL))) lv->name, NULL)))
return_0; return_0;
@ -861,7 +861,7 @@ int dev_manager_mknodes(const struct logical_volume *lv)
char *name; char *name;
int r = 0; int r = 0;
if (!(name = build_dm_name(lv->vg->cmd->mem, lv->vg->name, lv->name, NULL))) if (!(name = dm_build_dm_name(lv->vg->cmd->mem, lv->vg->name, lv->name, NULL)))
return_0; return_0;
if ((r = _info_run(name, NULL, &dminfo, NULL, 1, 0, 0, 0, 0))) { if ((r = _info_run(name, NULL, &dminfo, NULL, 1, 0, 0, 0, 0))) {
@ -933,7 +933,7 @@ static int _add_dev_to_dtree(struct dev_manager *dm, struct dm_tree *dtree,
char *dlid, *name; char *dlid, *name;
struct dm_info info, info2; struct dm_info info, info2;
if (!(name = build_dm_name(dm->mem, lv->vg->name, lv->name, layer))) if (!(name = dm_build_dm_name(dm->mem, lv->vg->name, lv->name, layer)))
return_0; return_0;
if (!(dlid = build_dm_uuid(dm->mem, lv->lvid.s, layer))) if (!(dlid = build_dm_uuid(dm->mem, lv->lvid.s, layer)))
@ -1163,7 +1163,7 @@ static char *_add_error_device(struct dev_manager *dm, struct dm_tree *dtree,
if (!(id = build_dm_uuid(dm->mem, seg->lv->lvid.s, errid))) if (!(id = build_dm_uuid(dm->mem, seg->lv->lvid.s, errid)))
return_NULL; return_NULL;
if (!(name = build_dm_name(dm->mem, seg->lv->vg->name, if (!(name = dm_build_dm_name(dm->mem, seg->lv->vg->name,
seg->lv->name, errid))) seg->lv->name, errid)))
return_NULL; return_NULL;
if (!(node = dm_tree_add_new_dev(dtree, name, id, 0, 0, 0, 0, 0))) if (!(node = dm_tree_add_new_dev(dtree, name, id, 0, 0, 0, 0, 0)))
@ -1558,7 +1558,7 @@ static int _add_new_lv_to_dtree(struct dev_manager *dm, struct dm_tree *dtree,
} }
} }
if (!(name = build_dm_name(dm->mem, lv->vg->name, lv->name, layer))) if (!(name = dm_build_dm_name(dm->mem, lv->vg->name, lv->name, layer)))
return_0; return_0;
if (!(dlid = build_dm_uuid(dm->mem, lv->lvid.s, layer))) if (!(dlid = build_dm_uuid(dm->mem, lv->lvid.s, layer)))

2
lib/cache/lvmcache.c vendored
View File

@ -677,7 +677,7 @@ struct volume_group *lvmcache_get_vg(const char *vgid, unsigned precommitted)
/* Build config tree from vgmetadata, if not yet cached */ /* Build config tree from vgmetadata, if not yet cached */
if (!vginfo->cft && if (!vginfo->cft &&
!(vginfo->cft = !(vginfo->cft =
create_config_tree_from_string(vginfo->vgmetadata))) dm_config_from_string(vginfo->vgmetadata)))
goto_bad; goto_bad;
if (!(vg = import_vg_from_config_tree(vginfo->cft, fid))) if (!(vg = import_vg_from_config_tree(vginfo->cft, fid)))

4
lib/cache/lvmcache.h vendored
View File

@ -33,7 +33,7 @@
struct cmd_context; struct cmd_context;
struct format_type; struct format_type;
struct volume_group; struct volume_group;
struct config_tree; struct dm_config_tree;
/* One per VG */ /* One per VG */
struct lvmcache_vginfo { struct lvmcache_vginfo {
@ -48,7 +48,7 @@ struct lvmcache_vginfo {
char *creation_host; char *creation_host;
size_t vgmetadata_size; size_t vgmetadata_size;
char *vgmetadata; /* Copy of VG metadata as format_text string */ char *vgmetadata; /* Copy of VG metadata as format_text string */
struct config_tree *cft; /* Config tree created from vgmetadata */ struct dm_config_tree *cft; /* Config tree created from vgmetadata */
/* Lifetime is directly tied to vgmetadata */ /* Lifetime is directly tied to vgmetadata */
struct volume_group *cached_vg; struct volume_group *cached_vg;
unsigned holders; unsigned holders;

56
lib/commands/toolcontext.c
View File

@ -222,8 +222,8 @@ static int _process_config(struct cmd_context *cmd)
mode_t old_umask; mode_t old_umask;
const char *read_ahead; const char *read_ahead;
struct stat st; struct stat st;
const struct config_node *cn; const struct dm_config_node *cn;
const struct config_value *cv; const struct dm_config_value *cv;
int64_t pv_min_kb; int64_t pv_min_kb;
/* umask */ /* umask */
@ -358,7 +358,7 @@ static int _process_config(struct cmd_context *cmd)
if ((cn = find_config_tree_node(cmd, "activation/mlock_filter"))) if ((cn = find_config_tree_node(cmd, "activation/mlock_filter")))
for (cv = cn->v; cv; cv = cv->next) for (cv = cn->v; cv; cv = cv->next)
if ((cv->type != CFG_STRING) || !cv->v.str[0]) if ((cv->type != DM_CFG_STRING) || !cv->v.str[0])
log_error("Ignoring invalid activation/mlock_filter entry in config file"); log_error("Ignoring invalid activation/mlock_filter entry in config file");
cmd->metadata_read_only = find_config_tree_int(cmd, "global/metadata_read_only", cmd->metadata_read_only = find_config_tree_int(cmd, "global/metadata_read_only",
@ -392,11 +392,11 @@ static int _set_tag(struct cmd_context *cmd, const char *tag)
return 1; return 1;
} }
static int _check_host_filters(struct cmd_context *cmd, const struct config_node *hn, static int _check_host_filters(struct cmd_context *cmd, const struct dm_config_node *hn,
int *passes) int *passes)
{ {
const struct config_node *cn; const struct dm_config_node *cn;
const struct config_value *cv; const struct dm_config_value *cv;
*passes = 1; *passes = 1;
@ -405,10 +405,10 @@ static int _check_host_filters(struct cmd_context *cmd, const struct config_node
continue; continue;
if (!strcmp(cn->key, "host_list")) { if (!strcmp(cn->key, "host_list")) {
*passes = 0; *passes = 0;
if (cn->v->type == CFG_EMPTY_ARRAY) if (cn->v->type == DM_CFG_EMPTY_ARRAY)
continue; continue;
for (cv = cn->v; cv; cv = cv->next) { for (cv = cn->v; cv; cv = cv->next) {
if (cv->type != CFG_STRING) { if (cv->type != DM_CFG_STRING) {
log_error("Invalid hostname string " log_error("Invalid hostname string "
"for tag %s", cn->key); "for tag %s", cn->key);
return 0; return 0;
@ -428,17 +428,17 @@ static int _check_host_filters(struct cmd_context *cmd, const struct config_node
return 1; return 1;
} }
static int _init_tags(struct cmd_context *cmd, struct config_tree *cft) static int _init_tags(struct cmd_context *cmd, struct dm_config_tree *cft)
{ {
const struct config_node *tn, *cn; const struct dm_config_node *tn, *cn;
const char *tag; const char *tag;
int passes; int passes;
if (!(tn = find_config_node(cft->root, "tags")) || !tn->child) if (!(tn = dm_config_find_node(cft->root, "tags")) || !tn->child)
return 1; return 1;
/* NB hosttags 0 when already 1 intentionally does not delete the tag */ /* NB hosttags 0 when already 1 intentionally does not delete the tag */
if (!cmd->hosttags && find_config_int(cft->root, "tags/hosttags", if (!cmd->hosttags && dm_config_find_int(cft->root, "tags/hosttags",
DEFAULT_HOSTTAGS)) { DEFAULT_HOSTTAGS)) {
/* FIXME Strip out invalid chars: only A-Za-z0-9_+.- */ /* FIXME Strip out invalid chars: only A-Za-z0-9_+.- */
if (!_set_tag(cmd, cmd->hostname)) if (!_set_tag(cmd, cmd->hostname))
@ -491,7 +491,7 @@ static int _load_config_file(struct cmd_context *cmd, const char *tag)
return 0; return 0;
} }
if (!(cfl->cft = create_config_tree(config_file, 0))) { if (!(cfl->cft = dm_config_create(config_file, 0))) {
log_error("config_tree allocation failed"); log_error("config_tree allocation failed");
return 0; return 0;
} }
@ -531,7 +531,7 @@ static int _init_lvm_conf(struct cmd_context *cmd)
{ {
/* No config file if LVM_SYSTEM_DIR is empty */ /* No config file if LVM_SYSTEM_DIR is empty */
if (!*cmd->system_dir) { if (!*cmd->system_dir) {
if (!(cmd->cft = create_config_tree(NULL, 0))) { if (!(cmd->cft = dm_config_create(NULL, 0))) {
log_error("Failed to create config tree"); log_error("Failed to create config tree");
return 0; return 0;
} }
@ -564,7 +564,7 @@ static int _merge_config_files(struct cmd_context *cmd)
/* Replace temporary duplicate copy of lvm.conf */ /* Replace temporary duplicate copy of lvm.conf */
if (cmd->cft->root) { if (cmd->cft->root) {
if (!(cmd->cft = create_config_tree(NULL, 0))) { if (!(cmd->cft = dm_config_create(NULL, 0))) {
log_error("Failed to create config tree"); log_error("Failed to create config tree");
return 0; return 0;
} }
@ -593,7 +593,7 @@ int config_files_changed(struct cmd_context *cmd)
struct config_tree_list *cfl; struct config_tree_list *cfl;
dm_list_iterate_items(cfl, &cmd->config_files) { dm_list_iterate_items(cfl, &cmd->config_files) {
if (config_file_changed(cfl->cft)) if (dm_config_changed(cfl->cft))
return 1; return 1;
} }
@ -620,8 +620,8 @@ static void _destroy_tag_configs(struct cmd_context *cmd)
static int _init_dev_cache(struct cmd_context *cmd) static int _init_dev_cache(struct cmd_context *cmd)
{ {
const struct config_node *cn; const struct dm_config_node *cn;
const struct config_value *cv; const struct dm_config_value *cv;
size_t uninitialized_var(udev_dir_len), len; size_t uninitialized_var(udev_dir_len), len;
int device_list_from_udev; int device_list_from_udev;
const char *uninitialized_var(udev_dir); const char *uninitialized_var(udev_dir);
@ -653,7 +653,7 @@ static int _init_dev_cache(struct cmd_context *cmd)
} }
for (cv = cn->v; cv; cv = cv->next) { for (cv = cn->v; cv; cv = cv->next) {
if (cv->type != CFG_STRING) { if (cv->type != DM_CFG_STRING) {
log_error("Invalid string in config file: " log_error("Invalid string in config file: "
"devices/scan"); "devices/scan");
return 0; return 0;
@ -680,7 +680,7 @@ static int _init_dev_cache(struct cmd_context *cmd)
return 1; return 1;
for (cv = cn->v; cv; cv = cv->next) { for (cv = cn->v; cv; cv = cv->next) {
if (cv->type != CFG_STRING) { if (cv->type != DM_CFG_STRING) {
log_error("Invalid string in config file: " log_error("Invalid string in config file: "
"devices/loopfiles"); "devices/loopfiles");
return 0; return 0;
@ -702,7 +702,7 @@ static int _init_dev_cache(struct cmd_context *cmd)
static struct dev_filter *_init_filter_components(struct cmd_context *cmd) static struct dev_filter *_init_filter_components(struct cmd_context *cmd)
{ {
unsigned nr_filt = 0; unsigned nr_filt = 0;
const struct config_node *cn; const struct dm_config_node *cn;
struct dev_filter *filters[MAX_FILTERS]; struct dev_filter *filters[MAX_FILTERS];
memset(filters, 0, sizeof(filters)); memset(filters, 0, sizeof(filters));
@ -823,7 +823,7 @@ static int _init_filters(struct cmd_context *cmd, unsigned load_persistent_cache
*/ */
if (load_persistent_cache && !cmd->is_long_lived && if (load_persistent_cache && !cmd->is_long_lived &&
!stat(dev_cache, &st) && !stat(dev_cache, &st) &&
(st.st_ctime > config_file_timestamp(cmd->cft)) && (st.st_ctime > dm_config_timestamp(cmd->cft)) &&
!persistent_filter_load(f4, NULL)) !persistent_filter_load(f4, NULL))
log_verbose("Failed to load existing device cache from %s", log_verbose("Failed to load existing device cache from %s",
dev_cache); dev_cache);
@ -853,7 +853,7 @@ static int _init_formats(struct cmd_context *cmd)
struct format_type *fmt; struct format_type *fmt;
#ifdef HAVE_LIBDL #ifdef HAVE_LIBDL
const struct config_node *cn; const struct dm_config_node *cn;
#endif #endif
label_init(); label_init();
@ -877,12 +877,12 @@ static int _init_formats(struct cmd_context *cmd)
if (!is_static() && if (!is_static() &&
(cn = find_config_tree_node(cmd, "global/format_libraries"))) { (cn = find_config_tree_node(cmd, "global/format_libraries"))) {
const struct config_value *cv; const struct dm_config_value *cv;
struct format_type *(*init_format_fn) (struct cmd_context *); struct format_type *(*init_format_fn) (struct cmd_context *);
void *lib; void *lib;
for (cv = cn->v; cv; cv = cv->next) { for (cv = cn->v; cv; cv = cv->next) {
if (cv->type != CFG_STRING) { if (cv->type != DM_CFG_STRING) {
log_error("Invalid string in config file: " log_error("Invalid string in config file: "
"global/format_libraries"); "global/format_libraries");
return 0; return 0;
@ -1010,7 +1010,7 @@ static int _init_segtypes(struct cmd_context *cmd)
}; };
#ifdef HAVE_LIBDL #ifdef HAVE_LIBDL
const struct config_node *cn; const struct dm_config_node *cn;
#endif #endif
for (i = 0; init_segtype_array[i]; i++) { for (i = 0; init_segtype_array[i]; i++) {
@ -1040,12 +1040,12 @@ static int _init_segtypes(struct cmd_context *cmd)
if (!is_static() && if (!is_static() &&
(cn = find_config_tree_node(cmd, "global/segment_libraries"))) { (cn = find_config_tree_node(cmd, "global/segment_libraries"))) {
const struct config_value *cv; const struct dm_config_value *cv;
int (*init_multiple_segtypes_fn) (struct cmd_context *, int (*init_multiple_segtypes_fn) (struct cmd_context *,
struct segtype_library *); struct segtype_library *);
for (cv = cn->v; cv; cv = cv->next) { for (cv = cn->v; cv; cv = cv->next) {
if (cv->type != CFG_STRING) { if (cv->type != DM_CFG_STRING) {
log_error("Invalid string in config file: " log_error("Invalid string in config file: "
"global/segment_libraries"); "global/segment_libraries");
return 0; return 0;

11
lib/commands/toolcontext.h
View File

@ -47,11 +47,16 @@ struct config_info {
char _padding[1]; char _padding[1];
}; };
struct config_tree; struct dm_config_tree;
struct archive_params; struct archive_params;
struct backup_params; struct backup_params;
struct arg_values; struct arg_values;
struct config_tree_list {
struct dm_list list;
struct dm_config_tree *cft;
};
/* FIXME Split into tool & library contexts */ /* FIXME Split into tool & library contexts */
/* command-instance-related variables needed by library */ /* command-instance-related variables needed by library */
struct cmd_context { struct cmd_context {
@ -87,8 +92,8 @@ struct cmd_context {
struct dm_list config_files; struct dm_list config_files;
int config_valid; int config_valid;
struct config_tree *cft; struct dm_config_tree *cft;
struct config_tree *cft_override; struct dm_config_tree *cft_override;
struct config_info default_settings; struct config_info default_settings;
struct config_info current_settings; struct config_info current_settings;

1255
lib/config/config.c
View File

File diff suppressed because it is too large Load Diff

90
lib/config/config.h
View File

@ -21,75 +21,25 @@
struct device; struct device;
struct cmd_context; struct cmd_context;
enum {
CFG_STRING,
CFG_FLOAT,
CFG_INT,
CFG_EMPTY_ARRAY
};
struct config_value {
int type;
union {
int64_t i;
float r;
const char *str;
} v;
struct config_value *next; /* for arrays */
};
struct config_node {
const char *key;
struct config_node *parent, *sib, *child;
struct config_value *v;
};
struct config_tree {
struct config_node *root;
};
struct config_tree_list {
struct dm_list list;
struct config_tree *cft;
};
struct config_tree *create_config_tree(const char *filename, int keep_open);
struct config_tree *create_config_tree_from_string(const char *config_settings);
int override_config_tree_from_string(struct cmd_context *cmd, int override_config_tree_from_string(struct cmd_context *cmd,
const char *config_settings); const char *config_settings);
void destroy_config_tree(struct config_tree *cft); void destroy_config_tree(struct dm_config_tree *cft);
typedef uint32_t (*checksum_fn_t) (uint32_t initial, const uint8_t *buf, uint32_t size); typedef uint32_t (*checksum_fn_t) (uint32_t initial, const uint8_t *buf, uint32_t size);
int read_config_fd(struct config_tree *cft, struct device *dev, int read_config_fd(struct dm_config_tree *cft, struct device *dev,
off_t offset, size_t size, off_t offset2, size_t size2, off_t offset, size_t size, off_t offset2, size_t size2,
checksum_fn_t checksum_fn, uint32_t checksum); checksum_fn_t checksum_fn, uint32_t checksum);
int read_config_file(struct config_tree *cft); int read_config_file(struct dm_config_tree *cft);
int write_config_file(struct config_tree *cft, const char *file,
int argc, char **argv);
typedef int (*putline_fn)(const char *line, void *baton); int merge_config_tree(struct cmd_context *cmd, struct dm_config_tree *cft,
int write_config_node(const struct config_node *cn, putline_fn putline, void *baton); struct dm_config_tree *newdata);
time_t config_file_timestamp(struct config_tree *cft);
int config_file_changed(struct config_tree *cft);
int merge_config_tree(struct cmd_context *cmd, struct config_tree *cft,
struct config_tree *newdata);
const struct config_node *find_config_node(const struct config_node *cn,
const char *path);
const char *find_config_str(const struct config_node *cn, const char *path,
const char *fail);
int find_config_int(const struct config_node *cn, const char *path, int fail);
float find_config_float(const struct config_node *cn, const char *path,
float fail);
/* /*
* These versions check an override tree, if present, first. * These versions check an override tree, if present, first.
*/ */
const struct config_node *find_config_tree_node(struct cmd_context *cmd, const struct dm_config_node *find_config_tree_node(struct cmd_context *cmd,
const char *path); const char *path);
const char *find_config_tree_str(struct cmd_context *cmd, const char *find_config_tree_str(struct cmd_context *cmd,
const char *path, const char *fail); const char *path, const char *fail);
@ -100,34 +50,6 @@ int64_t find_config_tree_int64(struct cmd_context *cmd, const char *path,
float find_config_tree_float(struct cmd_context *cmd, const char *path, float find_config_tree_float(struct cmd_context *cmd, const char *path,
float fail); float fail);
/*
* Understands (0, ~0), (y, n), (yes, no), (on,
* off), (true, false).
*/
int find_config_bool(const struct config_node *cn, const char *path, int fail);
int find_config_tree_bool(struct cmd_context *cmd, const char *path, int fail); int find_config_tree_bool(struct cmd_context *cmd, const char *path, int fail);
int get_config_uint32(const struct config_node *cn, const char *path,
uint32_t *result);
int get_config_uint64(const struct config_node *cn, const char *path,
uint64_t *result);
int get_config_str(const struct config_node *cn, const char *path,
const char **result);
unsigned maybe_config_section(const char *str, unsigned len);
const char *config_parent_name(const struct config_node *n);
struct config_node *clone_config_node_with_mem(struct dm_pool *mem,
const struct config_node *node,
int siblings);
struct config_node *create_config_node(struct config_tree *cft, const char *key);
struct config_value *create_config_value(struct config_tree *cft);
struct config_node *clone_config_node(struct config_tree *cft, const struct config_node *cn,
int siblings);
struct dm_pool *config_tree_memory(struct config_tree *cft);
#endif #endif

8
lib/device/dev-cache.c
View File

@ -644,8 +644,8 @@ void dev_cache_scan(int do_scan)
static int _init_preferred_names(struct cmd_context *cmd) static int _init_preferred_names(struct cmd_context *cmd)
{ {
const struct config_node *cn; const struct dm_config_node *cn;
const struct config_value *v; const struct dm_config_value *v;
struct dm_pool *scratch = NULL; struct dm_pool *scratch = NULL;
const char **regex; const char **regex;
unsigned count = 0; unsigned count = 0;
@ -654,14 +654,14 @@ static int _init_preferred_names(struct cmd_context *cmd)
_cache.preferred_names_matcher = NULL; _cache.preferred_names_matcher = NULL;
if (!(cn = find_config_tree_node(cmd, "devices/preferred_names")) || if (!(cn = find_config_tree_node(cmd, "devices/preferred_names")) ||
cn->v->type == CFG_EMPTY_ARRAY) { cn->v->type == DM_CFG_EMPTY_ARRAY) {
log_very_verbose("devices/preferred_names not found in config file: " log_very_verbose("devices/preferred_names not found in config file: "
"using built-in preferences"); "using built-in preferences");
return 1; return 1;
} }
for (v = cn->v; v; v = v->next) { for (v = cn->v; v; v = v->next) {
if (v->type != CFG_STRING) { if (v->type != DM_CFG_STRING) {
log_error("preferred_names patterns must be enclosed in quotes"); log_error("preferred_names patterns must be enclosed in quotes");
return 0; return 0;
} }

20
lib/filters/filter-persistent.c
View File

@ -64,13 +64,13 @@ int persistent_filter_wipe(struct dev_filter *f)
return 1; return 1;
} }
static int _read_array(struct pfilter *pf, struct config_tree *cft, static int _read_array(struct pfilter *pf, struct dm_config_tree *cft,
const char *path, void *data) const char *path, void *data)
{ {
const struct config_node *cn; const struct dm_config_node *cn;
const struct config_value *cv; const struct dm_config_value *cv;
if (!(cn = find_config_node(cft->root, path))) { if (!(cn = dm_config_find_node(cft->root, path))) {
log_very_verbose("Couldn't find %s array in '%s'", log_very_verbose("Couldn't find %s array in '%s'",
path, pf->file); path, pf->file);
return 0; return 0;
@ -81,7 +81,7 @@ static int _read_array(struct pfilter *pf, struct config_tree *cft,
* devices as we go. * devices as we go.
*/ */
for (cv = cn->v; cv; cv = cv->next) { for (cv = cn->v; cv; cv = cv->next) {
if (cv->type != CFG_STRING) { if (cv->type != DM_CFG_STRING) {
log_verbose("Devices array contains a value " log_verbose("Devices array contains a value "
"which is not a string ... ignoring"); "which is not a string ... ignoring");
continue; continue;
@ -96,10 +96,10 @@ static int _read_array(struct pfilter *pf, struct config_tree *cft,
return 1; return 1;
} }
int persistent_filter_load(struct dev_filter *f, struct config_tree **cft_out) int persistent_filter_load(struct dev_filter *f, struct dm_config_tree **cft_out)
{ {
struct pfilter *pf = (struct pfilter *) f->private; struct pfilter *pf = (struct pfilter *) f->private;
struct config_tree *cft; struct dm_config_tree *cft;
struct stat info; struct stat info;
int r = 0; int r = 0;
@ -122,7 +122,7 @@ int persistent_filter_load(struct dev_filter *f, struct config_tree **cft_out)
return_0; return_0;
} }
if (!(cft = create_config_tree(pf->file, 1))) if (!(cft = dm_config_create(pf->file, 1)))
return_0; return_0;
if (!read_config_file(cft)) if (!read_config_file(cft))
@ -173,7 +173,7 @@ static void _write_array(struct pfilter *pf, FILE *fp, const char *path,
first = 0; first = 0;
} }
escape_double_quotes(buf, dm_hash_get_key(pf->devices, n)); dm_escape_double_quotes(buf, dm_hash_get_key(pf->devices, n));
fprintf(fp, "\t\t\"%s\"", buf); fprintf(fp, "\t\t\"%s\"", buf);
} }
@ -186,7 +186,7 @@ int persistent_filter_dump(struct dev_filter *f, int merge_existing)
struct pfilter *pf; struct pfilter *pf;
char *tmp_file; char *tmp_file;
struct stat info, info2; struct stat info, info2;
struct config_tree *cft = NULL; struct dm_config_tree *cft = NULL;
FILE *fp; FILE *fp;
int lockfd; int lockfd;
int r = 0; int r = 0;

2
lib/filters/filter-persistent.h
View File

@ -22,7 +22,7 @@ struct dev_filter *persistent_filter_create(struct dev_filter *f,
const char *file); const char *file);
int persistent_filter_wipe(struct dev_filter *f); int persistent_filter_wipe(struct dev_filter *f);
int persistent_filter_load(struct dev_filter *f, struct config_tree **cft_out); int persistent_filter_load(struct dev_filter *f, struct dm_config_tree **cft_out);
int persistent_filter_dump(struct dev_filter *f, int merge_existing); int persistent_filter_dump(struct dev_filter *f, int merge_existing);
#endif #endif

8
lib/filters/filter-regex.c
View File

@ -87,10 +87,10 @@ static int _extract_pattern(struct dm_pool *mem, const char *pat,
return 1; return 1;
} }
static int _build_matcher(struct rfilter *rf, const struct config_value *val) static int _build_matcher(struct rfilter *rf, const struct dm_config_value *val)
{ {
struct dm_pool *scratch; struct dm_pool *scratch;
const struct config_value *v; const struct dm_config_value *v;
char **regex; char **regex;
unsigned count = 0; unsigned count = 0;
int i, r = 0; int i, r = 0;
@ -102,7 +102,7 @@ static int _build_matcher(struct rfilter *rf, const struct config_value *val)
* count how many patterns we have. * count how many patterns we have.
*/ */
for (v = val; v; v = v->next) { for (v = val; v; v = v->next) {
if (v->type != CFG_STRING) { if (v->type != DM_CFG_STRING) {
log_error("Filter patterns must be enclosed in quotes."); log_error("Filter patterns must be enclosed in quotes.");
goto out; goto out;
} }
@ -188,7 +188,7 @@ static void _regex_destroy(struct dev_filter *f)
dm_pool_destroy(rf->mem); dm_pool_destroy(rf->mem);
} }
struct dev_filter *regex_filter_create(const struct config_value *patterns) struct dev_filter *regex_filter_create(const struct dm_config_value *patterns)
{ {
struct dm_pool *mem = dm_pool_create("filter regex", 10 * 1024); struct dm_pool *mem = dm_pool_create("filter regex", 10 * 1024);
struct rfilter *rf; struct rfilter *rf;

2
lib/filters/filter-regex.h
View File

@ -27,6 +27,6 @@
* r|.*| - reject everything else * r|.*| - reject everything else
*/ */
struct dev_filter *regex_filter_create(const struct config_value *patterns); struct dev_filter *regex_filter_create(const struct dm_config_value *patterns);
#endif #endif

10
lib/filters/filter.c
View File

@ -177,7 +177,7 @@ static int _passes_lvm_type_device_filter(struct dev_filter *f __attribute__((un
return ret; return ret;
} }
static int _scan_proc_dev(const char *proc, const struct config_node *cn) static int _scan_proc_dev(const char *proc, const struct dm_config_node *cn)
{ {
char line[80]; char line[80];
char proc_devices[PATH_MAX]; char proc_devices[PATH_MAX];
@ -186,7 +186,7 @@ static int _scan_proc_dev(const char *proc, const struct config_node *cn)
int line_maj = 0; int line_maj = 0;
int blocksection = 0; int blocksection = 0;
size_t dev_len = 0; size_t dev_len = 0;
const struct config_value *cv; const struct dm_config_value *cv;
const char *name; const char *name;
@ -269,7 +269,7 @@ static int _scan_proc_dev(const char *proc, const struct config_node *cn)
/* Check devices/types for local variations */ /* Check devices/types for local variations */
for (cv = cn->v; cv; cv = cv->next) { for (cv = cn->v; cv; cv = cv->next) {
if (cv->type != CFG_STRING) { if (cv->type != DM_CFG_STRING) {
log_error("Expecting string in devices/types " log_error("Expecting string in devices/types "
"in config file"); "in config file");
if (fclose(pd)) if (fclose(pd))
@ -279,7 +279,7 @@ static int _scan_proc_dev(const char *proc, const struct config_node *cn)
dev_len = strlen(cv->v.str); dev_len = strlen(cv->v.str);
name = cv->v.str; name = cv->v.str;
cv = cv->next; cv = cv->next;
if (!cv || cv->type != CFG_INT) { if (!cv || cv->type != DM_CFG_INT) {
log_error("Max partition count missing for %s " log_error("Max partition count missing for %s "
"in devices/types in config file", "in devices/types in config file",
name); name);
@ -316,7 +316,7 @@ int max_partitions(int major)
} }
struct dev_filter *lvm_type_filter_create(const char *proc, struct dev_filter *lvm_type_filter_create(const char *proc,
const struct config_node *cn) const struct dm_config_node *cn)
{ {
struct dev_filter *f; struct dev_filter *f;

2
lib/filters/filter.h
View File

@ -31,7 +31,7 @@
#endif #endif
struct dev_filter *lvm_type_filter_create(const char *proc, struct dev_filter *lvm_type_filter_create(const char *proc,
const struct config_node *cn); const struct dm_config_node *cn);
void lvm_type_filter_destroy(struct dev_filter *f); void lvm_type_filter_destroy(struct dev_filter *f);

12
lib/format_text/export.c
View File

@ -319,9 +319,9 @@ static int _out_line(const char *line, void *_f) {
return out_text(f, "%s", line); return out_text(f, "%s", line);
} }
int out_config_node(struct formatter *f, const struct config_node *cn) int out_config_node(struct formatter *f, const struct dm_config_node *cn)
{ {
return write_config_node(cn, _out_line, f); return dm_config_write_node(cn, _out_line, f);
} }
static int _print_header(struct formatter *f, static int _print_header(struct formatter *f,
@ -337,12 +337,12 @@ static int _print_header(struct formatter *f,
outf(f, FORMAT_VERSION_FIELD " = %d", FORMAT_VERSION_VALUE); outf(f, FORMAT_VERSION_FIELD " = %d", FORMAT_VERSION_VALUE);
outnl(f); outnl(f);
if (!(buf = alloca(escaped_len(desc)))) { if (!(buf = alloca(dm_escaped_len(desc)))) {
log_error("temporary stack allocation for description" log_error("temporary stack allocation for description"
"string failed"); "string failed");
return 0; return 0;
} }
outf(f, "description = \"%s\"", escape_double_quotes(buf, desc)); outf(f, "description = \"%s\"", dm_escape_double_quotes(buf, desc));
outnl(f); outnl(f);
outf(f, "creation_host = \"%s\"\t# %s %s %s %s %s", _utsname.nodename, outf(f, "creation_host = \"%s\"\t# %s %s %s %s %s", _utsname.nodename,
_utsname.sysname, _utsname.nodename, _utsname.release, _utsname.sysname, _utsname.nodename, _utsname.release,
@ -465,14 +465,14 @@ static int _print_pvs(struct formatter *f, struct volume_group *vg)
outf(f, "id = \"%s\"", buffer); outf(f, "id = \"%s\"", buffer);
if (!(buf = alloca(escaped_len(pv_dev_name(pv))))) { if (!(buf = alloca(dm_escaped_len(pv_dev_name(pv))))) {
log_error("temporary stack allocation for device name" log_error("temporary stack allocation for device name"
"string failed"); "string failed");
return 0; return 0;
} }
outhint(f, "device = \"%s\"", outhint(f, "device = \"%s\"",
escape_double_quotes(buf, pv_dev_name(pv))); dm_escape_double_quotes(buf, pv_dev_name(pv)));
outnl(f); outnl(f);
if (!_print_flag_config(f, pv->status, PV_FLAGS)) if (!_print_flag_config(f, pv->status, PV_FLAGS))

6
lib/format_text/flags.c
View File

@ -140,7 +140,7 @@ int print_flags(uint64_t status, int type, char *buffer, size_t size)
return 1; return 1;
} }
int read_flags(uint64_t *status, int type, const struct config_value *cv) int read_flags(uint64_t *status, int type, const struct dm_config_value *cv)
{ {
int f; int f;
uint64_t s = UINT64_C(0); uint64_t s = UINT64_C(0);
@ -149,11 +149,11 @@ int read_flags(uint64_t *status, int type, const struct config_value *cv)
if (!(flags = _get_flags(type))) if (!(flags = _get_flags(type)))
return_0; return_0;
if (cv->type == CFG_EMPTY_ARRAY) if (cv->type == DM_CFG_EMPTY_ARRAY)
goto out; goto out;
while (cv) { while (cv) {
if (cv->type != CFG_STRING) { if (cv->type != DM_CFG_STRING) {
log_error("Status value is not a string."); log_error("Status value is not a string.");
return 0; return 0;
} }

18
lib/format_text/format-text.c
View File

@ -223,7 +223,7 @@ static int _pv_analyze_mda_raw (const struct format_type * fmt,
* area->start to area->start+area->size is not used. * area->start to area->start+area->size is not used.
* Only ~32KB seems to contain valid metadata records * Only ~32KB seems to contain valid metadata records
* (LVM2 format - format_text). As a result, I end up with * (LVM2 format - format_text). As a result, I end up with
* "maybe_config_section" returning true when there's no valid * "dm_config_maybe_section" returning true when there's no valid
* metadata in a sector (sectors with all nulls). * metadata in a sector (sectors with all nulls).
*/ */
if (!(buf = dm_malloc(size + size2))) if (!(buf = dm_malloc(size + size2)))
@ -236,7 +236,7 @@ static int _pv_analyze_mda_raw (const struct format_type * fmt,
/* /*
* FIXME: We could add more sophisticated metadata detection * FIXME: We could add more sophisticated metadata detection
*/ */
if (maybe_config_section(buf, size + size2)) { if (dm_config_maybe_section(buf, size + size2)) {
/* FIXME: Validate region, pull out timestamp?, etc */ /* FIXME: Validate region, pull out timestamp?, etc */
/* FIXME: Do something with this region */ /* FIXME: Do something with this region */
log_verbose ("Found LVM2 metadata record at " log_verbose ("Found LVM2 metadata record at "
@ -2277,7 +2277,7 @@ static int _add_dir(const char *dir, struct dm_list *dir_list)
} }
static int _get_config_disk_area(struct cmd_context *cmd, static int _get_config_disk_area(struct cmd_context *cmd,
const struct config_node *cn, struct dm_list *raw_list) const struct dm_config_node *cn, struct dm_list *raw_list)
{ {
struct device_area dev_area; struct device_area dev_area;
const char *id_str; const char *id_str;
@ -2288,21 +2288,21 @@ static int _get_config_disk_area(struct cmd_context *cmd,
return 0; return 0;
} }
if (!get_config_uint64(cn, "start_sector", &dev_area.start)) { if (!dm_config_get_uint64(cn, "start_sector", &dev_area.start)) {
log_error("Missing start_sector in metadata disk_area section " log_error("Missing start_sector in metadata disk_area section "
"of config file"); "of config file");
return 0; return 0;
} }
dev_area.start <<= SECTOR_SHIFT; dev_area.start <<= SECTOR_SHIFT;
if (!get_config_uint64(cn, "size", &dev_area.size)) { if (!dm_config_get_uint64(cn, "size", &dev_area.size)) {
log_error("Missing size in metadata disk_area section " log_error("Missing size in metadata disk_area section "
"of config file"); "of config file");
return 0; return 0;
} }
dev_area.size <<= SECTOR_SHIFT; dev_area.size <<= SECTOR_SHIFT;
if (!get_config_str(cn, "id", &id_str)) { if (!dm_config_get_str(cn, "id", &id_str)) {
log_error("Missing uuid in metadata disk_area section " log_error("Missing uuid in metadata disk_area section "
"of config file"); "of config file");
return 0; return 0;
@ -2332,8 +2332,8 @@ static int _get_config_disk_area(struct cmd_context *cmd,
struct format_type *create_text_format(struct cmd_context *cmd) struct format_type *create_text_format(struct cmd_context *cmd)
{ {
struct format_type *fmt; struct format_type *fmt;
const struct config_node *cn; const struct dm_config_node *cn;
const struct config_value *cv; const struct dm_config_value *cv;
struct mda_lists *mda_lists; struct mda_lists *mda_lists;
if (!(fmt = dm_malloc(sizeof(*fmt)))) if (!(fmt = dm_malloc(sizeof(*fmt))))
@ -2374,7 +2374,7 @@ struct format_type *create_text_format(struct cmd_context *cmd)
if ((cn = find_config_tree_node(cmd, "metadata/dirs"))) { if ((cn = find_config_tree_node(cmd, "metadata/dirs"))) {
for (cv = cn->v; cv; cv = cv->next) { for (cv = cn->v; cv; cv = cv->next) {
if (cv->type != CFG_STRING) { if (cv->type != DM_CFG_STRING) {
log_error("Invalid string in config file: " log_error("Invalid string in config file: "
"metadata/dirs"); "metadata/dirs");
goto err; goto err;

12
lib/format_text/import-export.h
View File

@ -44,14 +44,14 @@ enum {
}; };
struct text_vg_version_ops { struct text_vg_version_ops {
int (*check_version) (const struct config_tree * cf); int (*check_version) (const struct dm_config_tree * cf);
struct volume_group *(*read_vg) (struct format_instance * fid, struct volume_group *(*read_vg) (struct format_instance * fid,
const struct config_tree *cf, const struct dm_config_tree *cf,
unsigned use_cached_pvs); unsigned use_cached_pvs);
void (*read_desc) (struct dm_pool * mem, const struct config_tree *cf, void (*read_desc) (struct dm_pool * mem, const struct dm_config_tree *cf,
time_t *when, char **desc); time_t *when, char **desc);
const char *(*read_vgname) (const struct format_type *fmt, const char *(*read_vgname) (const struct format_type *fmt,
const struct config_tree *cft, const struct dm_config_tree *cft,
struct id *vgid, uint64_t *vgstatus, struct id *vgid, uint64_t *vgstatus,
char **creation_host); char **creation_host);
}; };
@ -59,10 +59,10 @@ struct text_vg_version_ops {
struct text_vg_version_ops *text_vg_vsn1_init(void); struct text_vg_version_ops *text_vg_vsn1_init(void);
int print_flags(uint64_t status, int type, char *buffer, size_t size); int print_flags(uint64_t status, int type, char *buffer, size_t size);
int read_flags(uint64_t *status, int type, const struct config_value *cv); int read_flags(uint64_t *status, int type, const struct dm_config_value *cv);
char *alloc_printed_tags(struct dm_list *tags); char *alloc_printed_tags(struct dm_list *tags);
int read_tags(struct dm_pool *mem, struct dm_list *tags, const struct config_value *cv); int read_tags(struct dm_pool *mem, struct dm_list *tags, const struct dm_config_value *cv);
int text_vg_export_file(struct volume_group *vg, const char *desc, FILE *fp); int text_vg_export_file(struct volume_group *vg, const char *desc, FILE *fp);
int text_vg_export_raw(struct volume_group *vg, const char *desc, char **buf); int text_vg_export_raw(struct volume_group *vg, const char *desc, char **buf);

10
lib/format_text/import.c
View File

@ -43,13 +43,13 @@ const char *text_vgname_import(const struct format_type *fmt,
struct id *vgid, uint64_t *vgstatus, struct id *vgid, uint64_t *vgstatus,
char **creation_host) char **creation_host)
{ {
struct config_tree *cft; struct dm_config_tree *cft;
struct text_vg_version_ops **vsn; struct text_vg_version_ops **vsn;
const char *vgname = NULL; const char *vgname = NULL;
_init_text_import(); _init_text_import();
if (!(cft = create_config_tree(NULL, 0))) if (!(cft = dm_config_create(NULL, 0)))
return_NULL; return_NULL;
if ((!dev && !read_config_file(cft)) || if ((!dev && !read_config_file(cft)) ||
@ -86,7 +86,7 @@ struct volume_group *text_vg_import_fd(struct format_instance *fid,
time_t *when, char **desc) time_t *when, char **desc)
{ {
struct volume_group *vg = NULL; struct volume_group *vg = NULL;
struct config_tree *cft; struct dm_config_tree *cft;
struct text_vg_version_ops **vsn; struct text_vg_version_ops **vsn;
_init_text_import(); _init_text_import();
@ -94,7 +94,7 @@ struct volume_group *text_vg_import_fd(struct format_instance *fid,
*desc = NULL; *desc = NULL;
*when = 0; *when = 0;
if (!(cft = create_config_tree(file, 0))) if (!(cft = dm_config_create(file, 0)))
return_NULL; return_NULL;
if ((!dev && !read_config_file(cft)) || if ((!dev && !read_config_file(cft)) ||
@ -131,7 +131,7 @@ struct volume_group *text_vg_import_file(struct format_instance *fid,
when, desc); when, desc);
} }
struct volume_group *import_vg_from_config_tree(const struct config_tree *cft, struct volume_group *import_vg_from_config_tree(const struct dm_config_tree *cft,
struct format_instance *fid) struct format_instance *fid)
{ {
struct volume_group *vg = NULL; struct volume_group *vg = NULL;

118
lib/format_text/import_vsn1.c
View File

@ -26,21 +26,21 @@
#include "defaults.h" #include "defaults.h"
typedef int (*section_fn) (struct format_instance * fid, struct dm_pool * mem, typedef int (*section_fn) (struct format_instance * fid, struct dm_pool * mem,
struct volume_group * vg, const struct config_node * pvn, struct volume_group * vg, const struct dm_config_node * pvn,
const struct config_node * vgn, const struct dm_config_node * vgn,
struct dm_hash_table * pv_hash, struct dm_hash_table * pv_hash,
struct dm_hash_table * lv_hash, struct dm_hash_table * lv_hash,
unsigned *scan_done_once, unsigned *scan_done_once,
unsigned report_missing_devices); unsigned report_missing_devices);
#define _read_int32(root, path, result) \ #define _read_int32(root, path, result) \
get_config_uint32(root, path, (uint32_t *) result) dm_config_get_uint32(root, path, (uint32_t *) result)
#define _read_uint32(root, path, result) \ #define _read_uint32(root, path, result) \
get_config_uint32(root, path, result) dm_config_get_uint32(root, path, result)
#define _read_int64(root, path, result) \ #define _read_int64(root, path, result) \
get_config_uint64(root, path, result) dm_config_get_uint64(root, path, result)
/* /*
* Logs an attempt to read an invalid format file. * Logs an attempt to read an invalid format file.
@ -54,21 +54,21 @@ static void _invalid_format(const char *str)
* Checks that the config file contains vg metadata, and that it * Checks that the config file contains vg metadata, and that it
* we recognise the version number, * we recognise the version number,
*/ */
static int _vsn1_check_version(const struct config_tree *cft) static int _vsn1_check_version(const struct dm_config_tree *cft)
{ {
const struct config_node *cn; const struct dm_config_node *cn;
const struct config_value *cv; const struct dm_config_value *cv;
/* /*
* Check the contents field. * Check the contents field.
*/ */
if (!(cn = find_config_node(cft->root, CONTENTS_FIELD))) { if (!(cn = dm_config_find_node(cft->root, CONTENTS_FIELD))) {
_invalid_format("missing contents field"); _invalid_format("missing contents field");
return 0; return 0;
} }
cv = cn->v; cv = cn->v;
if (!cv || cv->type != CFG_STRING || strcmp(cv->v.str, CONTENTS_VALUE)) { if (!cv || cv->type != DM_CFG_STRING || strcmp(cv->v.str, CONTENTS_VALUE)) {
_invalid_format("unrecognised contents field"); _invalid_format("unrecognised contents field");
return 0; return 0;
} }
@ -76,13 +76,13 @@ static int _vsn1_check_version(const struct config_tree *cft)
/* /*
* Check the version number. * Check the version number.
*/ */
if (!(cn = find_config_node(cft->root, FORMAT_VERSION_FIELD))) { if (!(cn = dm_config_find_node(cft->root, FORMAT_VERSION_FIELD))) {
_invalid_format("missing version number"); _invalid_format("missing version number");
return 0; return 0;
} }
cv = cn->v; cv = cn->v;
if (!cv || cv->type != CFG_INT || cv->v.i != FORMAT_VERSION_VALUE) { if (!cv || cv->type != DM_CFG_INT || cv->v.i != FORMAT_VERSION_VALUE) {
_invalid_format("unrecognised version number"); _invalid_format("unrecognised version number");
return 0; return 0;
} }
@ -106,11 +106,11 @@ static int _is_converting(struct logical_volume *lv)
return 0; return 0;
} }
static int _read_id(struct id *id, const struct config_node *cn, const char *path) static int _read_id(struct id *id, const struct dm_config_node *cn, const char *path)
{ {
const struct config_value *cv; const struct dm_config_value *cv;
if (!(cn = find_config_node(cn, path))) { if (!(cn = dm_config_find_node(cn, path))) {
log_error("Couldn't find uuid."); log_error("Couldn't find uuid.");
return 0; return 0;
} }
@ -129,12 +129,12 @@ static int _read_id(struct id *id, const struct config_node *cn, const char *pat
return 1; return 1;
} }
static int _read_flag_config(const struct config_node *n, uint64_t *status, int type) static int _read_flag_config(const struct dm_config_node *n, uint64_t *status, int type)
{ {
const struct config_node *cn; const struct dm_config_node *cn;
*status = 0; *status = 0;
if (!(cn = find_config_node(n, "status"))) { if (!(cn = dm_config_find_node(n, "status"))) {
log_error("Could not find status flags."); log_error("Could not find status flags.");
return 0; return 0;
} }
@ -144,7 +144,7 @@ static int _read_flag_config(const struct config_node *n, uint64_t *status, int
return 0; return 0;
} }
if ((cn = find_config_node(n, "flags"))) { if ((cn = dm_config_find_node(n, "flags"))) {
if (!(read_flags(status, type, cn->v))) { if (!(read_flags(status, type, cn->v))) {
log_error("Could not read flags."); log_error("Could not read flags.");
return 0; return 0;
@ -155,8 +155,8 @@ static int _read_flag_config(const struct config_node *n, uint64_t *status, int
} }
static int _read_pv(struct format_instance *fid, struct dm_pool *mem, static int _read_pv(struct format_instance *fid, struct dm_pool *mem,
struct volume_group *vg, const struct config_node *pvn, struct volume_group *vg, const struct dm_config_node *pvn,
const struct config_node *vgn __attribute__((unused)), const struct dm_config_node *vgn __attribute__((unused)),
struct dm_hash_table *pv_hash, struct dm_hash_table *pv_hash,
struct dm_hash_table *lv_hash __attribute__((unused)), struct dm_hash_table *lv_hash __attribute__((unused)),
unsigned *scan_done_once, unsigned *scan_done_once,
@ -164,7 +164,7 @@ static int _read_pv(struct format_instance *fid, struct dm_pool *mem,
{ {
struct physical_volume *pv; struct physical_volume *pv;
struct pv_list *pvl; struct pv_list *pvl;
const struct config_node *cn; const struct dm_config_node *cn;
uint64_t size; uint64_t size;
if (!(pvl = dm_pool_zalloc(mem, sizeof(*pvl))) || if (!(pvl = dm_pool_zalloc(mem, sizeof(*pvl))) ||
@ -238,7 +238,7 @@ static int _read_pv(struct format_instance *fid, struct dm_pool *mem,
dm_list_init(&pv->segments); dm_list_init(&pv->segments);
/* Optional tags */ /* Optional tags */
if ((cn = find_config_node(pvn, "tags")) && if ((cn = dm_config_find_node(pvn, "tags")) &&
!(read_tags(mem, &pv->tags, cn->v))) { !(read_tags(mem, &pv->tags, cn->v))) {
log_error("Couldn't read tags for physical volume %s in %s.", log_error("Couldn't read tags for physical volume %s in %s.",
pv_dev_name(pv), vg->name); pv_dev_name(pv), vg->name);
@ -292,13 +292,13 @@ static void _insert_segment(struct logical_volume *lv, struct lv_segment *seg)
} }
static int _read_segment(struct dm_pool *mem, struct volume_group *vg, static int _read_segment(struct dm_pool *mem, struct volume_group *vg,
struct logical_volume *lv, const struct config_node *sn, struct logical_volume *lv, const struct dm_config_node *sn,
struct dm_hash_table *pv_hash) struct dm_hash_table *pv_hash)
{ {
uint32_t area_count = 0u; uint32_t area_count = 0u;
struct lv_segment *seg; struct lv_segment *seg;
const struct config_node *cn, *sn_child = sn->child; const struct dm_config_node *cn, *sn_child = sn->child;
const struct config_value *cv; const struct dm_config_value *cv;
uint32_t start_extent, extent_count; uint32_t start_extent, extent_count;
struct segment_type *segtype; struct segment_type *segtype;
const char *segtype_str; const char *segtype_str;
@ -322,7 +322,7 @@ static int _read_segment(struct dm_pool *mem, struct volume_group *vg,
segtype_str = "striped"; segtype_str = "striped";
if ((cn = find_config_node(sn_child, "type"))) { if ((cn = dm_config_find_node(sn_child, "type"))) {
cv = cn->v; cv = cn->v;
if (!cv || !cv->v.str) { if (!cv || !cv->v.str) {
log_error("Segment type must be a string."); log_error("Segment type must be a string.");
@ -350,7 +350,7 @@ static int _read_segment(struct dm_pool *mem, struct volume_group *vg,
return_0; return_0;
/* Optional tags */ /* Optional tags */
if ((cn = find_config_node(sn_child, "tags")) && if ((cn = dm_config_find_node(sn_child, "tags")) &&
!(read_tags(mem, &seg->tags, cn->v))) { !(read_tags(mem, &seg->tags, cn->v))) {
log_error("Couldn't read tags for a segment of %s/%s.", log_error("Couldn't read tags for a segment of %s/%s.",
vg->name, lv->name); vg->name, lv->name);
@ -377,15 +377,15 @@ static int _read_segment(struct dm_pool *mem, struct volume_group *vg,
return 1; return 1;
} }
int text_import_areas(struct lv_segment *seg, const struct config_node *sn, int text_import_areas(struct lv_segment *seg, const struct dm_config_node *sn,
const struct config_node *cn, struct dm_hash_table *pv_hash, const struct dm_config_node *cn, struct dm_hash_table *pv_hash,
uint64_t status) uint64_t status)
{ {
unsigned int s; unsigned int s;
const struct config_value *cv; const struct dm_config_value *cv;
struct logical_volume *lv1; struct logical_volume *lv1;
struct physical_volume *pv; struct physical_volume *pv;
const char *seg_name = config_parent_name(sn); const char *seg_name = dm_config_parent_name(sn);
if (!seg->area_count) { if (!seg->area_count) {
log_error("Zero areas not allowed for segment %s", seg_name); log_error("Zero areas not allowed for segment %s", seg_name);
@ -395,7 +395,7 @@ int text_import_areas(struct lv_segment *seg, const struct config_node *sn,
for (cv = cn->v, s = 0; cv && s < seg->area_count; s++, cv = cv->next) { for (cv = cn->v, s = 0; cv && s < seg->area_count; s++, cv = cv->next) {
/* first we read the pv */ /* first we read the pv */
if (cv->type != CFG_STRING) { if (cv->type != DM_CFG_STRING) {
log_error("Bad volume name in areas array for segment %s.", seg_name); log_error("Bad volume name in areas array for segment %s.", seg_name);
return 0; return 0;
} }
@ -405,7 +405,7 @@ int text_import_areas(struct lv_segment *seg, const struct config_node *sn,
return 0; return 0;
} }
if (cv->next->type != CFG_INT) { if (cv->next->type != DM_CFG_INT) {
log_error("Bad offset in areas array for segment %s.", seg_name); log_error("Bad offset in areas array for segment %s.", seg_name);
return 0; return 0;
} }
@ -442,10 +442,10 @@ int text_import_areas(struct lv_segment *seg, const struct config_node *sn,
} }
static int _read_segments(struct dm_pool *mem, struct volume_group *vg, static int _read_segments(struct dm_pool *mem, struct volume_group *vg,
struct logical_volume *lv, const struct config_node *lvn, struct logical_volume *lv, const struct dm_config_node *lvn,
struct dm_hash_table *pv_hash) struct dm_hash_table *pv_hash)
{ {
const struct config_node *sn; const struct dm_config_node *sn;
int count = 0, seg_count; int count = 0, seg_count;
for (sn = lvn; sn; sn = sn->sib) { for (sn = lvn; sn; sn = sn->sib) {
@ -495,15 +495,15 @@ static int _read_segments(struct dm_pool *mem, struct volume_group *vg,
static int _read_lvnames(struct format_instance *fid __attribute__((unused)), static int _read_lvnames(struct format_instance *fid __attribute__((unused)),
struct dm_pool *mem, struct dm_pool *mem,
struct volume_group *vg, const struct config_node *lvn, struct volume_group *vg, const struct dm_config_node *lvn,
const struct config_node *vgn __attribute__((unused)), const struct dm_config_node *vgn __attribute__((unused)),
struct dm_hash_table *pv_hash __attribute__((unused)), struct dm_hash_table *pv_hash __attribute__((unused)),
struct dm_hash_table *lv_hash, struct dm_hash_table *lv_hash,
unsigned *scan_done_once __attribute__((unused)), unsigned *scan_done_once __attribute__((unused)),
unsigned report_missing_devices __attribute__((unused))) unsigned report_missing_devices __attribute__((unused)))
{ {
struct logical_volume *lv; struct logical_volume *lv;
const struct config_node *cn; const struct dm_config_node *cn;
if (!(lv = alloc_lv(mem))) if (!(lv = alloc_lv(mem)))
return_0; return_0;
@ -523,8 +523,8 @@ static int _read_lvnames(struct format_instance *fid __attribute__((unused)),
} }
lv->alloc = ALLOC_INHERIT; lv->alloc = ALLOC_INHERIT;
if ((cn = find_config_node(lvn, "allocation_policy"))) { if ((cn = dm_config_find_node(lvn, "allocation_policy"))) {
const struct config_value *cv = cn->v; const struct dm_config_value *cv = cn->v;
if (!cv || !cv->v.str) { if (!cv || !cv->v.str) {
log_error("allocation_policy must be a string."); log_error("allocation_policy must be a string.");
return 0; return 0;
@ -554,7 +554,7 @@ static int _read_lvnames(struct format_instance *fid __attribute__((unused)),
} }
/* Optional tags */ /* Optional tags */
if ((cn = find_config_node(lvn, "tags")) && if ((cn = dm_config_find_node(lvn, "tags")) &&
!(read_tags(mem, &lv->tags, cn->v))) { !(read_tags(mem, &lv->tags, cn->v))) {
log_error("Couldn't read tags for logical volume %s/%s.", log_error("Couldn't read tags for logical volume %s/%s.",
vg->name, lv->name); vg->name, lv->name);
@ -569,8 +569,8 @@ static int _read_lvnames(struct format_instance *fid __attribute__((unused)),
static int _read_lvsegs(struct format_instance *fid __attribute__((unused)), static int _read_lvsegs(struct format_instance *fid __attribute__((unused)),
struct dm_pool *mem, struct dm_pool *mem,
struct volume_group *vg, const struct config_node *lvn, struct volume_group *vg, const struct dm_config_node *lvn,
const struct config_node *vgn __attribute__((unused)), const struct dm_config_node *vgn __attribute__((unused)),
struct dm_hash_table *pv_hash, struct dm_hash_table *pv_hash,
struct dm_hash_table *lv_hash, struct dm_hash_table *lv_hash,
unsigned *scan_done_once __attribute__((unused)), unsigned *scan_done_once __attribute__((unused)),
@ -623,17 +623,17 @@ static int _read_lvsegs(struct format_instance *fid __attribute__((unused)),
static int _read_sections(struct format_instance *fid, static int _read_sections(struct format_instance *fid,
const char *section, section_fn fn, const char *section, section_fn fn,
struct dm_pool *mem, struct dm_pool *mem,
struct volume_group *vg, const struct config_node *vgn, struct volume_group *vg, const struct dm_config_node *vgn,
struct dm_hash_table *pv_hash, struct dm_hash_table *pv_hash,
struct dm_hash_table *lv_hash, struct dm_hash_table *lv_hash,
int optional, int optional,
unsigned *scan_done_once) unsigned *scan_done_once)
{ {
const struct config_node *n; const struct dm_config_node *n;
/* Only report missing devices when doing a scan */ /* Only report missing devices when doing a scan */
unsigned report_missing_devices = scan_done_once ? !*scan_done_once : 1; unsigned report_missing_devices = scan_done_once ? !*scan_done_once : 1;
if (!(n = find_config_node(vgn, section))) { if (!(n = dm_config_find_node(vgn, section))) {
if (!optional) { if (!optional) {
log_error("Couldn't find section '%s'.", section); log_error("Couldn't find section '%s'.", section);
return 0; return 0;
@ -652,10 +652,10 @@ static int _read_sections(struct format_instance *fid,
} }
static struct volume_group *_read_vg(struct format_instance *fid, static struct volume_group *_read_vg(struct format_instance *fid,
const struct config_tree *cft, const struct dm_config_tree *cft,
unsigned use_cached_pvs) unsigned use_cached_pvs)
{ {
const struct config_node *vgn, *cn; const struct dm_config_node *vgn, *cn;
struct volume_group *vg; struct volume_group *vg;
struct dm_hash_table *pv_hash = NULL, *lv_hash = NULL; struct dm_hash_table *pv_hash = NULL, *lv_hash = NULL;
unsigned scan_done_once = use_cached_pvs; unsigned scan_done_once = use_cached_pvs;
@ -677,7 +677,7 @@ static struct volume_group *_read_vg(struct format_instance *fid,
vgn = vgn->child; vgn = vgn->child;
if ((cn = find_config_node(vgn, "system_id")) && cn->v) { if ((cn = dm_config_find_node(vgn, "system_id")) && cn->v) {
if (!cn->v->v.str) { if (!cn->v->v.str) {
log_error("system_id must be a string"); log_error("system_id must be a string");
goto bad; goto bad;
@ -725,8 +725,8 @@ static struct volume_group *_read_vg(struct format_instance *fid,
goto bad; goto bad;
} }
if ((cn = find_config_node(vgn, "allocation_policy"))) { if ((cn = dm_config_find_node(vgn, "allocation_policy"))) {
const struct config_value *cv = cn->v; const struct dm_config_value *cv = cn->v;
if (!cv || !cv->v.str) { if (!cv || !cv->v.str) {
log_error("allocation_policy must be a string."); log_error("allocation_policy must be a string.");
goto bad; goto bad;
@ -760,7 +760,7 @@ static struct volume_group *_read_vg(struct format_instance *fid,
} }
/* Optional tags */ /* Optional tags */
if ((cn = find_config_node(vgn, "tags")) && if ((cn = dm_config_find_node(vgn, "tags")) &&
!(read_tags(vg->vgmem, &vg->tags, cn->v))) { !(read_tags(vg->vgmem, &vg->tags, cn->v))) {
log_error("Couldn't read tags for volume group %s.", vg->name); log_error("Couldn't read tags for volume group %s.", vg->name);
goto bad; goto bad;
@ -819,33 +819,33 @@ static struct volume_group *_read_vg(struct format_instance *fid,
} }
static void _read_desc(struct dm_pool *mem, static void _read_desc(struct dm_pool *mem,
const struct config_tree *cft, time_t *when, char **desc) const struct dm_config_tree *cft, time_t *when, char **desc)
{ {
const char *d; const char *d;
unsigned int u = 0u; unsigned int u = 0u;
int old_suppress; int old_suppress;
old_suppress = log_suppress(1); old_suppress = log_suppress(1);
d = find_config_str(cft->root, "description", ""); d = dm_config_find_str(cft->root, "description", "");
log_suppress(old_suppress); log_suppress(old_suppress);
*desc = dm_pool_strdup(mem, d); *desc = dm_pool_strdup(mem, d);
(void) get_config_uint32(cft->root, "creation_time", &u); (void) dm_config_get_uint32(cft->root, "creation_time", &u);
*when = u; *when = u;
} }
static const char *_read_vgname(const struct format_type *fmt, static const char *_read_vgname(const struct format_type *fmt,
const struct config_tree *cft, struct id *vgid, const struct dm_config_tree *cft, struct id *vgid,
uint64_t *vgstatus, char **creation_host) uint64_t *vgstatus, char **creation_host)
{ {
const struct config_node *vgn; const struct dm_config_node *vgn;
struct dm_pool *mem = fmt->cmd->mem; struct dm_pool *mem = fmt->cmd->mem;
char *vgname; char *vgname;
int old_suppress; int old_suppress;
old_suppress = log_suppress(2); old_suppress = log_suppress(2);
*creation_host = dm_pool_strdup(mem, *creation_host = dm_pool_strdup(mem,
find_config_str(cft->root, dm_config_find_str(cft->root,
"creation_host", "")); "creation_host", ""));
log_suppress(old_suppress); log_suppress(old_suppress);

6
lib/format_text/tags.c
View File

@ -61,13 +61,13 @@ bad:
return_NULL; return_NULL;
} }
int read_tags(struct dm_pool *mem, struct dm_list *tags, const struct config_value *cv) int read_tags(struct dm_pool *mem, struct dm_list *tags, const struct dm_config_value *cv)
{ {
if (cv->type == CFG_EMPTY_ARRAY) if (cv->type == DM_CFG_EMPTY_ARRAY)
return 1; return 1;
while (cv) { while (cv) {
if (cv->type != CFG_STRING) { if (cv->type != DM_CFG_STRING) {
log_error("Found a tag that is not a string"); log_error("Found a tag that is not a string");
return 0; return 0;
} }

4
lib/format_text/text_export.h
View File

@ -24,7 +24,7 @@
struct formatter; struct formatter;
struct lv_segment; struct lv_segment;
struct config_node; struct dm_config_node;
int out_size(struct formatter *f, uint64_t size, const char *fmt, ...) int out_size(struct formatter *f, uint64_t size, const char *fmt, ...)
__attribute__ ((format(printf, 3, 4))); __attribute__ ((format(printf, 3, 4)));
@ -35,7 +35,7 @@ int out_hint(struct formatter *f, const char *fmt, ...)
int out_text(struct formatter *f, const char *fmt, ...) int out_text(struct formatter *f, const char *fmt, ...)
__attribute__ ((format(printf, 2, 3))); __attribute__ ((format(printf, 2, 3)));
int out_config_node(struct formatter *f, const struct config_node *cn); int out_config_node(struct formatter *f, const struct dm_config_node *cn);
int out_areas(struct formatter *f, const struct lv_segment *seg, int out_areas(struct formatter *f, const struct lv_segment *seg,
const char *type); const char *type);

6
lib/format_text/text_import.h
View File

@ -17,10 +17,10 @@
#define _LVM_TEXT_IMPORT_H #define _LVM_TEXT_IMPORT_H
struct lv_segment; struct lv_segment;
struct config_node; struct dm_config_node;
int text_import_areas(struct lv_segment *seg, const struct config_node *sn, int text_import_areas(struct lv_segment *seg, const struct dm_config_node *sn,
const struct config_node *cn, struct dm_hash_table *pv_hash, const struct dm_config_node *cn, struct dm_hash_table *pv_hash,
uint64_t status); uint64_t status);
#endif #endif

4
lib/locking/cluster_locking.c
View File

@ -36,7 +36,7 @@
int lock_resource(struct cmd_context *cmd, const char *resource, uint32_t flags); int lock_resource(struct cmd_context *cmd, const char *resource, uint32_t flags);
int query_resource(const char *resource, int *mode); int query_resource(const char *resource, int *mode);
void locking_end(void); void locking_end(void);
int locking_init(int type, struct config_tree *cf, uint32_t *flags); int locking_init(int type, struct dm_config_tree *cf, uint32_t *flags);
#endif #endif
typedef struct lvm_response { typedef struct lvm_response {
@ -606,7 +606,7 @@ int init_cluster_locking(struct locking_type *locking, struct cmd_context *cmd,
return 1; return 1;
} }
#else #else
int locking_init(int type, struct config_tree *cf, uint32_t *flags) int locking_init(int type, struct dm_config_tree *cf, uint32_t *flags)
{ {
_clvmd_sock = _open_local_sock(0); _clvmd_sock = _open_local_sock(0);
if (_clvmd_sock == -1) if (_clvmd_sock == -1)

2
lib/locking/external_locking.c
View File

@ -26,7 +26,7 @@ static void (*_reset_fn) (void) = NULL;
static void (*_end_fn) (void) = NULL; static void (*_end_fn) (void) = NULL;
static int (*_lock_fn) (struct cmd_context * cmd, const char *resource, static int (*_lock_fn) (struct cmd_context * cmd, const char *resource,
uint32_t flags) = NULL; uint32_t flags) = NULL;
static int (*_init_fn) (int type, struct config_tree * cft, static int (*_init_fn) (int type, struct dm_config_tree * cft,
uint32_t *flags) = NULL; uint32_t *flags) = NULL;
static int (*_lock_query_fn) (const char *resource, int *mode) = NULL; static int (*_lock_query_fn) (const char *resource, int *mode) = NULL;

10
lib/metadata/lv_manip.c
View File

@ -628,7 +628,7 @@ struct alloc_handle {
*/ */
unsigned alloc_and_split_meta; unsigned alloc_and_split_meta;
const struct config_node *cling_tag_list_cn; const struct dm_config_node *cling_tag_list_cn;
struct dm_list *parallel_areas; /* PVs to avoid */ struct dm_list *parallel_areas; /* PVs to avoid */
@ -1161,7 +1161,7 @@ struct pv_match {
struct pv_area_used *areas; struct pv_area_used *areas;
struct pv_area *pva; struct pv_area *pva;
uint32_t areas_size; uint32_t areas_size;
const struct config_node *cling_tag_list_cn; const struct dm_config_node *cling_tag_list_cn;
int s; /* Area index of match */ int s; /* Area index of match */
}; };
@ -1182,12 +1182,12 @@ static int _is_same_pv(struct pv_match *pvmatch __attribute((unused)), struct pv
*/ */
static int _has_matching_pv_tag(struct pv_match *pvmatch, struct pv_segment *pvseg, struct pv_area *pva) static int _has_matching_pv_tag(struct pv_match *pvmatch, struct pv_segment *pvseg, struct pv_area *pva)
{ {
const struct config_value *cv; const struct dm_config_value *cv;
const char *str; const char *str;
const char *tag_matched; const char *tag_matched;
for (cv = pvmatch->cling_tag_list_cn->v; cv; cv = cv->next) { for (cv = pvmatch->cling_tag_list_cn->v; cv; cv = cv->next) {
if (cv->type != CFG_STRING) { if (cv->type != DM_CFG_STRING) {
log_error("Ignoring invalid string in config file entry " log_error("Ignoring invalid string in config file entry "
"allocation/cling_tag_list"); "allocation/cling_tag_list");
continue; continue;
@ -1292,7 +1292,7 @@ static int _is_condition(struct cmd_context *cmd __attribute__((unused)),
* Is pva on same PV as any existing areas? * Is pva on same PV as any existing areas?
*/ */
static int _check_cling(struct alloc_handle *ah, static int _check_cling(struct alloc_handle *ah,
const struct config_node *cling_tag_list_cn, const struct dm_config_node *cling_tag_list_cn,
struct lv_segment *prev_lvseg, struct pv_area *pva, struct lv_segment *prev_lvseg, struct pv_area *pva,
struct alloc_state *alloc_state) struct alloc_state *alloc_state)
{ {

2
lib/metadata/metadata.c
View File

@ -687,7 +687,7 @@ int vg_extend(struct volume_group *vg, int pv_count, const char *const *pv_names
log_error("Failed to duplicate pv name %s.", pv_names[i]); log_error("Failed to duplicate pv name %s.", pv_names[i]);
return 0; return 0;
} }
unescape_colons_and_at_signs(pv_name, NULL, NULL); dm_unescape_colons_and_at_signs(pv_name, NULL, NULL);
if (!vg_extend_single_pv(vg, pv_name, pp)) { if (!vg_extend_single_pv(vg, pv_name, pp)) {
log_error("Unable to add physical volume '%s' to " log_error("Unable to add physical volume '%s' to "
"volume group '%s'.", pv_name, vg->name); "volume group '%s'.", pv_name, vg->name);

5
lib/metadata/metadata.h
View File

@ -98,7 +98,7 @@
//#define FMT_RESIZE_PV 0x00000080U /* Supports pvresize? */ //#define FMT_RESIZE_PV 0x00000080U /* Supports pvresize? */
//#define FMT_UNLIMITED_STRIPESIZE 0x00000100U /* Unlimited stripe size? */ //#define FMT_UNLIMITED_STRIPESIZE 0x00000100U /* Unlimited stripe size? */
struct config_tree; struct dm_config_tree;
struct metadata_area; struct metadata_area;
/* Per-format per-metadata area operations */ /* Per-format per-metadata area operations */
@ -455,9 +455,10 @@ void lv_calculate_readahead(const struct logical_volume *lv, uint32_t *read_ahea
* For internal metadata caching. * For internal metadata caching.
*/ */
int export_vg_to_buffer(struct volume_group *vg, char **buf); int export_vg_to_buffer(struct volume_group *vg, char **buf);
int export_vg_to_config_tree(struct volume_group *vg, struct dm_config_tree **cft);
struct volume_group *import_vg_from_buffer(const char *buf, struct volume_group *import_vg_from_buffer(const char *buf,
struct format_instance *fid); struct format_instance *fid);
struct volume_group *import_vg_from_config_tree(const struct config_tree *cft, struct volume_group *import_vg_from_config_tree(const struct dm_config_tree *cft,
struct format_instance *fid); struct format_instance *fid);
/* /*

6
lib/metadata/mirror.c
View File

@ -1179,13 +1179,13 @@ static int get_mirror_fault_policy(struct cmd_context *cmd __attribute__((unused
const char *policy; const char *policy;
if (log_policy) if (log_policy)
policy = find_config_str(NULL, "activation/mirror_log_fault_policy", policy = dm_config_find_str(NULL, "activation/mirror_log_fault_policy",
DEFAULT_MIRROR_LOG_FAULT_POLICY); DEFAULT_MIRROR_LOG_FAULT_POLICY);
else { else {
policy = find_config_str(NULL, "activation/mirror_image_fault_policy", policy = dm_config_find_str(NULL, "activation/mirror_image_fault_policy",
NULL); NULL);
if (!policy) if (!policy)
policy = find_config_str(NULL, "activation/mirror_device_fault_policy", policy = dm_config_find_str(NULL, "activation/mirror_device_fault_policy",
DEFAULT_MIRROR_IMAGE_FAULT_POLICY); DEFAULT_MIRROR_IMAGE_FAULT_POLICY);
} }

8
lib/metadata/segtype.h
View File

@ -20,11 +20,11 @@
struct segtype_handler; struct segtype_handler;
struct cmd_context; struct cmd_context;
struct config_tree; struct dm_config_tree;
struct lv_segment; struct lv_segment;
struct lv_activate_opts; struct lv_activate_opts;
struct formatter; struct formatter;
struct config_node; struct dm_config_node;
struct dev_manager; struct dev_manager;
/* Feature flags */ /* Feature flags */
@ -87,10 +87,10 @@ struct segtype_handler {
void (*display) (const struct lv_segment * seg); void (*display) (const struct lv_segment * seg);
int (*text_export) (const struct lv_segment * seg, int (*text_export) (const struct lv_segment * seg,
struct formatter * f); struct formatter * f);
int (*text_import_area_count) (const struct config_node * sn, int (*text_import_area_count) (const struct dm_config_node * sn,
uint32_t *area_count); uint32_t *area_count);
int (*text_import) (struct lv_segment * seg, int (*text_import) (struct lv_segment * seg,
const struct config_node * sn, const struct dm_config_node * sn,
struct dm_hash_table * pv_hash); struct dm_hash_table * pv_hash);
int (*merge_segments) (struct lv_segment * seg1, int (*merge_segments) (struct lv_segment * seg1,
struct lv_segment * seg2); struct lv_segment * seg2);

32
lib/mirror/mirrored.c
View File

@ -69,46 +69,46 @@ static void _mirrored_display(const struct lv_segment *seg)
log_print(" "); log_print(" ");
} }
static int _mirrored_text_import_area_count(const struct config_node *sn, uint32_t *area_count) static int _mirrored_text_import_area_count(const struct dm_config_node *sn, uint32_t *area_count)
{ {
if (!get_config_uint32(sn, "mirror_count", area_count)) { if (!dm_config_get_uint32(sn, "mirror_count", area_count)) {
log_error("Couldn't read 'mirror_count' for " log_error("Couldn't read 'mirror_count' for "
"segment '%s'.", config_parent_name(sn)); "segment '%s'.", dm_config_parent_name(sn));
return 0; return 0;
} }
return 1; return 1;
} }
static int _mirrored_text_import(struct lv_segment *seg, const struct config_node *sn, static int _mirrored_text_import(struct lv_segment *seg, const struct dm_config_node *sn,
struct dm_hash_table *pv_hash) struct dm_hash_table *pv_hash)
{ {
const struct config_node *cn; const struct dm_config_node *cn;
const char *logname = NULL; const char *logname = NULL;
if (find_config_node(sn, "extents_moved")) { if (dm_config_find_node(sn, "extents_moved")) {
if (get_config_uint32(sn, "extents_moved", if (dm_config_get_uint32(sn, "extents_moved",
&seg->extents_copied)) &seg->extents_copied))
seg->status |= PVMOVE; seg->status |= PVMOVE;
else { else {
log_error("Couldn't read 'extents_moved' for " log_error("Couldn't read 'extents_moved' for "
"segment %s of logical volume %s.", "segment %s of logical volume %s.",
config_parent_name(sn), seg->lv->name); dm_config_parent_name(sn), seg->lv->name);
return 0; return 0;
} }
} }
if (find_config_node(sn, "region_size")) { if (dm_config_find_node(sn, "region_size")) {
if (!get_config_uint32(sn, "region_size", if (!dm_config_get_uint32(sn, "region_size",
&seg->region_size)) { &seg->region_size)) {
log_error("Couldn't read 'region_size' for " log_error("Couldn't read 'region_size' for "
"segment %s of logical volume %s.", "segment %s of logical volume %s.",
config_parent_name(sn), seg->lv->name); dm_config_parent_name(sn), seg->lv->name);
return 0; return 0;
} }
} }
if ((cn = find_config_node(sn, "mirror_log"))) { if ((cn = dm_config_find_node(sn, "mirror_log"))) {
if (!cn->v || !cn->v->v.str) { if (!cn->v || !cn->v->v.str) {
log_error("Mirror log type must be a string."); log_error("Mirror log type must be a string.");
return 0; return 0;
@ -117,7 +117,7 @@ static int _mirrored_text_import(struct lv_segment *seg, const struct config_nod
if (!(seg->log_lv = find_lv(seg->lv->vg, logname))) { if (!(seg->log_lv = find_lv(seg->lv->vg, logname))) {
log_error("Unrecognised mirror log in " log_error("Unrecognised mirror log in "
"segment %s of logical volume %s.", "segment %s of logical volume %s.",
config_parent_name(sn), seg->lv->name); dm_config_parent_name(sn), seg->lv->name);
return 0; return 0;
} }
seg->log_lv->status |= MIRROR_LOG; seg->log_lv->status |= MIRROR_LOG;
@ -126,14 +126,14 @@ static int _mirrored_text_import(struct lv_segment *seg, const struct config_nod
if (logname && !seg->region_size) { if (logname && !seg->region_size) {
log_error("Missing region size for mirror log for " log_error("Missing region size for mirror log for "
"segment %s of logical volume %s.", "segment %s of logical volume %s.",
config_parent_name(sn), seg->lv->name); dm_config_parent_name(sn), seg->lv->name);
return 0; return 0;
} }
if (!(cn = find_config_node(sn, "mirrors"))) { if (!(cn = dm_config_find_node(sn, "mirrors"))) {
log_error("Couldn't find mirrors array for " log_error("Couldn't find mirrors array for "
"segment %s of logical volume %s.", "segment %s of logical volume %s.",
config_parent_name(sn), seg->lv->name); dm_config_parent_name(sn), seg->lv->name);
return 0; return 0;
} }

248
lib/misc/lvm-string.c
View File

@ -43,248 +43,6 @@ int emit_to_buffer(char **buffer, size_t *size, const char *fmt, ...)
return 1; return 1;
} }
/*
* Count occurences of 'c' in 'str' until we reach a null char.
*
* Returns:
* len - incremented for each char we encounter.
* count - number of occurrences of 'c' and 'c2'.
*/
static void _count_chars(const char *str, size_t *len, int *count,
const int c1, const int c2)
{
const char *ptr;
for (ptr = str; *ptr; ptr++, (*len)++)
if (*ptr == c1 || *ptr == c2)
(*count)++;
}
/*
* Count occurences of 'c' in 'str' of length 'size'.
*
* Returns:
* Number of occurrences of 'c'
*/
unsigned count_chars(const char *str, size_t len, const int c)
{
size_t i;
unsigned count = 0;
for (i = 0; i < len; i++)
if (str[i] == c)
count++;
return count;
}
/*
* Length of string after escaping double quotes and backslashes.
*/
size_t escaped_len(const char *str)
{
size_t len = 1;
int count = 0;
_count_chars(str, &len, &count, '\"', '\\');
return count + len;
}
/*
* Copies a string, quoting orig_char with quote_char.
* Optionally also quote quote_char.
*/
static void _quote_characters(char **out, const char *src,
const int orig_char, const int quote_char,
int quote_quote_char)
{
while (*src) {
if (*src == orig_char ||
(*src == quote_char && quote_quote_char))
*(*out)++ = quote_char;
*(*out)++ = *src++;
}
}
static void _unquote_one_character(char *src, const char orig_char,
const char quote_char)
{
char *out;
char s, n;
/* Optimise for the common case where no changes are needed. */
while ((s = *src++)) {
if (s == quote_char &&
((n = *src) == orig_char || n == quote_char)) {
out = src++;
*(out - 1) = n;
while ((s = *src++)) {
if (s == quote_char &&
((n = *src) == orig_char || n == quote_char)) {
s = n;
src++;
}
*out = s;
out++;
}
*out = '\0';
return;
}
}
}
/*
* Unquote each character given in orig_char array and unquote quote_char
* as well. Also save the first occurrence of each character from orig_char
* that was found unquoted in arr_substr_first_unquoted array. This way we can
* process several characters in one go.
*/
static void _unquote_characters(char *src, const char *orig_chars,
size_t num_orig_chars,
const char quote_char,
char *arr_substr_first_unquoted[])
{
char *out = src;
char c, s, n;
unsigned i;
while ((s = *src++)) {
for (i = 0; i < num_orig_chars; i++) {
c = orig_chars[i];
if (s == quote_char &&
((n = *src) == c || n == quote_char)) {
s = n;
src++;
break;
}
if (arr_substr_first_unquoted && (s == c) &&
!arr_substr_first_unquoted[i])
arr_substr_first_unquoted[i] = out;
};
*out++ = s;
}
*out = '\0';
}
/*
* Copies a string, quoting hyphens with hyphens.
*/
static void _quote_hyphens(char **out, const char *src)
{
_quote_characters(out, src, '-', '-', 0);
}
/*
* <vg>-<lv>-<layer> or if !layer just <vg>-<lv>.
*/
char *build_dm_name(struct dm_pool *mem, const char *vgname,
const char *lvname, const char *layer)
{
size_t len = 1;
int hyphens = 1;
char *r, *out;
_count_chars(vgname, &len, &hyphens, '-', 0);
_count_chars(lvname, &len, &hyphens, '-', 0);
if (layer && *layer) {
_count_chars(layer, &len, &hyphens, '-', 0);
hyphens++;
}
len += hyphens;
if (!(r = dm_pool_alloc(mem, len))) {
log_error("build_dm_name: Allocation failed for %" PRIsize_t
" for %s %s %s.", len, vgname, lvname, layer);
return NULL;
}
out = r;
_quote_hyphens(&out, vgname);
*out++ = '-';
_quote_hyphens(&out, lvname);
if (layer && *layer) {
/* No hyphen if the layer begins with _ e.g. _mlog */
if (*layer != '_')
*out++ = '-';
_quote_hyphens(&out, layer);
}
*out = '\0';
return r;
}
char *build_dm_uuid(struct dm_pool *mem, const char *lvid, const char *layer)
{
char *dmuuid;
size_t len;
if (!layer)
layer = "";
len = sizeof(UUID_PREFIX) + strlen(lvid) + strlen(layer) + 1;
if (!(dmuuid = dm_pool_alloc(mem, len))) {
log_error("build_dm_name: Allocation failed for %" PRIsize_t
" %s %s.", len, lvid, layer);
return NULL;
}
sprintf(dmuuid, UUID_PREFIX "%s%s%s", lvid, (*layer) ? "-" : "", layer);
return dmuuid;
}
/*
* Copies a string, quoting double quotes with backslashes.
*/
char *escape_double_quotes(char *out, const char *src)
{
char *buf = out;
_quote_characters(&buf, src, '\"', '\\', 1);
*buf = '\0';
return out;
}
/*
* Undo quoting in situ.
*/
void unescape_double_quotes(char *src)
{
_unquote_one_character(src, '\"', '\\');
}
/*
* Unescape colons and "at" signs in situ and save the substrings
* starting at the position of the first unescaped colon and the
* first unescaped "at" sign. This is normally used to unescape
* device names used as PVs.
*/
void unescape_colons_and_at_signs(char *src,
char **substr_first_unquoted_colon,
char **substr_first_unquoted_at_sign)
{
const char *orig_chars = ":@";
char *arr_substr_first_unquoted[] = {NULL, NULL, NULL};
_unquote_characters(src, orig_chars, 2, '\\', arr_substr_first_unquoted);
if (substr_first_unquoted_colon)
*substr_first_unquoted_colon = arr_substr_first_unquoted[0];
if (substr_first_unquoted_at_sign)
*substr_first_unquoted_at_sign = arr_substr_first_unquoted[1];
}
/* /*
* A-Za-z0-9._-+/=!:&# * A-Za-z0-9._-+/=!:&#
*/ */
@ -392,3 +150,9 @@ int is_reserved_lvname(const char *name)
return rc; return rc;
} }
char *build_dm_uuid(struct dm_pool *mem, const char *lvid,
const char *layer)
{
return dm_build_dm_uuid(mem, UUID_PREFIX, lvid, layer);
}

34
lib/misc/lvm-string.h
View File

@ -27,8 +27,6 @@ struct pool;
int emit_to_buffer(char **buffer, size_t *size, const char *fmt, ...) int emit_to_buffer(char **buffer, size_t *size, const char *fmt, ...)
__attribute__ ((format(printf, 3, 4))); __attribute__ ((format(printf, 3, 4)));
char *build_dm_name(struct dm_pool *mem, const char *vg,
const char *lv, const char *layer);
char *build_dm_uuid(struct dm_pool *mem, const char *lvid, char *build_dm_uuid(struct dm_pool *mem, const char *lvid,
const char *layer); const char *layer);
@ -38,36 +36,4 @@ int validate_tag(const char *n);
int apply_lvname_restrictions(const char *name); int apply_lvname_restrictions(const char *name);
int is_reserved_lvname(const char *name); int is_reserved_lvname(const char *name);
/*
* Returns number of occurrences of c in first len characters of str.
*/
unsigned count_chars(const char *str, size_t len, const int c);
/*
* Returns what length of escaped string would be including terminating NUL.
*/
size_t escaped_len(const char *str);
/*
* Copies a string from src to out.
* Double quotation marks and backslashes are quoted with a backslash.
* Caller must ensure *out has enough space - see escaped_len().
* Returns *out.
*/
char *escape_double_quotes(char *out, const char *src);
/*
* Removes quoting of double quotation marks and backslashes in situ.
*/
void unescape_double_quotes(char *src);
/*
* Unescape colons and at signs in situ and save the substring starting
* at the position of the first unescaped colon and the first unescaped
* "at" sign.
*/
void unescape_colons_and_at_signs(char *src,
char **substr_first_unquoted_colon,
char **substr_first_unquoted_at_sign);
#endif #endif

8
lib/mm/memlock.c
View File

@ -146,10 +146,10 @@ static void _release_memory(void)
* mlock/munlock memory areas from /proc/self/maps * mlock/munlock memory areas from /proc/self/maps
* format described in kernel/Documentation/filesystem/proc.txt * format described in kernel/Documentation/filesystem/proc.txt
*/ */
static int _maps_line(const struct config_node *cn, lvmlock_t lock, static int _maps_line(const struct dm_config_node *cn, lvmlock_t lock,
const char* line, size_t* mstats) const char* line, size_t* mstats)
{ {
const struct config_value *cv; const struct dm_config_value *cv;
long from, to; long from, to;
int pos; int pos;
unsigned i; unsigned i;
@ -188,7 +188,7 @@ static int _maps_line(const struct config_node *cn, lvmlock_t lock,
} }
} else { } else {
for (cv = cn->v; cv; cv = cv->next) { for (cv = cn->v; cv; cv = cv->next) {
if ((cv->type != CFG_STRING) || !cv->v.str[0]) if ((cv->type != DM_CFG_STRING) || !cv->v.str[0])
continue; continue;
if (strstr(line + pos, cv->v.str)) { if (strstr(line + pos, cv->v.str)) {
log_debug("mlock_filter '%s' matches '%s': Skipping.", log_debug("mlock_filter '%s' matches '%s': Skipping.",
@ -228,7 +228,7 @@ static int _maps_line(const struct config_node *cn, lvmlock_t lock,
static int _memlock_maps(struct cmd_context *cmd, lvmlock_t lock, size_t *mstats) static int _memlock_maps(struct cmd_context *cmd, lvmlock_t lock, size_t *mstats)
{ {
const struct config_node *cn; const struct dm_config_node *cn;
char *line, *line_end; char *line, *line_end;
size_t len; size_t len;
ssize_t n; ssize_t n;

36
lib/raid/raid.c
View File

@ -32,25 +32,25 @@ static const char *_raid_name(const struct lv_segment *seg)
return seg->segtype->name; return seg->segtype->name;
} }
static int _raid_text_import_area_count(const struct config_node *sn, static int _raid_text_import_area_count(const struct dm_config_node *sn,
uint32_t *area_count) uint32_t *area_count)
{ {
if (!get_config_uint32(sn, "device_count", area_count)) { if (!dm_config_get_uint32(sn, "device_count", area_count)) {
log_error("Couldn't read 'device_count' for " log_error("Couldn't read 'device_count' for "
"segment '%s'.", config_parent_name(sn)); "segment '%s'.", dm_config_parent_name(sn));
return 0; return 0;
} }
return 1; return 1;
} }
static int _raid_text_import_areas(struct lv_segment *seg, static int _raid_text_import_areas(struct lv_segment *seg,
const struct config_node *sn, const struct dm_config_node *sn,
const struct config_node *cn) const struct dm_config_node *cn)
{ {
unsigned int s; unsigned int s;
const struct config_value *cv; const struct dm_config_value *cv;
struct logical_volume *lv1; struct logical_volume *lv1;
const char *seg_name = config_parent_name(sn); const char *seg_name = dm_config_parent_name(sn);
if (!seg->area_count) { if (!seg->area_count) {
log_error("No areas found for segment %s", seg_name); log_error("No areas found for segment %s", seg_name);
@ -58,7 +58,7 @@ static int _raid_text_import_areas(struct lv_segment *seg,
} }
for (cv = cn->v, s = 0; cv && s < seg->area_count; s++, cv = cv->next) { for (cv = cn->v, s = 0; cv && s < seg->area_count; s++, cv = cv->next) {
if (cv->type != CFG_STRING) { if (cv->type != DM_CFG_STRING) {
log_error("Bad volume name in areas array for segment %s.", seg_name); log_error("Bad volume name in areas array for segment %s.", seg_name);
return 0; return 0;
} }
@ -101,31 +101,31 @@ static int _raid_text_import_areas(struct lv_segment *seg,
} }
static int _raid_text_import(struct lv_segment *seg, static int _raid_text_import(struct lv_segment *seg,
const struct config_node *sn, const struct dm_config_node *sn,
struct dm_hash_table *pv_hash) struct dm_hash_table *pv_hash)
{ {
const struct config_node *cn; const struct dm_config_node *cn;
if (find_config_node(sn, "region_size")) { if (dm_config_find_node(sn, "region_size")) {
if (!get_config_uint32(sn, "region_size", &seg->region_size)) { if (!dm_config_get_uint32(sn, "region_size", &seg->region_size)) {
log_error("Couldn't read 'region_size' for " log_error("Couldn't read 'region_size' for "
"segment %s of logical volume %s.", "segment %s of logical volume %s.",
config_parent_name(sn), seg->lv->name); dm_config_parent_name(sn), seg->lv->name);
return 0; return 0;
} }
} }
if (find_config_node(sn, "stripe_size")) { if (dm_config_find_node(sn, "stripe_size")) {
if (!get_config_uint32(sn, "stripe_size", &seg->stripe_size)) { if (!dm_config_get_uint32(sn, "stripe_size", &seg->stripe_size)) {
log_error("Couldn't read 'stripe_size' for " log_error("Couldn't read 'stripe_size' for "
"segment %s of logical volume %s.", "segment %s of logical volume %s.",
config_parent_name(sn), seg->lv->name); dm_config_parent_name(sn), seg->lv->name);
return 0; return 0;
} }
} }
if (!(cn = find_config_node(sn, "raids"))) { if (!(cn = dm_config_find_node(sn, "raids"))) {
log_error("Couldn't find RAID array for " log_error("Couldn't find RAID array for "
"segment %s of logical volume %s.", "segment %s of logical volume %s.",
config_parent_name(sn), seg->lv->name); dm_config_parent_name(sn), seg->lv->name);
return 0; return 0;
} }

62
lib/replicator/replicator.c
View File

@ -36,7 +36,7 @@
*/ */
#define SEG_LOG_ERROR(t, p...) \ #define SEG_LOG_ERROR(t, p...) \
log_error(t " segment %s of logical volume %s.", ## p, \ log_error(t " segment %s of logical volume %s.", ## p, \
config_parent_name(sn), seg->lv->name), 0; dm_config_parent_name(sn), seg->lv->name), 0;
/* /*
@ -58,24 +58,24 @@ static void _replicator_display(const struct lv_segment *seg)
log_print(" Replicator volume\t%s", seg->rlog_lv->name); log_print(" Replicator volume\t%s", seg->rlog_lv->name);
} }
/* Wrapper for get_config_uint32() with default value */ /* Wrapper for dm_config_get_uint32() with default value */
static uint32_t _get_config_uint32(const struct config_node *cn, static uint32_t _get_config_uint32(const struct dm_config_node *cn,
const char *path, const char *path,
uint32_t def) uint32_t def)
{ {
uint32_t t; uint32_t t;
return get_config_uint32(cn, path, &t) ? t : def; return dm_config_get_uint32(cn, path, &t) ? t : def;
} }
/* Wrapper for get_config_uint64() with default value */ /* Wrapper for dm_config_get_uint64() with default value */
static uint64_t _get_config_uint64(const struct config_node *cn, static uint64_t _get_config_uint64(const struct dm_config_node *cn,
const char *path, const char *path,
uint64_t def) uint64_t def)
{ {
uint64_t t; uint64_t t;
return get_config_uint64(cn, path, &t) ? t : def; return dm_config_get_uint64(cn, path, &t) ? t : def;
} }
@ -86,13 +86,13 @@ static const char _state_txt[NUM_REPLICATOR_STATE][8] = {
}; };
/* Parse state string */ /* Parse state string */
static replicator_state_t _get_state(const struct config_node *sn, static replicator_state_t _get_state(const struct dm_config_node *sn,
const char *path, replicator_state_t def) const char *path, replicator_state_t def)
{ {
const char *str; const char *str;
unsigned i; unsigned i;
if (get_config_str(sn, path, &str)) { if (dm_config_get_str(sn, path, &str)) {
for (i = 0; i < sizeof(_state_txt)/sizeof(_state_txt[0]); ++i) for (i = 0; i < sizeof(_state_txt)/sizeof(_state_txt[0]); ++i)
if (strcasecmp(str, _state_txt[i]) == 0) if (strcasecmp(str, _state_txt[i]) == 0)
return (replicator_state_t) i; return (replicator_state_t) i;
@ -115,13 +115,13 @@ static const char _op_mode_txt[NUM_DM_REPLICATOR_MODES][8] = {
/* Parse action string */ /* Parse action string */
static dm_replicator_mode_t _get_op_mode(const struct config_node *sn, static dm_replicator_mode_t _get_op_mode(const struct dm_config_node *sn,
const char *path, dm_replicator_mode_t def) const char *path, dm_replicator_mode_t def)
{ {
const char *str; const char *str;
unsigned i; unsigned i;
if (get_config_str(sn, path, &str)) { if (dm_config_get_str(sn, path, &str)) {
for (i = 0; i < sizeof(_op_mode_txt)/sizeof(_op_mode_txt[0]); ++i) for (i = 0; i < sizeof(_op_mode_txt)/sizeof(_op_mode_txt[0]); ++i)
if (strcasecmp(str, _op_mode_txt[i]) == 0) { if (strcasecmp(str, _op_mode_txt[i]) == 0) {
log_very_verbose("Setting %s to %s", log_very_verbose("Setting %s to %s",
@ -162,16 +162,16 @@ static struct replicator_site *_get_site(struct logical_volume *replicator,
/* Parse replicator site element */ /* Parse replicator site element */
static int _add_site(struct lv_segment *seg, static int _add_site(struct lv_segment *seg,
const char *key, const char *key,
const struct config_node *sn) const struct dm_config_node *sn)
{ {
struct dm_pool *mem = seg->lv->vg->vgmem; struct dm_pool *mem = seg->lv->vg->vgmem;
const struct config_node *cn; const struct dm_config_node *cn;
struct replicator_site *rsite; struct replicator_site *rsite;
if (!(rsite = _get_site(seg->lv, key))) if (!(rsite = _get_site(seg->lv, key)))
return_0; return_0;
if (!find_config_node(sn, "site_index")) if (!dm_config_find_node(sn, "site_index"))
return SEG_LOG_ERROR("Mandatory site_index is missing for"); return SEG_LOG_ERROR("Mandatory site_index is missing for");
rsite->state = _get_state(sn, "state", REPLICATOR_STATE_PASSIVE); rsite->state = _get_state(sn, "state", REPLICATOR_STATE_PASSIVE);
@ -204,8 +204,8 @@ static int _add_site(struct lv_segment *seg,
rsite->op_mode); rsite->op_mode);
} }
if ((cn = find_config_node(sn, "volume_group"))) { if ((cn = dm_config_find_node(sn, "volume_group"))) {
if (!cn->v || cn->v->type != CFG_STRING) if (!cn->v || cn->v->type != DM_CFG_STRING)
return SEG_LOG_ERROR("volume_group must be a string in"); return SEG_LOG_ERROR("volume_group must be a string in");
if (!(rsite->vg_name = dm_pool_strdup(mem, cn->v->v.str))) if (!(rsite->vg_name = dm_pool_strdup(mem, cn->v->v.str)))
@ -220,25 +220,25 @@ static int _add_site(struct lv_segment *seg,
/* Import replicator segment */ /* Import replicator segment */
static int _replicator_text_import(struct lv_segment *seg, static int _replicator_text_import(struct lv_segment *seg,
const struct config_node *sn, const struct dm_config_node *sn,
struct dm_hash_table *pv_hash __attribute__((unused))) struct dm_hash_table *pv_hash __attribute__((unused)))
{ {
const struct config_node *cn; const struct dm_config_node *cn;
struct logical_volume *rlog_lv; struct logical_volume *rlog_lv;
if (!replicator_add_replicator_dev(seg->lv, NULL)) if (!replicator_add_replicator_dev(seg->lv, NULL))
return_0; return_0;
if (!(cn = find_config_node(sn, "replicator_log")) || if (!(cn = dm_config_find_node(sn, "replicator_log")) ||
!cn->v || cn->v->type != CFG_STRING) !cn->v || cn->v->type != DM_CFG_STRING)
return SEG_LOG_ERROR("Replicator log type must be a string in"); return SEG_LOG_ERROR("Replicator log type must be a string in");
if (!(rlog_lv = find_lv(seg->lv->vg, cn->v->v.str))) if (!(rlog_lv = find_lv(seg->lv->vg, cn->v->v.str)))
return SEG_LOG_ERROR("Unknown replicator log %s in", return SEG_LOG_ERROR("Unknown replicator log %s in",
cn->v->v.str); cn->v->v.str);
if (!(cn = find_config_node(sn, "replicator_log_type")) || if (!(cn = dm_config_find_node(sn, "replicator_log_type")) ||
!cn->v || cn->v->type != CFG_STRING) !cn->v || cn->v->type != DM_CFG_STRING)
return SEG_LOG_ERROR("Replicator log's type must be a string in"); return SEG_LOG_ERROR("Replicator log's type must be a string in");
if (strcasecmp(cn->v->v.str, "ringbuffer")) if (strcasecmp(cn->v->v.str, "ringbuffer"))
return SEG_LOG_ERROR("Only ringbuffer replicator log type is supported in"); return SEG_LOG_ERROR("Only ringbuffer replicator log type is supported in");
@ -443,7 +443,7 @@ static void _replicator_dev_display(const struct lv_segment *seg)
static int _add_device(struct lv_segment *seg, static int _add_device(struct lv_segment *seg,
const char *site_name, const char *site_name,
const struct config_node *sn, const struct dm_config_node *sn,
uint64_t devidx) uint64_t devidx)
{ {
struct dm_pool *mem = seg->lv->vg->vgmem; struct dm_pool *mem = seg->lv->vg->vgmem;
@ -453,19 +453,19 @@ static int _add_device(struct lv_segment *seg,
struct replicator_device *rdev; struct replicator_device *rdev;
const char *dev_str = NULL; const char *dev_str = NULL;
const char *slog_str = NULL; const char *slog_str = NULL;
const struct config_node *cn; const struct dm_config_node *cn;
dm_list_iterate_items(rdev, &rsite->rdevices) dm_list_iterate_items(rdev, &rsite->rdevices)
if (rdev->replicator_dev == seg) if (rdev->replicator_dev == seg)
return SEG_LOG_ERROR("Duplicate site found in"); return SEG_LOG_ERROR("Duplicate site found in");
if ((cn = find_config_node(sn, "sync_log"))) { if ((cn = dm_config_find_node(sn, "sync_log"))) {
if (!cn->v || !cn->v->v.str) if (!cn->v || !cn->v->v.str)
return SEG_LOG_ERROR("Sync log must be a string in"); return SEG_LOG_ERROR("Sync log must be a string in");
slog_str = cn->v->v.str; slog_str = cn->v->v.str;
} }
if (!(cn = find_config_node(sn, "logical_volume")) || if (!(cn = dm_config_find_node(sn, "logical_volume")) ||
!cn->v || !cn->v->v.str) !cn->v || !cn->v->v.str)
return SEG_LOG_ERROR("Logical volume must be a string in"); return SEG_LOG_ERROR("Logical volume must be a string in");
@ -520,14 +520,14 @@ static int _add_device(struct lv_segment *seg,
/* Import replicator segment */ /* Import replicator segment */
static int _replicator_dev_text_import(struct lv_segment *seg, static int _replicator_dev_text_import(struct lv_segment *seg,
const struct config_node *sn, const struct dm_config_node *sn,
struct dm_hash_table *pv_hash __attribute__((unused))) struct dm_hash_table *pv_hash __attribute__((unused)))
{ {
const struct config_node *cn; const struct dm_config_node *cn;
struct logical_volume *replicator; struct logical_volume *replicator;
uint64_t devidx; uint64_t devidx;
if (!(cn = find_config_node(sn, "replicator"))) if (!(cn = dm_config_find_node(sn, "replicator")))
return SEG_LOG_ERROR("Replicator is missing for"); return SEG_LOG_ERROR("Replicator is missing for");
if (!cn->v || !cn->v->v.str) if (!cn->v || !cn->v->v.str)
@ -542,8 +542,8 @@ static int _replicator_dev_text_import(struct lv_segment *seg,
log_very_verbose("replicator=%s", replicator->name); log_very_verbose("replicator=%s", replicator->name);
/* Mandatory */ /* Mandatory */
if (!find_config_node(sn, "device_index") || if (!dm_config_find_node(sn, "device_index") ||
!get_config_uint64(sn, "device_index", &devidx)) !dm_config_get_uint64(sn, "device_index", &devidx))
return SEG_LOG_ERROR("Could not read 'device_index' for"); return SEG_LOG_ERROR("Could not read 'device_index' for");
/* Read devices from sites */ /* Read devices from sites */

12
lib/snapshot/snapshot.c
View File

@ -37,7 +37,7 @@ static const char *_snap_target_name(const struct lv_segment *seg,
return _snap_name(seg); return _snap_name(seg);
} }
static int _snap_text_import(struct lv_segment *seg, const struct config_node *sn, static int _snap_text_import(struct lv_segment *seg, const struct dm_config_node *sn,
struct dm_hash_table *pv_hash __attribute__((unused))) struct dm_hash_table *pv_hash __attribute__((unused)))
{ {
uint32_t chunk_size; uint32_t chunk_size;
@ -45,28 +45,28 @@ static int _snap_text_import(struct lv_segment *seg, const struct config_node *s
struct logical_volume *org, *cow; struct logical_volume *org, *cow;
int old_suppress, merge = 0; int old_suppress, merge = 0;
if (!get_config_uint32(sn, "chunk_size", &chunk_size)) { if (!dm_config_get_uint32(sn, "chunk_size", &chunk_size)) {
log_error("Couldn't read chunk size for snapshot."); log_error("Couldn't read chunk size for snapshot.");
return 0; return 0;
} }
old_suppress = log_suppress(1); old_suppress = log_suppress(1);
if ((cow_name = find_config_str(sn, "merging_store", NULL))) { if ((cow_name = dm_config_find_str(sn, "merging_store", NULL))) {
if (find_config_str(sn, "cow_store", NULL)) { if (dm_config_find_str(sn, "cow_store", NULL)) {
log_suppress(old_suppress); log_suppress(old_suppress);
log_error("Both snapshot cow and merging storage were specified."); log_error("Both snapshot cow and merging storage were specified.");
return 0; return 0;
} }
merge = 1; merge = 1;
} }
else if (!(cow_name = find_config_str(sn, "cow_store", NULL))) { else if (!(cow_name = dm_config_find_str(sn, "cow_store", NULL))) {
log_suppress(old_suppress); log_suppress(old_suppress);
log_error("Snapshot cow storage not specified."); log_error("Snapshot cow storage not specified.");
return 0; return 0;
} }
if (!(org_name = find_config_str(sn, "origin", NULL))) { if (!(org_name = dm_config_find_str(sn, "origin", NULL))) {
log_suppress(old_suppress); log_suppress(old_suppress);
log_error("Snapshot origin not specified."); log_error("Snapshot origin not specified.");
return 0; return 0;

18
lib/striped/striped.c
View File

@ -57,32 +57,32 @@ static void _striped_display(const struct lv_segment *seg)
log_print(" "); log_print(" ");
} }
static int _striped_text_import_area_count(const struct config_node *sn, uint32_t *area_count) static int _striped_text_import_area_count(const struct dm_config_node *sn, uint32_t *area_count)
{ {
if (!get_config_uint32(sn, "stripe_count", area_count)) { if (!dm_config_get_uint32(sn, "stripe_count", area_count)) {
log_error("Couldn't read 'stripe_count' for " log_error("Couldn't read 'stripe_count' for "
"segment '%s'.", config_parent_name(sn)); "segment '%s'.", dm_config_parent_name(sn));
return 0; return 0;
} }
return 1; return 1;
} }
static int _striped_text_import(struct lv_segment *seg, const struct config_node *sn, static int _striped_text_import(struct lv_segment *seg, const struct dm_config_node *sn,
struct dm_hash_table *pv_hash) struct dm_hash_table *pv_hash)
{ {
const struct config_node *cn; const struct dm_config_node *cn;
if ((seg->area_count != 1) && if ((seg->area_count != 1) &&
!get_config_uint32(sn, "stripe_size", &seg->stripe_size)) { !dm_config_get_uint32(sn, "stripe_size", &seg->stripe_size)) {
log_error("Couldn't read stripe_size for segment %s " log_error("Couldn't read stripe_size for segment %s "
"of logical volume %s.", config_parent_name(sn), seg->lv->name); "of logical volume %s.", dm_config_parent_name(sn), seg->lv->name);
return 0; return 0;
} }
if (!(cn = find_config_node(sn, "stripes"))) { if (!(cn = dm_config_find_node(sn, "stripes"))) {
log_error("Couldn't find stripes array for segment %s " log_error("Couldn't find stripes array for segment %s "
"of logical volume %s.", config_parent_name(sn), seg->lv->name); "of logical volume %s.", dm_config_parent_name(sn), seg->lv->name);
return 0; return 0;
} }

34
lib/thin/thin.c
View File

@ -36,39 +36,39 @@
*/ */
#define SEG_LOG_ERROR(t, p...) \ #define SEG_LOG_ERROR(t, p...) \
log_error(t " segment %s of logical volume %s.", ## p, \ log_error(t " segment %s of logical volume %s.", ## p, \
config_parent_name(sn), seg->lv->name), 0; dm_config_parent_name(sn), seg->lv->name), 0;
static const char *_thin_pool_name(const struct lv_segment *seg) static const char *_thin_pool_name(const struct lv_segment *seg)
{ {
return seg->segtype->name; return seg->segtype->name;
} }
static int _thin_pool_text_import(struct lv_segment *seg, const struct config_node *sn, static int _thin_pool_text_import(struct lv_segment *seg, const struct dm_config_node *sn,
struct dm_hash_table *pv_hash __attribute__((unused))) struct dm_hash_table *pv_hash __attribute__((unused)))
{ {
const struct config_node *cn; const struct dm_config_node *cn;
if (!(cn = find_config_node(sn, "data")) || if (!(cn = dm_config_find_node(sn, "data")) ||
!cn->v || cn->v->type != CFG_STRING) !cn->v || cn->v->type != DM_CFG_STRING)
return SEG_LOG_ERROR("Thin pool data must be a string in"); return SEG_LOG_ERROR("Thin pool data must be a string in");
if (!(seg->data_lv = find_lv(seg->lv->vg, cn->v->v.str))) if (!(seg->data_lv = find_lv(seg->lv->vg, cn->v->v.str)))
return SEG_LOG_ERROR("Unknown pool data %s in", return SEG_LOG_ERROR("Unknown pool data %s in",
cn->v->v.str); cn->v->v.str);
if (!(cn = find_config_node(sn, "metadata")) || if (!(cn = dm_config_find_node(sn, "metadata")) ||
!cn->v || cn->v->type != CFG_STRING) !cn->v || cn->v->type != DM_CFG_STRING)
return SEG_LOG_ERROR("Thin pool metadata must be a string in"); return SEG_LOG_ERROR("Thin pool metadata must be a string in");
if (!(seg->metadata_lv = find_lv(seg->lv->vg, cn->v->v.str))) if (!(seg->metadata_lv = find_lv(seg->lv->vg, cn->v->v.str)))
return SEG_LOG_ERROR("Unknown pool metadata %s in", return SEG_LOG_ERROR("Unknown pool metadata %s in",
cn->v->v.str); cn->v->v.str);
if (!get_config_uint64(sn, "transaction_id", &seg->transaction_id)) if (!dm_config_get_uint64(sn, "transaction_id", &seg->transaction_id))
return SEG_LOG_ERROR("Could not read transaction_id for"); return SEG_LOG_ERROR("Could not read transaction_id for");
if (find_config_node(sn, "zero_new_blocks") && if (dm_config_find_node(sn, "zero_new_blocks") &&
!get_config_uint32(sn, "zero_new_blocks", &seg->zero_new_blocks)) !dm_config_get_uint32(sn, "zero_new_blocks", &seg->zero_new_blocks))
return SEG_LOG_ERROR("Could not read zero_new_blocks for"); return SEG_LOG_ERROR("Could not read zero_new_blocks for");
return 1; return 1;
@ -90,21 +90,21 @@ static const char *_thin_name(const struct lv_segment *seg)
return seg->segtype->name; return seg->segtype->name;
} }
static int _thin_text_import(struct lv_segment *seg, const struct config_node *sn, static int _thin_text_import(struct lv_segment *seg, const struct dm_config_node *sn,
struct dm_hash_table *pv_hash __attribute__((unused))) struct dm_hash_table *pv_hash __attribute__((unused)))
{ {
const struct config_node *cn; const struct dm_config_node *cn;
if (!(cn = find_config_node(sn, "thin_pool")) || if (!(cn = dm_config_find_node(sn, "thin_pool")) ||
!cn->v || cn->v->type != CFG_STRING) !cn->v || cn->v->type != DM_CFG_STRING)
return SEG_LOG_ERROR("Thin pool must be a string in"); return SEG_LOG_ERROR("Thin pool must be a string in");
if (!(seg->thin_pool_lv = find_lv(seg->lv->vg, cn->v->v.str))) if (!(seg->thin_pool_lv = find_lv(seg->lv->vg, cn->v->v.str)))
return SEG_LOG_ERROR("Unknown thin pool %s in", return SEG_LOG_ERROR("Unknown thin pool %s in",
cn->v->v.str); cn->v->v.str);
if ((cn = find_config_node(sn, "origin"))) { if ((cn = dm_config_find_node(sn, "origin"))) {
if (!cn->v || cn->v->type != CFG_STRING) if (!cn->v || cn->v->type != DM_CFG_STRING)
return SEG_LOG_ERROR("Thin pool origin must be a string in"); return SEG_LOG_ERROR("Thin pool origin must be a string in");
if (!(seg->origin = find_lv(seg->lv->vg, cn->v->v.str))) if (!(seg->origin = find_lv(seg->lv->vg, cn->v->v.str)))
@ -112,7 +112,7 @@ static int _thin_text_import(struct lv_segment *seg, const struct config_node *s
cn->v->v.str); cn->v->v.str);
} }
if (!get_config_uint64(sn, "device_id", &seg->device_id)) if (!dm_config_get_uint64(sn, "device_id", &seg->device_id))
return SEG_LOG_ERROR("Could not read device_id for"); return SEG_LOG_ERROR("Could not read device_id for");
return 1; return 1;

10
lib/unknown/unknown.c
View File

@ -32,17 +32,17 @@ static const char *_unknown_name(const struct lv_segment *seg)
return seg->segtype->name; return seg->segtype->name;
} }
static int _unknown_text_import(struct lv_segment *seg, const struct config_node *sn, static int _unknown_text_import(struct lv_segment *seg, const struct dm_config_node *sn,
struct dm_hash_table *pv_hash) struct dm_hash_table *pv_hash)
{ {
struct config_node *new, *last = NULL, *head = NULL; struct dm_config_node *new, *last = NULL, *head = NULL;
const struct config_node *current; const struct dm_config_node *current;
log_verbose("importing unknown segment"); log_verbose("importing unknown segment");
for (current = sn; current != NULL; current = current->sib) { for (current = sn; current != NULL; current = current->sib) {
if (!strcmp(current->key, "type") || !strcmp(current->key, "start_extent") || if (!strcmp(current->key, "type") || !strcmp(current->key, "start_extent") ||
!strcmp(current->key, "tags") || !strcmp(current->key, "extent_count")) !strcmp(current->key, "tags") || !strcmp(current->key, "extent_count"))
continue; continue;
new = clone_config_node_with_mem(seg->lv->vg->vgmem, current, 0); new = dm_config_clone_node_with_mem(seg->lv->vg->vgmem, current, 0);
if (!new) if (!new)
return_0; return_0;
if (last) if (last)
@ -57,7 +57,7 @@ static int _unknown_text_import(struct lv_segment *seg, const struct config_node
static int _unknown_text_export(const struct lv_segment *seg, struct formatter *f) static int _unknown_text_export(const struct lv_segment *seg, struct formatter *f)
{ {
struct config_node *cn = seg->segtype_private; struct dm_config_node *cn = seg->segtype_private;
return out_config_node(f, cn); return out_config_node(f, cn);
} }

1
libdm/Makefile.in
View File

@ -25,6 +25,7 @@ SOURCES =\
libdm-deptree.c \ libdm-deptree.c \
libdm-string.c \ libdm-string.c \
libdm-report.c \ libdm-report.c \
libdm-config.c \
mm/dbg_malloc.c \ mm/dbg_malloc.c \
mm/pool.c \ mm/pool.c \
regex/matcher.c \ regex/matcher.c \

143
libdm/libdevmapper.h
View File

@ -19,6 +19,7 @@
#include <inttypes.h> #include <inttypes.h>
#include <stdarg.h> #include <stdarg.h>
#include <sys/types.h> #include <sys/types.h>
#include <sys/stat.h>
#ifdef linux #ifdef linux
# include <linux/types.h> # include <linux/types.h>
@ -1014,6 +1015,46 @@ int dm_snprintf(char *buf, size_t bufsize, const char *format, ...)
*/ */
const char *dm_basename(const char *path); const char *dm_basename(const char *path);
/*
* Count occurences of 'c' in 'str' of length 'size'.
*
* Returns:
* Number of occurrences of 'c'
*/
unsigned dm_count_chars(const char *str, size_t len, const int c);
/*
* Length of string after escaping double quotes and backslashes.
*/
size_t dm_escaped_len(const char *str);
/*
* <vg>-<lv>-<layer> or if !layer just <vg>-<lv>.
*/
char *dm_build_dm_name(struct dm_pool *mem, const char *vgname,
const char *lvname, const char *layer);
char *dm_build_dm_uuid(struct dm_pool *mem, const char *prefix, const char *lvid, const char *layer);
/*
* Copies a string, quoting double quotes with backslashes.
*/
char *dm_escape_double_quotes(char *out, const char *src);
/*
* Undo quoting in situ.
*/
void dm_unescape_double_quotes(char *src);
/*
* Unescape colons and "at" signs in situ and save the substrings
* starting at the position of the first unescaped colon and the
* first unescaped "at" sign. This is normally used to unescape
* device names used as PVs.
*/
void dm_unescape_colons_and_at_signs(char *src,
char **substr_first_unquoted_colon,
char **substr_first_unquoted_at_sign);
/************************** /**************************
* file/stream manipulation * file/stream manipulation
**************************/ **************************/
@ -1181,6 +1222,108 @@ int dm_report_field_uint64(struct dm_report *rh, struct dm_report_field *field,
void dm_report_field_set_value(struct dm_report_field *field, const void *value, void dm_report_field_set_value(struct dm_report_field *field, const void *value,
const void *sortvalue); const void *sortvalue);
/*********************************
* config file parse/prettyprint
*********************************/
enum {
DM_CFG_STRING,
DM_CFG_FLOAT,
DM_CFG_INT,
DM_CFG_EMPTY_ARRAY
};
struct dm_config_value {
int type;
union {
int64_t i;
float r;
const char *str;
} v;
struct dm_config_value *next; /* for arrays */
};
struct dm_config_node {
const char *key;
struct dm_config_node *parent, *sib, *child;
struct dm_config_value *v;
};
struct dm_config_tree {
struct dm_config_node *root;
struct dm_config_tree *cascade;
};
struct dm_config_tree *dm_config_create(const char *filename, int keep_open);
struct dm_config_tree *dm_config_from_string(const char *config_settings);
int dm_config_parse(struct dm_config_tree *cft, const char *start, const char *end);
void *dm_config_get_custom(struct dm_config_tree *cft);
int dm_config_check_file(struct dm_config_tree *cft, const char **filename, struct stat *info);
int dm_config_keep_open(struct dm_config_tree *ctf);
void dm_config_set_custom(struct dm_config_tree *cft, void *custom);
void dm_config_destroy(struct dm_config_tree *cft);
int dm_config_write(struct dm_config_tree *cft, const char *file,
int argc, char **argv);
typedef int (*dm_putline_fn)(const char *line, void *baton);
int dm_config_write_node(const struct dm_config_node *cn, dm_putline_fn putline, void *baton);
time_t dm_config_timestamp(struct dm_config_tree *cft);
int dm_config_changed(struct dm_config_tree *cft);
const struct dm_config_node *dm_config_find_node(const struct dm_config_node *cn, const char *path);
const char *dm_config_find_str(const struct dm_config_node *cn, const char *path, const char *fail);
int dm_config_find_int(const struct dm_config_node *cn, const char *path, int fail);
float dm_config_find_float(const struct dm_config_node *cn, const char *path, float fail);
const struct dm_config_node *dm_config_tree_find_node(
const struct dm_config_tree *cft, const char *path);
const char *dm_config_tree_find_str(const struct dm_config_tree *cft,
const char *path, const char *fail);
int dm_config_tree_find_int(const struct dm_config_tree *cft,
const char *path, int fail);
int64_t dm_config_tree_find_int64(const struct dm_config_tree *cft,
const char *path, int64_t fail);
float dm_config_tree_find_float(const struct dm_config_tree *cft,
const char *path, float fail);
int dm_config_tree_find_bool(const struct dm_config_tree *cft,
const char *path, int fail);
/*
* Understands (0, ~0), (y, n), (yes, no), (on,
* off), (true, false).
*/
int dm_config_find_bool(const struct dm_config_node *cn, const char *path, int fail);
int dm_config_get_uint32(const struct dm_config_node *cn, const char *path,
uint32_t *result);
int dm_config_get_uint64(const struct dm_config_node *cn, const char *path,
uint64_t *result);
int dm_config_get_str(const struct dm_config_node *cn, const char *path,
const char **result);
unsigned dm_config_maybe_section(const char *str, unsigned len);
const char *dm_config_parent_name(const struct dm_config_node *n);
struct dm_config_node *dm_config_clone_node_with_mem(struct dm_pool *mem,
const struct dm_config_node *node,
int siblings);
struct dm_config_node *dm_config_create_node(struct dm_config_tree *cft, const char *key);
struct dm_config_value *dm_config_create_value(struct dm_config_tree *cft);
struct dm_config_node *dm_config_clone_node(struct dm_config_tree *cft,
const struct dm_config_node *cn,
int siblings);
struct dm_pool *dm_config_memory(struct dm_config_tree *cft);
/* Cookie prefixes. /* Cookie prefixes.
* The cookie value consists of a prefix (16 bits) and a base (16 bits). * The cookie value consists of a prefix (16 bits) and a base (16 bits).
* We can use the prefix to store the flags. These flags are sent to * We can use the prefix to store the flags. These flags are sent to

1237
libdm/libdm-config.c Normal file
View File

File diff suppressed because it is too large Load Diff

222
libdm/libdm-string.c
View File

@ -161,3 +161,225 @@ int dm_asprintf(char **result, const char *format, ...)
dm_free(buf); dm_free(buf);
return n + 1; return n + 1;
} }
/*
* Count occurences of 'c' in 'str' until we reach a null char.
*
* Returns:
* len - incremented for each char we encounter.
* count - number of occurrences of 'c' and 'c2'.
*/
static void _count_chars(const char *str, size_t *len, int *count,
const int c1, const int c2)
{
const char *ptr;
for (ptr = str; *ptr; ptr++, (*len)++)
if (*ptr == c1 || *ptr == c2)
(*count)++;
}
unsigned dm_count_chars(const char *str, size_t len, const int c)
{
size_t i;
unsigned count = 0;
for (i = 0; i < len; i++)
if (str[i] == c)
count++;
return count;
}
size_t dm_escaped_len(const char *str)
{
size_t len = 1;
int count = 0;
_count_chars(str, &len, &count, '\"', '\\');
return count + len;
}
/*
* Copies a string, quoting orig_char with quote_char.
* Optionally also quote quote_char.
*/
static void _quote_characters(char **out, const char *src,
const int orig_char, const int quote_char,
int quote_quote_char)
{
while (*src) {
if (*src == orig_char ||
(*src == quote_char && quote_quote_char))
*(*out)++ = quote_char;
*(*out)++ = *src++;
}
}
static void _unquote_one_character(char *src, const char orig_char,
const char quote_char)
{
char *out;
char s, n;
/* Optimise for the common case where no changes are needed. */
while ((s = *src++)) {
if (s == quote_char &&
((n = *src) == orig_char || n == quote_char)) {
out = src++;
*(out - 1) = n;
while ((s = *src++)) {
if (s == quote_char &&
((n = *src) == orig_char || n == quote_char)) {
s = n;
src++;
}
*out = s;
out++;
}
*out = '\0';
return;
}
}
}
/*
* Unquote each character given in orig_char array and unquote quote_char
* as well. Also save the first occurrence of each character from orig_char
* that was found unquoted in arr_substr_first_unquoted array. This way we can
* process several characters in one go.
*/
static void _unquote_characters(char *src, const char *orig_chars,
size_t num_orig_chars,
const char quote_char,
char *arr_substr_first_unquoted[])
{
char *out = src;
char c, s, n;
unsigned i;
while ((s = *src++)) {
for (i = 0; i < num_orig_chars; i++) {
c = orig_chars[i];
if (s == quote_char &&
((n = *src) == c || n == quote_char)) {
s = n;
src++;
break;
}
if (arr_substr_first_unquoted && (s == c) &&
!arr_substr_first_unquoted[i])
arr_substr_first_unquoted[i] = out;
};
*out++ = s;
}
*out = '\0';
}
/*
* Copies a string, quoting hyphens with hyphens.
*/
static void _quote_hyphens(char **out, const char *src)
{
_quote_characters(out, src, '-', '-', 0);
}
char *dm_build_dm_name(struct dm_pool *mem, const char *vgname,
const char *lvname, const char *layer)
{
size_t len = 1;
int hyphens = 1;
char *r, *out;
_count_chars(vgname, &len, &hyphens, '-', 0);
_count_chars(lvname, &len, &hyphens, '-', 0);
if (layer && *layer) {
_count_chars(layer, &len, &hyphens, '-', 0);
hyphens++;
}
len += hyphens;
if (!(r = dm_pool_alloc(mem, len))) {
log_error("build_dm_name: Allocation failed for %" PRIsize_t
" for %s %s %s.", len, vgname, lvname, layer);
return NULL;
}
out = r;
_quote_hyphens(&out, vgname);
*out++ = '-';
_quote_hyphens(&out, lvname);
if (layer && *layer) {
/* No hyphen if the layer begins with _ e.g. _mlog */
if (*layer != '_')
*out++ = '-';
_quote_hyphens(&out, layer);
}
*out = '\0';
return r;
}
char *dm_build_dm_uuid(struct dm_pool *mem, const char *prefix, const char *lvid, const char *layer)
{
char *dmuuid;
size_t len;
if (!layer)
layer = "";
len = strlen(prefix) + strlen(lvid) + strlen(layer) + 1;
if (!(dmuuid = dm_pool_alloc(mem, len))) {
log_error("build_dm_name: Allocation failed for %" PRIsize_t
" %s %s.", len, lvid, layer);
return NULL;
}
sprintf(dmuuid, "%s%s%s%s", prefix, lvid, (*layer) ? "-" : "", layer);
return dmuuid;
}
/*
* Copies a string, quoting double quotes with backslashes.
*/
char *dm_escape_double_quotes(char *out, const char *src)
{
char *buf = out;
_quote_characters(&buf, src, '\"', '\\', 1);
*buf = '\0';
return out;
}
void dm_unescape_double_quotes(char *src)
{
_unquote_one_character(src, '\"', '\\');
}
void dm_unescape_colons_and_at_signs(char *src,
char **substr_first_unquoted_colon,
char **substr_first_unquoted_at_sign)
{
const char *orig_chars = ":@";
char *arr_substr_first_unquoted[] = {NULL, NULL, NULL};
_unquote_characters(src, orig_chars, 2, '\\', arr_substr_first_unquoted);
if (substr_first_unquoted_colon)
*substr_first_unquoted_colon = arr_substr_first_unquoted[0];
if (substr_first_unquoted_at_sign)
*substr_first_unquoted_at_sign = arr_substr_first_unquoted[1];
}

2
tools/dumpconfig.c
View File

@ -19,7 +19,7 @@ int dumpconfig(struct cmd_context *cmd, int argc, char **argv)
{ {
const char *file = arg_str_value(cmd, file_ARG, NULL); const char *file = arg_str_value(cmd, file_ARG, NULL);
if (!write_config_file(cmd->cft, file, argc, argv)) { if (!dm_config_write(cmd->cft, file, argc, argv)) {
stack; stack;
return ECMD_FAILED; return ECMD_FAILED;
} }

2
tools/pvchange.c
View File

@ -209,7 +209,7 @@ int pvchange(struct cmd_context *cmd, int argc, char **argv)
log_verbose("Using physical volume(s) on command line"); log_verbose("Using physical volume(s) on command line");
for (; opt < argc; opt++) { for (; opt < argc; opt++) {
pv_name = argv[opt]; pv_name = argv[opt];
unescape_colons_and_at_signs(pv_name, NULL, NULL); dm_unescape_colons_and_at_signs(pv_name, NULL, NULL);
vg_name = find_vgname_from_pvname(cmd, pv_name); vg_name = find_vgname_from_pvname(cmd, pv_name);
if (!vg_name) { if (!vg_name) {
log_error("Failed to read physical volume %s", log_error("Failed to read physical volume %s",

2
tools/pvck.c
View File

@ -31,7 +31,7 @@ int pvck(struct cmd_context *cmd, int argc, char **argv)
/* FIXME: warning and/or check if in use? */ /* FIXME: warning and/or check if in use? */
log_verbose("Scanning %s", argv[i]); log_verbose("Scanning %s", argv[i]);
unescape_colons_and_at_signs(argv[i], NULL, NULL); dm_unescape_colons_and_at_signs(argv[i], NULL, NULL);
pv_analyze(cmd, argv[i], pv_analyze(cmd, argv[i],
arg_uint64_value(cmd, labelsector_ARG, arg_uint64_value(cmd, labelsector_ARG,
UINT64_C(0))); UINT64_C(0)));

2
tools/pvcreate.c
View File

@ -110,7 +110,7 @@ int pvcreate(struct cmd_context *cmd, int argc, char **argv)
return ECMD_FAILED; return ECMD_FAILED;
} }
unescape_colons_and_at_signs(argv[i], NULL, NULL); dm_unescape_colons_and_at_signs(argv[i], NULL, NULL);
if (!(pv = pvcreate_single(cmd, argv[i], &pp, 1))) { if (!(pv = pvcreate_single(cmd, argv[i], &pp, 1))) {
stack; stack;

2
tools/pvmove.c
View File

@ -664,7 +664,7 @@ int pvmove(struct cmd_context *cmd, int argc, char **argv)
return ECMD_FAILED; return ECMD_FAILED;
} }
unescape_colons_and_at_signs(pv_name, &colon, NULL); dm_unescape_colons_and_at_signs(pv_name, &colon, NULL);
/* Drop any PE lists from PV name */ /* Drop any PE lists from PV name */
if (colon) if (colon)

2
tools/pvremove.c
View File

@ -150,7 +150,7 @@ int pvremove(struct cmd_context *cmd, int argc, char **argv)
} }
for (i = 0; i < argc; i++) { for (i = 0; i < argc; i++) {
unescape_colons_and_at_signs(argv[i], NULL, NULL); dm_unescape_colons_and_at_signs(argv[i], NULL, NULL);
r = pvremove_single(cmd, argv[i], NULL); r = pvremove_single(cmd, argv[i], NULL);
if (r > ret) if (r > ret)
ret = r; ret = r;

4
tools/toollib.c
View File

@ -707,7 +707,7 @@ int process_each_pv(struct cmd_context *cmd, int argc, char **argv,
if (argc) { if (argc) {
log_verbose("Using physical volume(s) on command line"); log_verbose("Using physical volume(s) on command line");
for (; opt < argc; opt++) { for (; opt < argc; opt++) {
unescape_colons_and_at_signs(argv[opt], NULL, &at_sign); dm_unescape_colons_and_at_signs(argv[opt], NULL, &at_sign);
if (at_sign && (at_sign == argv[opt])) { if (at_sign && (at_sign == argv[opt])) {
tagname = at_sign + 1; tagname = at_sign + 1;
@ -1129,7 +1129,7 @@ struct dm_list *create_pv_list(struct dm_pool *mem, struct volume_group *vg, int
dm_list_init(&arg_pvnames); dm_list_init(&arg_pvnames);
for (i = 0; i < argc; i++) { for (i = 0; i < argc; i++) {
unescape_colons_and_at_signs(argv[i], &colon, &at_sign); dm_unescape_colons_and_at_signs(argv[i], &colon, &at_sign);
if (at_sign && (at_sign == argv[i])) { if (at_sign && (at_sign == argv[i])) {
tagname = at_sign + 1; tagname = at_sign + 1;

2
tools/vgsplit.c
View File

@ -395,7 +395,7 @@ int vgsplit(struct cmd_context *cmd, int argc, char **argv)
/* Move PVs across to new structure */ /* Move PVs across to new structure */
for (opt = 0; opt < argc; opt++) { for (opt = 0; opt < argc; opt++) {
unescape_colons_and_at_signs(argv[opt], NULL, NULL); dm_unescape_colons_and_at_signs(argv[opt], NULL, NULL);
if (!move_pv(vg_from, vg_to, argv[opt])) if (!move_pv(vg_from, vg_to, argv[opt]))
goto_bad; goto_bad;
} }