Version 2.02.85 -
===================================
+ Fixing some const cast gcc warnings in the code.
Use char* arithmetic in _text_write(), _text_read() & send_message().
Fix compilation when devmapper is dissabled.
Remove fs_unlock() from lv_suspend error path.
return -1;
}
-void process_message(struct local_client *client, const char *buf, int len,
+void process_message(struct local_client *client, char *buf, int len,
const char *csid)
{
struct clvm_header *inheader;
extern int add_client(struct local_client *new_client);
extern void clvmd_cluster_init_completed(void);
-extern void process_message(struct local_client *client, const char *buf,
+extern void process_message(struct local_client *client, char *buf,
int len, const char *csid);
extern void debuglog(const char *fmt, ... )
__attribute__ ((format(printf, 1, 2)));
{
return 0;
}
-int lv_mirror_percent(struct cmd_context *cmd, struct logical_volume *lv,
+int lv_mirror_percent(struct cmd_context *cmd, const struct logical_volume *lv,
int wait, percent_t *percent, uint32_t *event_nr)
{
return 0;
}
/* FIXME Merge with snapshot_percent */
-int lv_mirror_percent(struct cmd_context *cmd, struct logical_volume *lv,
+int lv_mirror_percent(struct cmd_context *cmd, const struct logical_volume *lv,
int wait, percent_t *percent, uint32_t *event_nr)
{
int r;
* Returns 1 if percent has been set, else 0.
*/
int lv_snapshot_percent(const struct logical_volume *lv, percent_t *percent);
-int lv_mirror_percent(struct cmd_context *cmd, struct logical_volume *lv,
+int lv_mirror_percent(struct cmd_context *cmd, const struct logical_volume *lv,
int wait, percent_t *percent, uint32_t *event_nr);
/*
/*
* build the matcher.
*/
- if (!(rf->engine = dm_regex_create(rf->mem, (const char **) regex,
+ if (!(rf->engine = dm_regex_create(rf->mem, (const char * const*) regex,
count)))
goto_out;
r = 1;
struct logical_volume {
union lvid lvid;
- char *name;
+ const char *name;
struct volume_group *vg;
struct logical_volume *lv,
const char *lv_name_old, const char *lv_name_new)
{
- char *suffix, *new_name;
+ const char *suffix;
+ char *new_name;
size_t len;
/*
int vg_remove(struct volume_group *vg);
int vg_rename(struct cmd_context *cmd, struct volume_group *vg,
const char *new_name);
-int vg_extend(struct volume_group *vg, int pv_count, char **pv_names,
+int vg_extend(struct volume_group *vg, int pv_count, const char *const *pv_names,
struct pvcreate_params *pp);
-int vg_reduce(struct volume_group *vg, char *pv_name);
+int vg_reduce(struct volume_group *vg, const char *pv_name);
int vg_change_tag(struct volume_group *vg, const char *tag, int add_tag);
int vg_split_mdas(struct cmd_context *cmd, struct volume_group *vg_from,
struct volume_group *vg_to);
uint32_t lv_type);
const char *get_pvmove_pvname_from_lv(struct logical_volume *lv);
const char *get_pvmove_pvname_from_lv_mirr(struct logical_volume *lv_mirr);
-percent_t copy_percent(struct logical_volume *lv_mirr);
+percent_t copy_percent(const struct logical_volume *lv_mirr);
struct dm_list *lvs_using_lv(struct cmd_context *cmd, struct volume_group *vg,
struct logical_volume *lv);
int vg_has_unknown_segments(const struct volume_group *vg);
struct vgcreate_params {
- char *vg_name;
+ const char *vg_name;
uint32_t extent_size;
size_t max_pv;
size_t max_lv;
* - pp: parameters to pass to implicit pvcreate; if NULL, do not pvcreate
*
*/
-int vg_extend(struct volume_group *vg, int pv_count, char **pv_names,
+int vg_extend(struct volume_group *vg, int pv_count, const char *const *pv_names,
struct pvcreate_params *pp)
{
int i;
+ char *pv_name;
if (_vg_bad_status_bits(vg, RESIZEABLE_VG))
return 0;
/* attach each pv */
for (i = 0; i < pv_count; i++) {
- unescape_colons_and_at_signs(pv_names[i], NULL, NULL);
- if (!vg_extend_single_pv(vg, pv_names[i], pp))
- goto bad;
+ if (!(pv_name = dm_strdup(pv_names[i]))) {
+ log_error("Failed to duplicate pv name %s.", pv_names[i]);
+ return 0;
+ }
+ unescape_colons_and_at_signs(pv_name, NULL, NULL);
+ if (!vg_extend_single_pv(vg, pv_name, pp)) {
+ log_error("Unable to add physical volume '%s' to "
+ "volume group '%s'.", pv_name, vg->name);
+ dm_free(pv_name);
+ return 0;
+ }
+ dm_free(pv_name);
}
/* FIXME Decide whether to initialise and add new mdahs to format instance */
return 1;
-
- bad:
- log_error("Unable to add physical volume '%s' to "
- "volume group '%s'.", pv_names[i], vg->name);
- return 0;
}
/* FIXME: use this inside vgreduce_single? */
-int vg_reduce(struct volume_group *vg, char *pv_name)
+int vg_reduce(struct volume_group *vg, const char *pv_name)
{
struct physical_volume *pv;
struct pv_list *pvl;
{
struct lv_list *lvl1, *lvl2;
struct pv_list *pvl;
- char *name1, *name2;
+ const char *name1, *name2;
if (lvs_in_vg_activated(vg_from)) {
log_error("Logical volumes in \"%s\" must be inactive",
return lvs;
}
-percent_t copy_percent(struct logical_volume *lv_mirr)
+percent_t copy_percent(const struct logical_volume *lv_mirr)
{
uint32_t numerator = 0u, denominator = 0u;
struct lv_segment *seg;
int in_sync)
{
struct logical_volume *log_lv;
- const char *suffix, *c;
- char *lv_name;
+ const char *suffix, *lv_name;
+ char *tmp_name;
size_t len;
struct lv_segment *seg;
strstr(seg_lv(seg, 0)->name, MIRROR_SYNC_LAYER)) {
lv_name = lv->name;
suffix = "_mlogtmp_%d";
- } else if ((c = strstr(lv->name, MIRROR_SYNC_LAYER))) {
- len = c - lv->name + 1;
- if (!(lv_name = alloca(len)) ||
- !dm_snprintf(lv_name, len, "%s", lv->name)) {
+ } else if ((lv_name = strstr(lv->name, MIRROR_SYNC_LAYER))) {
+ len = lv_name - lv->name + 1;
+ if (!(tmp_name = alloca(len)) ||
+ !dm_snprintf(tmp_name, len, "%s", lv->name)) {
log_error("mirror log name allocation failed");
return 0;
}
+ lv_name = tmp_name;
suffix = "_mlog";
} else {
lv_name = lv->name;
suffix = "_mlog";
}
- if (!(log_lv = _create_mirror_log(lv, ah, alloc,
- (const char *) lv_name, suffix))) {
+ if (!(log_lv = _create_mirror_log(lv, ah, alloc, lv_name, suffix))) {
log_error("Failed to create mirror log.");
return NULL;
}
static percent_t _copy_percent(const struct logical_volume *lv) {
percent_t perc;
- if (!lv_mirror_percent(lv->vg->cmd, (struct logical_volume *) lv,
- 0, &perc, NULL))
+ if (!lv_mirror_percent(lv->vg->cmd, lv, 0, &perc, NULL))
perc = PERCENT_INVALID;
return perc;
}
struct dm_report_field *field,
const void *data, void *private __attribute__((unused)))
{
- return dm_report_field_string(rh, field, (const char **) data);
+ return dm_report_field_string(rh, field, (const char * const *) data);
}
static int _dev_name_disp(struct dm_report *rh, struct dm_pool *mem __attribute__((unused)),
char *repstr, *lvname;
size_t len;
- if (lv_is_visible(lv)) {
- repstr = lv->name;
- return dm_report_field_string(rh, field, (const char **) &repstr);
- }
+ if (lv_is_visible(lv))
+ return dm_report_field_string(rh, field, &lv->name);
len = strlen(lv->name) + 3;
if (!(repstr = dm_pool_zalloc(mem, len))) {
{
char *repstr = NULL;
- if (!(repstr = id_format_and_copy(mem, (struct id *)data)))
+ if (!(repstr = id_format_and_copy(mem, data)))
return_0;
dm_report_field_set_value(field, repstr, NULL);
struct dm_report_field *field,
const void *data, void *private __attribute__((unused)))
{
- struct logical_volume *lv = (struct logical_volume *) data;
+ const struct logical_volume *lv = (const struct logical_volume *) data;
percent_t percent;
uint64_t *sortval;
char *repstr;
static struct volume_group _dummy_vg = {
.fid = &_dummy_fid,
- .name = (char *) "",
+ .name = "",
.system_id = (char *) "",
.pvs = { &(_dummy_vg.pvs), &(_dummy_vg.pvs) },
.lvs = { &(_dummy_vg.lvs), &(_dummy_vg.lvs) },
{
int i, tot;
- static unsigned group_size[] = { 6, 4, 4, 4, 4, 4, 6 };
+ static const unsigned group_size[] = { 6, 4, 4, 4, 4, 4, 6 };
assert(ID_LEN == 32);
}
pvcreate_params_set_defaults(&pp);
- if (!vg_extend(vg, 1, (char **) &device, &pp)) {
+ if (!vg_extend(vg, 1, &device, &pp)) {
unlock_vg(vg->cmd, VG_ORPHANS);
return -1;
}
if (!vg_check_write_mode(vg))
return -1;
- if (!vg_reduce(vg, (char *)device))
+ if (!vg_reduce(vg, device))
return -1;
return 0;
}
{
int argc = *pargc;
char **argv = *pargv, *ptr;
- char *vg_name;
+ const char *vg_name;
lp->lv_name = arg_str_value(cmd, name_ARG, NULL);
struct volume_group _free_vg = {
.cmd = cmd,
- .name = (char *)"",
+ .name = "",
};
if (!(_free_vg.vgmem = dm_pool_create("_free_vg", 10240)))
struct logical_volume _free_logical_volume = {
.vg = vg ?: &_free_vg,
- .name = (char *) "",
+ .name = "",
.snapshot = NULL,
.status = VISIBLE_LV,
.major = -1,
/*
* Strip dev_dir if present
*/
-char *skip_dev_dir(struct cmd_context *cmd, const char *vg_name,
+const char *skip_dev_dir(struct cmd_context *cmd, const char *vg_name,
unsigned *dev_dir_found)
{
const char *dmdir = dm_dir();
*layer) {
log_error("skip_dev_dir: Couldn't split up device name %s",
vg_name);
- return (char *) vg_name;
+ return vg_name;
}
vglv_sz = strlen(vgname) + strlen(lvname) + 2;
if (!(vglv = dm_pool_alloc(cmd->mem, vglv_sz)) ||
*lvname ? "/" : "",
lvname) < 0) {
log_error("vg/lv string alloc failed");
- return (char *) vg_name;
+ return vg_name;
}
return vglv;
}
} else if (dev_dir_found)
*dev_dir_found = 0;
- return (char *) vg_name;
+ return vg_name;
}
/*
*/
char *default_vgname(struct cmd_context *cmd)
{
- char *vg_path;
+ const char *vg_path;
/* Take default VG from environment? */
vg_path = getenv("LVM_VG_NAME");
char *default_vgname(struct cmd_context *cmd);
const char *extract_vgname(struct cmd_context *cmd, const char *lv_name);
-char *skip_dev_dir(struct cmd_context *cmd, const char *vg_name,
- unsigned *dev_dir_found);
+const char *skip_dev_dir(struct cmd_context *cmd, const char *vg_name,
+ unsigned *dev_dir_found);
/*
* Builds a list of pv's from the names in argv. Used in
int vgcfgrestore(struct cmd_context *cmd, int argc, char **argv)
{
- char *vg_name = NULL;
+ const char *vg_name = NULL;
if (argc == 1) {
vg_name = skip_dev_dir(cmd, argv[0], NULL);
}
/* attach the pv's */
- if (!vg_extend(vg, argc, argv, &pp))
+ if (!vg_extend(vg, argc, (const char* const*)argv, &pp))
goto_bad;
if (vp_new.max_lv != vg->max_lv)
int vgextend(struct cmd_context *cmd, int argc, char **argv)
{
- char *vg_name;
+ const char *vg_name;
struct volume_group *vg = NULL;
int r = ECMD_FAILED;
struct pvcreate_params pp;
}
/* extend vg */
- if (!vg_extend(vg, argc, argv, &pp))
+ if (!vg_extend(vg, argc, (const char* const*)argv, &pp))
goto_bad;
if (arg_count(cmd, metadataignore_ARG) &&
int vgmerge(struct cmd_context *cmd, int argc, char **argv)
{
- char *vg_name_to, *vg_name_from;
+ const char *vg_name_to, *vg_name_from;
int opt = 0;
int ret = 0, ret_max = 0;
int vgreduce(struct cmd_context *cmd, int argc, char **argv)
{
struct volume_group *vg;
- char *vg_name;
+ const char *vg_name;
int ret = ECMD_FAILED;
int fixed = 1;
int repairing = arg_count(cmd, removemissing_ARG);
int found_id = 0;
struct dm_list *vgids;
struct str_list *sl;
- char *vg_name_new;
+ const char *vg_name_new;
const char *vgid = NULL, *vg_name, *vg_name_old;
char old_path[NAME_LEN], new_path[NAME_LEN];
struct volume_group *vg = NULL;
{
struct vgcreate_params vp_new;
struct vgcreate_params vp_def;
- char *vg_name_from, *vg_name_to;
+ const char *vg_name_from, *vg_name_to;
struct volume_group *vg_to = NULL, *vg_from = NULL;
int opt;
int existing_vg = 0;