shaba/lvm2
1
0
Fork 0
mirror of git://sourceware.org/git/lvm2.git synced 2024-12-22 17:35:59 +03:00
Code Releases Activity

Add more strict const pointers around config tree

Browse Source 
To have better control were the config tree could be modified use more
const pointers and very carefully downcast them back to non-const
(for config tree merge).
This commit is contained in:
Zdenek Kabelac 2010-12-20 13:12:55 +00:00
parent e5526cb27e
commit 1ea4c6d449
21 changed files with 106 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
WHATS_NEW
View File

@ -1,5 +1,6 @@
Version 2.02.79 -
===================================
Add const for struct config_node usage.
Fix NULL pointer check in error path in clvmd do_command(). (2.02.78)
Fix device.c #include to ensure 64-bit fopen64 use. (2.02.51)
Create /var/run/lvm directory during clvmd initialisation if missing.

4
lib/activate/activate.c
View File

@ -259,8 +259,8 @@ static int _passes_activation_filter(struct cmd_context *cmd,
struct logical_volume *lv)
{
const struct config_node *cn;
struct config_value *cv;
char *str;
const struct config_value *cv;
const char *str;
char path[PATH_MAX];
if (!(cn = find_config_tree_node(cmd, "activation/volume_list"))) {

14
lib/commands/toolcontext.c
View File

@ -204,7 +204,7 @@ static int _process_config(struct cmd_context *cmd)
const char *read_ahead;
struct stat st;
const struct config_node *cn;
struct config_value *cv;
const struct config_value *cv;
/* umask */
cmd->default_settings.umask = find_config_tree_int(cmd,
@ -332,11 +332,11 @@ static int _set_tag(struct cmd_context *cmd, const char *tag)
return 1;
}
static int _check_host_filters(struct cmd_context *cmd, struct config_node *hn,
static int _check_host_filters(struct cmd_context *cmd, const struct config_node *hn,
int *passes)
{
struct config_node *cn;
struct config_value *cv;
const struct config_node *cn;
const struct config_value *cv;
*passes = 1;
@ -561,7 +561,7 @@ static void _destroy_tag_configs(struct cmd_context *cmd)
static int _init_dev_cache(struct cmd_context *cmd)
{
const struct config_node *cn;
struct config_value *cv;
const struct config_value *cv;
init_dev_disable_after_error_count(
find_config_tree_int(cmd, "devices/disable_after_error_count",
@ -793,7 +793,7 @@ static int _init_formats(struct cmd_context *cmd)
if (!is_static() &&
(cn = find_config_tree_node(cmd, "global/format_libraries"))) {
struct config_value *cv;
const struct config_value *cv;
struct format_type *(*init_format_fn) (struct cmd_context *);
void *lib;
@ -959,7 +959,7 @@ static int _init_segtypes(struct cmd_context *cmd)
if (!is_static() &&
(cn = find_config_tree_node(cmd, "global/segment_libraries"))) {
struct config_value *cv;
const struct config_value *cv;
int (*init_multiple_segtypes_fn) (struct cmd_context *,
struct segtype_library *);

49
lib/config/config.c
View File

@ -420,7 +420,7 @@ static int _line_end(struct output_line *outline)
return 1;
}
static int _write_value(struct output_line *outline, struct config_value *v)
static int _write_value(struct output_line *outline, const struct config_value *v)
{
char *buf;
@ -483,7 +483,7 @@ static int _write_config(const struct config_node *n, int only_one,
line_append("%s}", space);
} else {
/* it's a value */
struct config_value *v = n->v;
const struct config_value *v = n->v;
line_append("=");
if (v->next) {
line_append("[");
@ -526,7 +526,7 @@ int write_config_node(const struct config_node *cn, putline_fn putline, void *ba
int write_config_file(struct config_tree *cft, const char *file,
int argc, char **argv)
{
struct config_node *cn;
const struct config_node *cn;
int r = 1;
struct output_line outline;
outline.fp = NULL;
@ -669,6 +669,7 @@ static struct config_value *_type(struct parser *p)
{
/* [+-]{0,1}[0-9]+ | [0-9]*\.[0-9]* | ".*" */
struct config_value *v = _create_value(p->mem);
char *str;
if (!v)
return NULL;
@ -700,9 +701,10 @@ static struct config_value *_type(struct parser *p)
v->type = CFG_STRING;
p->tb++, p->te--; /* strip "'s */
if (!(v->v.str = _dup_tok(p)))
if (!(str = _dup_tok(p)))
return_0;
unescape_double_quotes(v->v.str);
unescape_double_quotes(str);
v->v.str = str;
p->te++;
match(TOK_STRING_ESCAPED);
break;
@ -894,8 +896,8 @@ static char *_dup_tok(struct parser *p)
/*
* utility functions
*/
static struct config_node *_find_config_node(const struct config_node *cn,
const char *path)
static const struct config_node *_find_config_node(const struct config_node *cn,
const char *path)
{
const char *e;
const struct config_node *cn_found = NULL;
@ -932,14 +934,14 @@ static struct config_node *_find_config_node(const struct config_node *cn,
path = e;
}
return (struct config_node *) cn_found;
return cn_found;
}
static struct config_node *_find_first_config_node(const struct config_node *cn1,
const struct config_node *cn2,
const char *path)
static const struct config_node *_find_first_config_node(const struct config_node *cn1,
const struct config_node *cn2,
const char *path)
{
struct config_node *cn;
const struct config_node *cn;
if (cn1 && (cn = _find_config_node(cn1, path)))
return cn;
@ -950,8 +952,8 @@ static struct config_node *_find_first_config_node(const struct config_node *cn1
return NULL;
}
struct config_node *find_config_node(const struct config_node *cn,
const char *path)
const struct config_node *find_config_node(const struct config_node *cn,
const char *path)
{
return _find_config_node(cn, path);
}
@ -1026,7 +1028,7 @@ float find_config_float(const struct config_node *cn, const char *path,
return _find_config_float(cn, NULL, path, fail);
}
struct config_node *find_config_tree_node(struct cmd_context *cmd,
const struct config_node *find_config_tree_node(struct cmd_context *cmd,
const char *path)
{
return _find_first_config_node(cmd->cft_override ? cmd->cft_override->root : NULL, cmd->cft->root, path);
@ -1081,7 +1083,7 @@ static int _find_config_bool(const struct config_node *cn1,
const char *path, int fail)
{
const struct config_node *n = _find_first_config_node(cn1, cn2, path);
struct config_value *v;
const struct config_value *v;
if (!n)
return fail;
@ -1138,7 +1140,7 @@ int get_config_uint64(const struct config_node *cn, const char *path,
}
int get_config_str(const struct config_node *cn, const char *path,
char **result)
const char **result)
{
const struct config_node *n;
@ -1185,7 +1187,7 @@ static void _merge_section(struct config_node *cn1, struct config_node *cn2)
/* Ignore - we don't have any of these yet */
continue;
/* Not already present? */
if (!(oldn = find_config_node(cn1->child, cn->key))) {
if (!(oldn = (struct config_node*)find_config_node(cn1->child, cn->key))) {
_insert_config_node(&cn1->child, cn);
continue;
}
@ -1205,9 +1207,9 @@ static void _merge_section(struct config_node *cn1, struct config_node *cn2)
}
}
static int _match_host_tags(struct dm_list *tags, struct config_node *tn)
static int _match_host_tags(struct dm_list *tags, const struct config_node *tn)
{
struct config_value *tv;
const struct config_value *tv;
const char *str;
for (tv = tn->v; tv; tv = tv->next) {
@ -1229,8 +1231,9 @@ static int _match_host_tags(struct dm_list *tags, struct config_node *tn)
int merge_config_tree(struct cmd_context *cmd, struct config_tree *cft,
struct config_tree *newdata)
{
struct config_node *root = cft->root;
struct config_node *cn, *nextn, *oldn, *tn, *cn2;
const struct config_node *root = cft->root;
struct config_node *cn, *nextn, *oldn, *cn2;
const struct config_node *tn;
for (cn = newdata->root; cn; cn = nextn) {
nextn = cn->sib;
@ -1242,7 +1245,7 @@ int merge_config_tree(struct cmd_context *cmd, struct config_tree *cft,
if (!_match_host_tags(&cmd->tags, tn))
continue;
}
if (!(oldn = find_config_node(root, cn->key))) {
if (!(oldn = (struct config_node *)find_config_node(root, cn->key))) {
_insert_config_node(&cft->root, cn);
/* Remove any "tags" nodes */
for (cn2 = cn->child; cn2; cn2 = cn2->sib) {

14
lib/config/config.h
View File

@ -33,13 +33,13 @@ struct config_value {
union {
int64_t i;
float r;
char *str;
const char *str;
} v;
struct config_value *next; /* for arrays */
};
struct config_node {
char *key;
const char *key;
struct config_node *parent, *sib, *child;
struct config_value *v;
};
@ -78,8 +78,8 @@ int config_file_changed(struct config_tree *cft);
int merge_config_tree(struct cmd_context *cmd, struct config_tree *cft,
struct config_tree *newdata);
struct config_node *find_config_node(const struct config_node *cn,
const char *path);
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);
@ -89,8 +89,8 @@ float find_config_float(const struct config_node *cn, const char *path,
/*
* These versions check an override tree, if present, first.
*/
struct config_node *find_config_tree_node(struct cmd_context *cmd,
const char *path);
const struct config_node *find_config_tree_node(struct cmd_context *cmd,
const char *path);
const char *find_config_tree_str(struct cmd_context *cmd,
const char *path, const char *fail);
int find_config_tree_int(struct cmd_context *cmd, const char *path,
@ -112,7 +112,7 @@ 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,
char **result);
const char **result);
unsigned maybe_config_section(const char *str, unsigned len);

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

@ -541,7 +541,7 @@ void dev_cache_scan(int do_scan)
static int _init_preferred_names(struct cmd_context *cmd)
{
const struct config_node *cn;
struct config_value *v;
const struct config_value *v;
struct dm_pool *scratch = NULL;
char **regex;
unsigned count = 0;

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

@ -68,7 +68,7 @@ static int _read_array(struct pfilter *pf, struct config_tree *cft,
const char *path, void *data)
{
const struct config_node *cn;
struct config_value *cv;
const struct config_value *cv;
if (!(cn = find_config_node(cft->root, path))) {
log_very_verbose("Couldn't find %s array in '%s'",

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

@ -87,10 +87,10 @@ static int _extract_pattern(struct dm_pool *mem, const char *pat,
return 1;
}
static int _build_matcher(struct rfilter *rf, struct config_value *val)
static int _build_matcher(struct rfilter *rf, const struct config_value *val)
{
struct dm_pool *scratch;
struct config_value *v;
const struct config_value *v;
char **regex;
unsigned count = 0;
int i, r = 0;
@ -188,7 +188,7 @@ static void _regex_destroy(struct dev_filter *f)
dm_pool_destroy(rf->mem);
}
struct dev_filter *regex_filter_create(struct config_value *patterns)
struct dev_filter *regex_filter_create(const struct config_value *patterns)
{
struct dm_pool *mem = dm_pool_create("filter regex", 10 * 1024);
struct rfilter *rf;

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

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

4
lib/filters/filter.c
View File

@ -185,8 +185,8 @@ static int _scan_proc_dev(const char *proc, const struct config_node *cn)
int line_maj = 0;
int blocksection = 0;
size_t dev_len = 0;
struct config_value *cv;
char *name;
const struct config_value *cv;
const char *name;
if (!*proc) {

2
lib/format_text/flags.c
View File

@ -138,7 +138,7 @@ int print_flags(uint64_t status, int type, char *buffer, size_t size)
return 1;
}
int read_flags(uint64_t *status, int type, struct config_value *cv)
int read_flags(uint64_t *status, int type, const struct config_value *cv)
{
int f;
uint64_t s = UINT64_C(0);

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

@ -2078,10 +2078,10 @@ static int _add_dir(const char *dir, struct dm_list *dir_list)
}
static int _get_config_disk_area(struct cmd_context *cmd,
struct config_node *cn, struct dm_list *raw_list)
const struct config_node *cn, struct dm_list *raw_list)
{
struct device_area dev_area;
char *id_str;
const char *id_str;
struct id id;
if (!(cn = cn->child)) {
@ -2133,8 +2133,8 @@ static int _get_config_disk_area(struct cmd_context *cmd,
struct format_type *create_text_format(struct cmd_context *cmd)
{
struct format_type *fmt;
struct config_node *cn;
struct config_value *cv;
const struct config_node *cn;
const struct config_value *cv;
struct mda_lists *mda_lists;
if (!(fmt = dm_malloc(sizeof(*fmt))))

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

@ -44,14 +44,14 @@ enum {
};
struct text_vg_version_ops {
int (*check_version) (struct config_tree * cf);
int (*check_version) (const struct config_tree * cf);
struct volume_group *(*read_vg) (struct format_instance * fid,
struct config_tree * cf,
const struct config_tree *cf,
unsigned use_cached_pvs);
void (*read_desc) (struct dm_pool * mem, struct config_tree * cf,
void (*read_desc) (struct dm_pool * mem, const struct config_tree *cf,
time_t *when, char **desc);
const char *(*read_vgname) (const struct format_type *fmt,
struct config_tree *cft,
const struct config_tree *cft,
struct id *vgid, uint64_t *vgstatus,
char **creation_host);
};
@ -59,10 +59,10 @@ struct text_vg_version_ops {
struct text_vg_version_ops *text_vg_vsn1_init(void);
int print_flags(uint64_t status, int type, char *buffer, size_t size);
int read_flags(uint64_t *status, int type, struct config_value *cv);
int read_flags(uint64_t *status, int type, const struct config_value *cv);
char *alloc_printed_tags(struct dm_list *tags);
int read_tags(struct dm_pool *mem, struct dm_list *tags, struct config_value *cv);
int read_tags(struct dm_pool *mem, struct dm_list *tags, const struct config_value *cv);
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);

67
lib/format_text/import_vsn1.c
View File

@ -26,8 +26,8 @@
#include "defaults.h"
typedef int (*section_fn) (struct format_instance * fid, struct dm_pool * mem,
struct volume_group * vg, struct config_node * pvn,
struct config_node * vgn,
struct volume_group * vg, const struct config_node * pvn,
const struct config_node * vgn,
struct dm_hash_table * pv_hash,
struct dm_hash_table * lv_hash,
unsigned *scan_done_once,
@ -54,10 +54,10 @@ static void _invalid_format(const char *str)
* Checks that the config file contains vg metadata, and that it
* we recognise the version number,
*/
static int _check_version(struct config_tree *cft)
static int _check_version(const struct config_tree *cft)
{
struct config_node *cn;
struct config_value *cv;
const struct config_node *cn;
const struct config_value *cv;
/*
* Check the contents field.
@ -106,9 +106,9 @@ static int _is_converting(struct logical_volume *lv)
return 0;
}
static int _read_id(struct id *id, struct config_node *cn, const char *path)
static int _read_id(struct id *id, const struct config_node *cn, const char *path)
{
struct config_value *cv;
const struct config_value *cv;
if (!(cn = find_config_node(cn, path))) {
log_error("Couldn't find uuid.");
@ -129,9 +129,9 @@ static int _read_id(struct id *id, struct config_node *cn, const char *path)
return 1;
}
static int _read_flag_config(struct config_node *n, uint64_t *status, int type)
static int _read_flag_config(const struct config_node *n, uint64_t *status, int type)
{
struct config_node *cn;
const struct config_node *cn;
*status = 0;
if (!(cn = find_config_node(n, "status"))) {
@ -155,8 +155,8 @@ static int _read_flag_config(struct config_node *n, uint64_t *status, int type)
}
static int _read_pv(struct format_instance *fid, struct dm_pool *mem,
struct volume_group *vg, struct config_node *pvn,
struct config_node *vgn __attribute__((unused)),
struct volume_group *vg, const struct config_node *pvn,
const struct config_node *vgn __attribute__((unused)),
struct dm_hash_table *pv_hash,
struct dm_hash_table *lv_hash __attribute__((unused)),
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 pv_list *pvl;
struct config_node *cn;
const struct config_node *cn;
uint64_t size;
if (!(pvl = dm_pool_zalloc(mem, sizeof(*pvl))) ||
@ -293,13 +293,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,
struct logical_volume *lv, struct config_node *sn,
struct logical_volume *lv, const struct config_node *sn,
struct dm_hash_table *pv_hash)
{
uint32_t area_count = 0u;
struct lv_segment *seg;
struct config_node *cn, *sn_child = sn->child;
struct config_value *cv;
const struct config_node *cn, *sn_child = sn->child;
const struct config_value *cv;
uint32_t start_extent, extent_count;
struct segment_type *segtype;
const char *segtype_str;
@ -380,7 +380,7 @@ int text_import_areas(struct lv_segment *seg, const struct config_node *sn,
uint64_t status)
{
unsigned int s;
struct config_value *cv;
const struct config_value *cv;
struct logical_volume *lv1;
struct physical_volume *pv;
const char *seg_name = config_parent_name(sn);
@ -440,10 +440,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,
struct logical_volume *lv, struct config_node *lvn,
struct logical_volume *lv, const struct config_node *lvn,
struct dm_hash_table *pv_hash)
{
struct config_node *sn;
const struct config_node *sn;
int count = 0, seg_count;
for (sn = lvn; sn; sn = sn->sib) {
@ -493,15 +493,15 @@ static int _read_segments(struct dm_pool *mem, struct volume_group *vg,
static int _read_lvnames(struct format_instance *fid __attribute__((unused)),
struct dm_pool *mem,
struct volume_group *vg, struct config_node *lvn,
struct config_node *vgn __attribute__((unused)),
struct volume_group *vg, const struct config_node *lvn,
const struct config_node *vgn __attribute__((unused)),
struct dm_hash_table *pv_hash __attribute__((unused)),
struct dm_hash_table *lv_hash,
unsigned *scan_done_once __attribute__((unused)),
unsigned report_missing_devices __attribute__((unused)))
{
struct logical_volume *lv;
struct config_node *cn;
const struct config_node *cn;
if (!(lv = alloc_lv(mem)))
return_0;
@ -522,7 +522,7 @@ static int _read_lvnames(struct format_instance *fid __attribute__((unused)),
lv->alloc = ALLOC_INHERIT;
if ((cn = find_config_node(lvn, "allocation_policy"))) {
struct config_value *cv = cn->v;
const struct config_value *cv = cn->v;
if (!cv || !cv->v.str) {
log_error("allocation_policy must be a string.");
return 0;
@ -567,8 +567,8 @@ static int _read_lvnames(struct format_instance *fid __attribute__((unused)),
static int _read_lvsegs(struct format_instance *fid __attribute__((unused)),
struct dm_pool *mem,
struct volume_group *vg, struct config_node *lvn,
struct config_node *vgn __attribute__((unused)),
struct volume_group *vg, const struct config_node *lvn,
const struct config_node *vgn __attribute__((unused)),
struct dm_hash_table *pv_hash,
struct dm_hash_table *lv_hash,
unsigned *scan_done_once __attribute__((unused)),
@ -621,13 +621,13 @@ static int _read_lvsegs(struct format_instance *fid __attribute__((unused)),
static int _read_sections(struct format_instance *fid,
const char *section, section_fn fn,
struct dm_pool *mem,
struct volume_group *vg, struct config_node *vgn,
struct volume_group *vg, const struct config_node *vgn,
struct dm_hash_table *pv_hash,
struct dm_hash_table *lv_hash,
int optional,
unsigned *scan_done_once)
{
struct config_node *n;
const struct config_node *n;
/* Only report missing devices when doing a scan */
unsigned report_missing_devices = scan_done_once ? !*scan_done_once : 1;
@ -641,7 +641,8 @@ static int _read_sections(struct format_instance *fid,
}
for (n = n->child; n; n = n->sib) {
if (!fn(fid, mem, vg, n, vgn, pv_hash, lv_hash, scan_done_once, report_missing_devices))
if (!fn(fid, mem, vg, n, vgn, pv_hash, lv_hash,
scan_done_once, report_missing_devices))
return_0;
}
@ -649,10 +650,10 @@ static int _read_sections(struct format_instance *fid,
}
static struct volume_group *_read_vg(struct format_instance *fid,
struct config_tree *cft,
const struct config_tree *cft,
unsigned use_cached_pvs)
{
struct config_node *vgn, *cn;
const struct config_node *vgn, *cn;
struct volume_group *vg;
struct dm_hash_table *pv_hash = NULL, *lv_hash = NULL;
struct dm_pool *mem = dm_pool_create("lvm2 vg_read", VG_MEMPOOL_CHUNK);
@ -738,7 +739,7 @@ static struct volume_group *_read_vg(struct format_instance *fid,
vg->alloc = ALLOC_NORMAL;
if ((cn = find_config_node(vgn, "allocation_policy"))) {
struct config_value *cv = cn->v;
const struct config_value *cv = cn->v;
if (!cv || !cv->v.str) {
log_error("allocation_policy must be a string.");
goto bad;
@ -832,7 +833,7 @@ static struct volume_group *_read_vg(struct format_instance *fid,
}
static void _read_desc(struct dm_pool *mem,
struct config_tree *cft, time_t *when, char **desc)
const struct config_tree *cft, time_t *when, char **desc)
{
const char *d;
unsigned int u = 0u;
@ -848,10 +849,10 @@ static void _read_desc(struct dm_pool *mem,
}
static const char *_read_vgname(const struct format_type *fmt,
struct config_tree *cft, struct id *vgid,
const struct config_tree *cft, struct id *vgid,
uint64_t *vgstatus, char **creation_host)
{
struct config_node *vgn;
const struct config_node *vgn;
struct dm_pool *mem = fmt->cmd->mem;
char *vgname;
int old_suppress;

2
lib/format_text/tags.c
View File

@ -61,7 +61,7 @@ bad:
return_NULL;
}
int read_tags(struct dm_pool *mem, struct dm_list *tags, struct config_value *cv)
int read_tags(struct dm_pool *mem, struct dm_list *tags, const struct config_value *cv)
{
if (cv->type == CFG_EMPTY_ARRAY)
return 1;

4
lib/metadata/lv_manip.c
View File

@ -957,8 +957,8 @@ 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)
{
struct config_value *cv;
char *str;
const struct config_value *cv;
const char *str;
const char *tag_matched;
for (cv = pvmatch->cling_tag_list_cn->v; cv; cv = cv->next) {

2
lib/metadata/segtype.h
View File

@ -70,7 +70,7 @@ struct segtype_handler {
void (*display) (const struct lv_segment * seg);
int (*text_export) (const struct lv_segment * seg,
struct formatter * f);
int (*text_import_area_count) (struct config_node * sn,
int (*text_import_area_count) (const struct config_node * sn,
uint32_t *area_count);
int (*text_import) (struct lv_segment * seg,
const struct config_node * sn,

4
lib/mirror/mirrored.c
View File

@ -72,7 +72,7 @@ static void _mirrored_display(const struct lv_segment *seg)
log_print(" ");
}
static int _mirrored_text_import_area_count(struct config_node *sn, uint32_t *area_count)
static int _mirrored_text_import_area_count(const struct config_node *sn, uint32_t *area_count)
{
if (!get_config_uint32(sn, "mirror_count", area_count)) {
log_error("Couldn't read 'mirror_count' for "
@ -87,7 +87,7 @@ static int _mirrored_text_import(struct lv_segment *seg, const struct config_nod
struct dm_hash_table *pv_hash)
{
const struct config_node *cn;
char *logname = NULL;
const char *logname = NULL;
if (find_config_node(sn, "extents_moved")) {
if (get_config_uint32(sn, "extents_moved",

2
lib/mm/memlock.c
View File

@ -124,7 +124,7 @@ static void _release_memory(void)
static int _maps_line(const struct config_node *cn, lvmlock_t lock,
const char* line, size_t* mstats)
{
struct config_value *cv;
const struct config_value *cv;
long from, to;
int pos, i;
char fr, fw, fx, fp;

4
lib/replicator/replicator.c
View File

@ -89,7 +89,7 @@ static const char _state_txt[NUM_REPLICATOR_STATE][8] = {
static replicator_state_t _get_state(const struct config_node *sn,
const char *path, replicator_state_t def)
{
char *str;
const char *str;
unsigned i;
if (get_config_str(sn, path, &str)) {
@ -118,7 +118,7 @@ static const char _op_mode_txt[NUM_DM_REPLICATOR_MODES][8] = {
static dm_replicator_mode_t _get_op_mode(const struct config_node *sn,
const char *path, dm_replicator_mode_t def)
{
char *str;
const char *str;
unsigned i;
if (get_config_str(sn, path, &str)) {

2
lib/striped/striped.c
View File

@ -57,7 +57,7 @@ static void _striped_display(const struct lv_segment *seg)
log_print(" ");
}
static int _striped_text_import_area_count(struct config_node *sn, uint32_t *area_count)
static int _striped_text_import_area_count(const struct config_node *sn, uint32_t *area_count)
{
if (!get_config_uint32(sn, "stripe_count", area_count)) {
log_error("Couldn't read 'stripe_count' for "