shaba/lvm2
1
0
Fork 0
mirror of git://sourceware.org/git/lvm2.git synced 2024-10-27 10:25:13 +03:00
Code Releases Activity

quotes around names in output

Browse Source
This commit is contained in:
Heinz Mauelshagen 2002-01-30 15:04:48 +00:00
parent 851866d2fc
commit 08907484f5
24 changed files with 239 additions and 218 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lib/display/display.c
View File

@ -511,7 +511,7 @@ void vgdisplay_short(struct volume_group *vg)
display_size((vg->extent_count - vg->free_count) * vg->extent_size /
2, SIZE_SHORT);
s3 = display_size(vg->free_count * vg->extent_size / 2, SIZE_SHORT);
log_print("%s %-9s [%-9s used / %s free]", vg->name,
log_print("\"%s\" %-9s [%-9s used / %s free]", vg->name,
/********* FIXME if "open" print "/used" else print "/idle"??? ******/
s1, s2, s3);
dbg_free(s1);

6
tools/archive.c
View File

@ -89,9 +89,9 @@ int archive(struct volume_group *vg)
return 1;
}
log_verbose("Archiving volume group %s metadata.", vg->name);
log_verbose("Archiving volume group \"%s\" metadata.", vg->name);
if (!__archive(vg)) {
log_error("Volume group %s metadata archive failed.",
log_error("Volume group \"%s\" metadata archive failed.",
vg->name);
return 0;
}
@ -149,7 +149,7 @@ static int __backup(struct volume_group *vg)
return 0;
}
log_verbose("Creating volume group backup %s", name);
log_verbose("Creating volume group backup \"%s\"", name);
if (!(tf = text_format_create(vg->cmd, name, the_um))) {
stack;

50
tools/lvchange.c
View File

@ -50,19 +50,19 @@ static int lvchange_single(struct logical_volume *lv)
if ((lv->vg->status & PARTIAL_VG) &&
(arg_count(contiguous_ARG) || arg_count(permission_ARG) ||
arg_count(readahead_ARG))) {
log_error("Only -a permitted with partial volume group %s",
log_error("Only -a permitted with partial volume group \"%s\"",
lv->vg->name);
return EINVALID_CMD_LINE;
}
if (lv->status & SNAPSHOT_ORG) {
log_error("Can't change logical volume %s under snapshot",
log_error("Can't change logical volume \"%s\" under snapshot",
lv->name);
return ECMD_FAILED;
}
if (lv->status & SNAPSHOT) {
log_error("Can't change snapshot logical volume %s", lv->name);
log_error("Can't change snapshot logical volume \"%s\"", lv->name);
return ECMD_FAILED;
}
@ -91,7 +91,7 @@ static int lvchange_single(struct logical_volume *lv)
}
if (doit)
log_print("Logical volume %s changed", lv->name);
log_print("Logical volume \"%s\" changed", lv->name);
/* availability change */
if (arg_count(available_ARG))
@ -108,31 +108,31 @@ static int lvchange_permission(struct logical_volume *lv)
lv_access = arg_int_value(permission_ARG, 0);
if ((lv_access & LVM_WRITE) && (lv->status & LVM_WRITE)) {
log_error("Logical volume %s is already writable", lv->name);
log_error("Logical volume \"%s\" is already writable", lv->name);
return 0;
}
if (!(lv_access & LVM_WRITE) && !(lv->status & LVM_WRITE)) {
log_error("Logical volume %s is already read only", lv->name);
log_error("Logical volume \"%s\" is already read only", lv->name);
return 0;
}
if (lv_access & LVM_WRITE) {
lv->status |= LVM_WRITE;
log_verbose("Setting logical volume %s read/write", lv->name);
log_verbose("Setting logical volume \"%s\" read/write", lv->name);
} else {
lv->status &= ~LVM_WRITE;
log_verbose("Setting logical volume %s read-only", lv->name);
log_verbose("Setting logical volume \"%s\" read-only", lv->name);
}
log_very_verbose("Updating logical volume %s on disk(s)", lv->name);
log_very_verbose("Updating logical volume \"%s\" on disk(s)", lv->name);
if (!fid->ops->vg_write(fid, lv->vg))
return 0;
backup(lv->vg);
log_very_verbose("Updating permissions for %s in kernel", lv->name);
log_very_verbose("Updating permissions for \"%s\" in kernel", lv->name);
if (!lv_update_write_access(lv))
return 0;
@ -148,33 +148,33 @@ static int lvchange_availability(struct logical_volume *lv)
activate = 1;
if ((active = lv_active(lv)) < 0) {
log_error("Unable to determine status of %s", lv->name);
log_error("Unable to determine status of \"%s\"", lv->name);
return 0;
}
if (activate && active) {
log_verbose("Logical volume %s is already active", lv->name);
log_verbose("Logical volume \"%s\" is already active", lv->name);
return 0;
}
if (!activate && !active) {
log_verbose("Logical volume %s is already inactive", lv->name);
log_verbose("Logical volume \"%s\" is already inactive", lv->name);
return 0;
}
if (activate & lv_suspended(lv)) {
log_verbose("Reactivating logical volume %s", lv->name);
log_verbose("Reactivating logical volume \"%s\"", lv->name);
if (!lv_reactivate(lv))
return 0;
return 1;
}
if (activate) {
log_verbose("Activating logical volume %s", lv->name);
log_verbose("Activating logical volume \"%s\"", lv->name);
if (!lv_activate(lv))
return 0;
} else {
log_verbose("Deactivating logical volume %s", lv->name);
log_verbose("Deactivating logical volume \"%s\"", lv->name);
if (!lv_deactivate(lv))
return 0;
}
@ -191,14 +191,14 @@ static int lvchange_contiguous(struct logical_volume *lv)
if ((lv_allocation & ALLOC_CONTIGUOUS) &&
(lv->status & ALLOC_CONTIGUOUS)) {
log_error("Allocation policy of logical volume %s is "
log_error("Allocation policy of logical volume \"%s\" is "
"already contiguous", lv->name);
return 0;
}
if (!(lv_allocation & ALLOC_CONTIGUOUS) &&
!(lv->status & ALLOC_CONTIGUOUS)) {
log_error("Allocation policy of logical volume %s is already"
log_error("Allocation policy of logical volume \"%s\" is already"
" not contiguous", lv->name);
return 0;
}
@ -206,21 +206,21 @@ static int lvchange_contiguous(struct logical_volume *lv)
/******** FIXME lv_check_contiguous?
if ((lv_allocation & ALLOC_CONTIGUOUS)
&& (ret = lv_check_contiguous(vg, lv_index + 1)) == FALSE) {
log_error("No contiguous logical volume %s", lv->name);
log_error("No contiguous logical volume \"%s\"", lv->name);
return 0;
*********/
if (lv_allocation & ALLOC_CONTIGUOUS) {
lv->status |= ALLOC_CONTIGUOUS;
log_verbose("Setting contiguous allocation policy for %s",
log_verbose("Setting contiguous allocation policy for \"%s\"",
lv->name);
} else {
lv->status &= ~ALLOC_CONTIGUOUS;
log_verbose("Removing contiguous allocation policy for %s",
log_verbose("Removing contiguous allocation policy for \"%s\"",
lv->name);
}
log_verbose("Updating logical volume %s on disk(s)", lv->name);
log_verbose("Updating logical volume \"%s\" on disk(s)", lv->name);
if (!fid->ops->vg_write(fid, lv->vg))
return 0;
@ -244,15 +244,15 @@ static int lvchange_readahead(struct logical_volume *lv)
********/
if (lv->read_ahead == read_ahead) {
log_error("Read ahead is already %u for %s",
log_error("Read ahead is already %u for \"%s\"",
read_ahead, lv->name);
return 0;
}
lv->read_ahead = read_ahead;
log_verbose("Setting read ahead to %u for %s", read_ahead, lv->name);
log_verbose("Setting read ahead to %u for \"%s\"", read_ahead, lv->name);
log_verbose("Updating logical volume %s on disk(s)", lv->name);
log_verbose("Updating logical volume \"%s\" on disk(s)", lv->name);
if (!fid->ops->vg_write(fid, lv->vg))
return 0;

23
tools/lvcreate.c
View File

@ -103,7 +103,8 @@ int lvcreate(int argc, char **argv)
return EINVALID_CMD_LINE;
if (strcmp(vg_name, argv[0])) {
log_error("Inconsistent volume group names "
"given: %s and %s", vg_name, argv[0]);
"given: \"%s\" and \"%s\"",
vg_name, argv[0]);
return EINVALID_CMD_LINE;
}
}
@ -116,25 +117,25 @@ int lvcreate(int argc, char **argv)
lv_name = st + 1;
/* does VG exist? */
log_verbose("Finding volume group %s", vg_name);
log_verbose("Finding volume group \"%s\"", vg_name);
if (!(vg = fid->ops->vg_read(fid, vg_name))) {
log_error("Volume group %s doesn't exist", vg_name);
log_error("Volume group \"%s\" doesn't exist", vg_name);
return ECMD_FAILED;
}
if (vg->status & EXPORTED_VG) {
log_error("Volume group %s is exported", vg_name);
log_error("Volume group \"%s\" is exported", vg_name);
return ECMD_FAILED;
}
if (!(vg->status & LVM_WRITE)) {
log_error("Volume group %s is read-only", vg_name);
log_error("Volume group \"%s\" is read-only", vg_name);
return ECMD_FAILED;
}
if (lv_name && find_lv_in_vg(vg, lv_name)) {
log_error("Logical volume %s already exists in "
"volume group %s", lv_name, vg_name);
log_error("Logical volume \"%s\" already exists in "
"volume group \"%s\"", lv_name, vg_name);
return ECMD_FAILED;
}
@ -218,7 +219,7 @@ int lvcreate(int argc, char **argv)
backup(vg);
log_print("Logical volume %s created", lv->name);
log_print("Logical volume \"%s\" created", lv->name);
if (!lv_activate(lv))
return ECMD_FAILED;
@ -239,10 +240,10 @@ int lvcreate(int argc, char **argv)
return ECMD_FAILED;
}
log_verbose("Zeroing start of logical volume %s", name);
log_verbose("Zeroing start of logical volume \"%s\"", name);
if (!(dev = dev_cache_get(name, NULL))) {
log_error("%s not found: device not zeroed", name);
log_error("\"%s\" not found: device not zeroed", name);
return ECMD_FAILED;
}
if (!(dev_open(dev, O_WRONLY)))
@ -251,7 +252,7 @@ int lvcreate(int argc, char **argv)
dev_close(dev);
} else
log_print("WARNING: %s not zeroed", lv->name);
log_print("WARNING: \"%s\" not zeroed", lv->name);
return 0;
}

18
tools/lvremove.c
View File

@ -40,18 +40,18 @@ static int lvremove_single(struct logical_volume *lv)
vg = lv->vg;
if (!(vg->status & LVM_WRITE)) {
log_error("Volume group %s is read-only", vg->name);
log_error("Volume group \"%s\" is read-only", vg->name);
return ECMD_FAILED;
}
if (lv->status & SNAPSHOT_ORG) {
log_error("Can't remove logical volume %s under snapshot",
log_error("Can't remove logical volume \"%s\" under snapshot",
lv->name);
return ECMD_FAILED;
}
if (lv_open_count(lv) > 0) {
log_error("Can't remove open logical volume %s", lv->name);
log_error("Can't remove open logical volume \"%s\"", lv->name);
return ECMD_FAILED;
}
@ -59,9 +59,9 @@ static int lvremove_single(struct logical_volume *lv)
if (active && !arg_count(force_ARG)) {
if (yes_no_prompt
("Do you really want to remove active logical volume %s? "
("Do you really want to remove active logical volume \"%s\"? "
"[y/n]: ", lv->name) == 'n') {
log_print("Logical volume %s not removed", lv->name);
log_print("Logical volume \"%s\" not removed", lv->name);
return 0;
}
}
@ -70,12 +70,12 @@ static int lvremove_single(struct logical_volume *lv)
return ECMD_FAILED;
if (active && !lv_deactivate(lv)) {
log_error("Unable to deactivate logical volume %s", lv->name);
log_error("Unable to deactivate logical volume \"%s\"", lv->name);
}
log_verbose("Releasing logical volume %s", lv->name);
log_verbose("Releasing logical volume \"%s\"", lv->name);
if (!lv_remove(vg, lv)) {
log_error("Error releasing logical volume %s", lv->name);
log_error("Error releasing logical volume \"%s\"", lv->name);
return ECMD_FAILED;
}
@ -85,6 +85,6 @@ static int lvremove_single(struct logical_volume *lv)
backup(vg);
log_print("logical volume %s successfully removed", lv->name);
log_print("logical volume \"%s\" successfully removed", lv->name);
return 0;
}

28
tools/lvrename.c
View File

@ -49,7 +49,7 @@ int lvrename(int argc, char **argv)
(vg_name_new = extract_vgname(fid, lv_name_new)) &&
strcmp(vg_name, vg_name_new)) {
log_error("Logical volume names must "
"have the same volume group (%s or %s)",
"have the same volume group (\"%s\" or \"%s\")",
vg_name, vg_name_new);
return EINVALID_CMD_LINE;
}
@ -74,7 +74,7 @@ int lvrename(int argc, char **argv)
}
if (!is_valid_chars(lv_name_new)) {
log_error("New logical volume name %s has invalid characters",
log_error("New logical volume name \"%s\" has invalid characters",
lv_name_new);
return EINVALID_CMD_LINE;
}
@ -84,31 +84,31 @@ int lvrename(int argc, char **argv)
return EINVALID_CMD_LINE;
}
log_verbose("Checking for existing volume group %s", vg_name);
log_verbose("Checking for existing volume group \"%s\"", vg_name);
if (!(vg = fid->ops->vg_read(fid, vg_name))) {
log_error("Volume group %s doesn't exist", vg_name);
log_error("Volume group \"%s\" doesn't exist", vg_name);
return ECMD_FAILED;
}
if (vg->status & EXPORTED_VG) {
log_error("Volume group %s is exported", vg->name);
log_error("Volume group \"%s\" is exported", vg->name);
return ECMD_FAILED;
}
if (!(vg->status & LVM_WRITE)) {
log_error("Volume group %s is read-only", vg_name);
log_error("Volume group \"%s\" is read-only", vg_name);
return ECMD_FAILED;
}
if (find_lv_in_vg(vg, lv_name_new)) {
log_error("Logical volume %s already exists in "
"volume group %s", lv_name_new, vg_name);
log_error("Logical volume \"%s\" already exists in "
"volume group \"%s\"", lv_name_new, vg_name);
return ECMD_FAILED;
}
if (!(lvl = find_lv_in_vg(vg, lv_name_old))) {
log_error("Existing logical volume %s not found in "
"volume group %s", lv_name_old, vg_name);
log_error("Existing logical volume \"%s\" not found in "
"volume group \"%s\"", lv_name_old, vg_name);
return ECMD_FAILED;
}
@ -118,12 +118,12 @@ int lvrename(int argc, char **argv)
return ECMD_FAILED;
if ((active = lv_active(lv)) < 0) {
log_error("Unable to determine status of %s", lv->name);
log_error("Unable to determine status of \"%s\"", lv->name);
return ECMD_FAILED;
}
if (active && !lv_suspend(lv)) {
log_error("Failed to suspend %s", lv->name);
log_error("Failed to suspend \"%s\"", lv->name);
return ECMD_FAILED;
}
@ -145,8 +145,8 @@ int lvrename(int argc, char **argv)
backup(lv->vg);
log_print("Renamed %s to %s in volume group %s%s",
lv_name_old, lv_name_new, fid->cmd->dev_dir, vg_name);
log_print("Renamed \"%s\" to \"%s\" in volume group \"%s\"",
lv_name_old, lv_name_new, vg_name);
return 0;
}

37
tools/pvchange.c
View File

@ -53,7 +53,7 @@ int pvchange(int argc, char **argv)
for (; opt < argc; opt++) {
pv_name = argv[opt];
if (!(pv = fid->ops->pv_read(fid, pv_name))) {
log_error("Failed to read physical volume %s",
log_error("Failed to read physical volume \"%s\"",
pv_name);
continue;
}
@ -73,8 +73,10 @@ int pvchange(int argc, char **argv)
}
}
log_print("%d physical volume(s) changed / %d physical volume(s) "
"not changed", done, total - done);
log_print("%d physical volume%s changed / %d physical volume%s "
"not changed",
done, done > 1 ? "s" : "",
total - done, total - done > 1 ? "s" : "");
return 0;
}
@ -90,25 +92,26 @@ int pvchange_single(struct physical_volume *pv)
/* If in a VG, must change using volume group. */
if (*pv->vg_name) {
log_verbose("Finding volume group of physical volume %s",
log_verbose("Finding volume group of physical volume \"%s\"",
pv_name);
if (!(vg = fid->ops->vg_read(fid, pv->vg_name))) {
log_error("Unable to find volume group of %s", pv_name);
log_error("Unable to find volume group of \"%s\"",
pv_name);
return 0;
}
if (vg->status & EXPORTED_VG) {
log_error("Volume group %s is exported", vg->name);
log_error("Volume group \"%s\" is exported", vg->name);
return ECMD_FAILED;
}
if (!(vg->status & LVM_WRITE)) {
log_error("Volume group %s is read-only", vg->name);
log_error("Volume group \"%s\" is read-only", vg->name);
return ECMD_FAILED;
}
if (!(pvl = find_pv_in_vg(vg, pv_name))) {
log_error("Unable to find %s in volume group %s",
log_error("Unable to find \"%s\" in volume group \"%s\"",
pv_name, vg->name);
return 0;
}
@ -119,42 +122,42 @@ int pvchange_single(struct physical_volume *pv)
/* change allocatability for a PV */
if (allocatable && (pv->status & ALLOCATABLE_PV)) {
log_error("Physical volume %s is already allocatable", pv_name);
log_error("Physical volume \"%s\" is already allocatable", pv_name);
return 0;
}
if (!allocatable && !(pv->status & ALLOCATABLE_PV)) {
log_error("Physical volume %s is already unallocatable",
log_error("Physical volume \"%s\" is already unallocatable",
pv_name);
return 0;
}
if (allocatable) {
log_verbose("Setting physical volume %s allocatable", pv_name);
log_verbose("Setting physical volume \"%s\" allocatable", pv_name);
pv->status |= ALLOCATABLE_PV;
} else {
log_verbose("Setting physical volume %s NOT allocatable",
log_verbose("Setting physical volume \"%s\" NOT allocatable",
pv_name);
pv->status &= ~ALLOCATABLE_PV;
}
log_verbose("Updating physical volume %s", pv_name);
log_verbose("Updating physical volume \"%s\"", pv_name);
if (*pv->vg_name) {
if (!(fid->ops->vg_write(fid,vg))) {
log_error("Failed to store physical volume %s in "
"volume group %s", pv_name, vg->name);
log_error("Failed to store physical volume \"%s\" in "
"volume group \"%s\"", pv_name, vg->name);
return 0;
}
backup(vg);
} else {
if (!(fid->ops->pv_write(fid, pv))) {
log_error("Failed to store physical volume %s",
log_error("Failed to store physical volume \"%s\"",
pv_name);
return 0;
}
}
log_print("Physical volume %s changed", pv_name);
log_print("Physical volume \"%s\" changed", pv_name);
return 1;
}

28
tools/pvcreate.c
View File

@ -21,7 +21,7 @@
#include "tools.h"
const char _really_init[] =
"Really INITIALIZE physical volume %s of volume group %s [y/n]? ";
"Really INITIALIZE physical volume \"%s\" of volume group \"%s\" [y/n]? ";
/*
* See if we may pvcreate on this device.
@ -46,23 +46,24 @@ static int pvcreate_check(const char *name)
/* Allow partial & exported VGs to be destroyed. */
/* we must have -ff to overwrite a non orphan */
if (arg_count(force_ARG) < 2) {
log_error("Can't initialize physical volume %s of "
"volume group %s without -ff", name, pv->vg_name);
log_error("Can't initialize physical volume \"%s\" of "
"volume group \"%s\" without -ff", name, pv->vg_name);
return 0;
}
/* prompt */
if (!arg_count(yes_ARG) &&
yes_no_prompt(_really_init, name, pv->vg_name) == 'n') {
log_print("Physical volume %s not initialized", name);
log_print("Physical volume \"%s\" not initialized", name);
return 0;
}
if (arg_count(force_ARG)) {
log_print("WARNING: Forcing physical volume creation on "
"%s%s%s", name,
pv->vg_name[0] ? " of volume group " : "",
pv->vg_name[0] ? pv->vg_name : "");
"%s%s%s%s", name,
pv->vg_name[0] ? " of volume group \"" : "",
pv->vg_name[0] ? pv->vg_name : "",
pv->vg_name[0] ? "\"" : "");
}
return 1;
@ -80,7 +81,7 @@ static void pvcreate_single(const char *pv_name)
if (!id_read_format(&id, uuid))
return;
if ((dev = uuid_map_lookup(the_um, &id))) {
log_error("uuid %s already in use on %s", uuid,
log_error("uuid %s already in use on \"%s\"", uuid,
dev_name(dev));
return;
}
@ -91,20 +92,21 @@ static void pvcreate_single(const char *pv_name)
return;
if (!(pv = pv_create(fid, pv_name, idp))) {
log_err("Failed to setup physical volume %s", pv_name);
log_err("Failed to setup physical volume \"%s\"", pv_name);
return;
}
log_verbose("Set up physical volume for %s with %" PRIu64 " sectors",
log_verbose("Set up physical volume for \"%s\" with %" PRIu64
" sectors",
pv_name, pv->size);
log_verbose("Writing physical volume data to disk %s", pv_name);
log_verbose("Writing physical volume data to disk \"%s\"", pv_name);
if (!(fid->ops->pv_write(fid, pv))) {
log_error("Failed to write physical volume %s", pv_name);
log_error("Failed to write physical volume \"%s\"", pv_name);
return;
}
log_print("Physical volume %s successfully created", pv_name);
log_print("Physical volume \"%s\" successfully created", pv_name);
}
int pvcreate(int argc, char **argv)

15
tools/pvdisplay.c
View File

@ -39,7 +39,8 @@ int pvdisplay(int argc, char **argv)
for (; opt < argc; opt++) {
if (!(pv = fid->ops->pv_read(fid, argv[opt]))) {
log_error("Failed to read physical volume %s",
log_error("Failed to read physical "
"volume \"%s\"",
argv[opt]);
continue;
}
@ -71,14 +72,13 @@ void pvdisplay_single(struct physical_volume *pv)
if (arg_count(short_ARG)) {
sz = display_size(size / 2, SIZE_SHORT);
log_print("Device '%s' has a capacity of %s", pv_name, sz);
log_print("Device \"%s\" has a capacity of %s", pv_name, sz);
dbg_free(sz);
return;
}
if (pv->status & EXPORTED_VG)
log_print("Physical volume '%s' of volume group '%s' "
log_print("Physical volume \"%s\" of volume group \"%s\" "
"is exported" , pv_name, pv->vg_name);
/********* FIXME
@ -86,7 +86,7 @@ void pvdisplay_single(struct physical_volume *pv)
*********/
if (!pv->vg_name) {
log_print ( "'%s' is a new physical volume of %s",
log_print ( "\"%s\" is a new physical volume of \"%s\"",
pv_name, ( sz = display_size ( size / 2,
SIZE_SHORT)));
dbg_free(sz);
@ -118,12 +118,13 @@ void pvdisplay_single(struct physical_volume *pv)
if (!(pv->pe = pv_read_pe(pv_name, pv)))
goto pvdisplay_device_out;
if (!(lvs = pv_read_lvs(pv))) {
log_error("Failed to read LVs on %s", pv->pv_name);
log_error("Failed to read LVs on \"%s\"", pv->pv_name);
goto pvdisplay_device_out;
}
pv_display_pe_text(pv, pv->pe, lvs);
} else
log_print("no logical volume on physical volume %s", pv_name);
log_print("no logical volume on physical volume \"%s\"",
pv_name);
**********/
return;

3
tools/pvscan.c
View File

@ -184,7 +184,8 @@ void pvscan_display_single(struct physical_volume *pv)
if (pv->status & EXPORTED_VG) {
strncpy(vg_name_this, pv->vg_name, vg_name_len);
log_print("PV %-*s is in exported VG %s [%s / %s free]",
log_print("PV %-*s is in exported VG %s "
"[%s / %s free]",
pv_max_name_len, pv_tmp_name,
vg_name_this, (s1 =
display_size(pv->pe_count *

39
tools/toollib.c
View File

@ -16,7 +16,7 @@ int dir_exists(const char *dir)
return 1;
if (stat(dir, &info) != -1) {
log_error("%s exists", dir);
log_error("\"%s\" exists", dir);
return 0;
}
@ -31,7 +31,7 @@ int create_dir(const char *dir)
return 1;
if (stat(dir, &info) < 0) {
log_verbose("Creating directory %s", dir);
log_verbose("Creating directory \"%s\"", dir);
if (!mkdir(dir, 0777))
return 1;
log_sys_error("mkdir", dir);
@ -41,7 +41,7 @@ int create_dir(const char *dir)
if (S_ISDIR(info.st_mode))
return 1;
log_error("Directory %s not found", dir);
log_error("Directory \"%s\" not found", dir);
return 0;
}
@ -55,7 +55,7 @@ int process_each_lv_in_vg(struct volume_group *vg,
struct logical_volume *lv;
if (vg->status & EXPORTED_VG) {
log_error("Volume group %s is exported", vg->name);
log_error("Volume group \"%s\" is exported", vg->name);
return ECMD_FAILED;
}
@ -97,9 +97,9 @@ int process_each_lv(int argc, char **argv,
continue;
}
log_verbose("Finding volume group %s", vg_name);
log_verbose("Finding volume group \"%s\"", vg_name);
if (!(vg = fid->ops->vg_read(fid, vg_name))) {
log_error("Volume group %s doesn't exist",
log_error("Volume group \"%s\" doesn't exist",
vg_name);
if (ret_max < ECMD_FAILED)
ret_max = ECMD_FAILED;
@ -107,14 +107,14 @@ int process_each_lv(int argc, char **argv,
}
if (vg->status & EXPORTED_VG) {
log_error("Volume group %s is exported",
log_error("Volume group \"%s\" is exported",
vg->name);
return ECMD_FAILED;
}
if (!(lvl = find_lv_in_vg(vg, lv_name))) {
log_error("Can't find logical volume %s "
"in volume group %s",
log_error("Can't find logical volume \"%s\" "
"in volume group \"%s\"",
lv_name, vg_name);
if (ret_max < ECMD_FAILED)
ret_max = ECMD_FAILED;
@ -135,7 +135,8 @@ int process_each_lv(int argc, char **argv,
list_iterate(vgh, vgs) {
vg_name = list_item(vgh, struct name_list)->name;
if (!(vg = fid->ops->vg_read(fid, vg_name))) {
log_error("Volume group %s not found", vg_name);
log_error("Volume group \"%s\" not found",
vg_name);
if (ret_max < ECMD_FAILED)
ret_max = ECMD_FAILED;
continue;
@ -216,8 +217,8 @@ int process_each_pv(int argc, char **argv, struct volume_group *vg,
log_verbose("Using physical volume(s) on command line");
for (; opt < argc; opt++) {
if (!(pvl = find_pv_in_vg(vg, argv[opt]))) {
log_error("Physical Volume %s not found in "
"Volume Group %s", argv[opt],
log_error("Physical Volume \"%s\" not found in "
"Volume Group \"%s\"", argv[opt],
vg->name);
continue;
}
@ -257,7 +258,7 @@ char *extract_vgname(struct format_instance *fi, char *lv_name)
/* Require exactly one slash */
/* FIXME But allow for consecutive slashes */
if (!(st = strchr(vg_name, '/')) || (strchr(st + 1, '/'))) {
log_error("%s: Invalid path for Logical Volume",
log_error("\"%s\": Invalid path for Logical Volume",
lv_name);
return 0;
}
@ -274,7 +275,7 @@ char *extract_vgname(struct format_instance *fi, char *lv_name)
if (!(vg_name = default_vgname(fid))) {
if (lv_name)
log_error("Path required for Logical Volume %s",
log_error("Path required for Logical Volume \"%s\"",
lv_name);
return 0;
}
@ -297,8 +298,8 @@ char *default_vgname(struct format_instance *fi)
vg_path += strlen(dev_dir);
if (strchr(vg_path, '/')) {
log_error("Environment Volume Group in LVM_VG_NAME invalid: %s",
vg_path);
log_error("Environment Volume Group in LVM_VG_NAME invalid: "
"\"%s\"", vg_path);
return 0;
}
@ -322,13 +323,13 @@ struct list *create_pv_list(struct pool *mem,
for (i = 0; i < argc; i++) {
if (!(pvl = find_pv_in_vg(vg, argv[i]))) {
log_err("Physical Volume %s not found in "
"Volume Group %s", argv[i], vg->name);
log_err("Physical Volume \"%s\" not found in "
"Volume Group \"%s\"", argv[i], vg->name);
return NULL;
}
if (pvl->pv->pe_count == pvl->pv->pe_allocated) {
log_err("No free extents on physical volume %s",
log_err("No free extents on physical volume \"%s\"",
argv[i]);
continue;
}

6
tools/vgcfgbackup.c
View File

@ -29,9 +29,9 @@ static int vg_backup_single(const char *vg_name)
{
struct volume_group *vg;
log_verbose("Checking for volume group %s", vg_name);
log_verbose("Checking for volume group \"%s\"", vg_name);
if (!(vg = fid->ops->vg_read(fid, vg_name))) {
log_error("Volume group %s not found", vg_name);
log_error("Volume group \"%s\" not found", vg_name);
return ECMD_FAILED;
}
@ -47,7 +47,7 @@ static int vg_backup_single(const char *vg_name)
}
}
log_print("Volume group %s successfully backed up.", vg_name);
log_print("Volume group \"%s\" successfully backed up.", vg_name);
return 0;
}

28
tools/vgchange.c
View File

@ -52,17 +52,17 @@ static int vgchange_single(const char *vg_name)
struct volume_group *vg;
if (!(vg = fid->ops->vg_read(fid, vg_name))) {
log_error("Unable to find volume group %s", vg_name);
log_error("Unable to find volume group \"%s\"", vg_name);
return ECMD_FAILED;
}
if (!(vg->status & LVM_WRITE) && !arg_count(available_ARG)) {
log_error("Volume group %s is read-only", vg->name);
log_error("Volume group \"%s\" is read-only", vg->name);
return ECMD_FAILED;
}
if (vg->status & EXPORTED_VG) {
log_error("Volume group %s is exported", vg_name);
log_error("Volume group \"%s\" is exported", vg_name);
return ECMD_FAILED;
}
@ -85,24 +85,24 @@ void vgchange_available(struct volume_group *vg)
/* FIXME: Force argument to deactivate them? */
if (!available && (lv_open = lvs_in_vg_opened(vg))) {
log_error("Can't deactivate volume group '%s' with %d open "
log_error("Can't deactivate volume group \"%s\" with %d open "
"logical volume(s)", vg->name, lv_open);
return;
}
if (available && (lv_active = lvs_in_vg_activated(vg)))
log_verbose("%d logical volume(s) in volume group %s "
log_verbose("%d logical volume(s) in volume group \"%s\" "
"already active", lv_active, vg->name);
if (available && (lv_open = activate_lvs_in_vg(vg)))
log_verbose("Activated %d logical volumes in "
"volume group %s", lv_open, vg->name);
"volume group \"%s\"", lv_open, vg->name);
if (!available && (lv_open = deactivate_lvs_in_vg(vg)))
log_verbose("Deactivated %d logical volumes in "
"volume group %s", lv_open, vg->name);
"volume group \"%s\"", lv_open, vg->name);
log_print("%d logical volume(s) in volume group %s now active",
log_print("%d logical volume(s) in volume group \"%s\" now active",
lvs_in_vg_activated(vg), vg->name);
return;
}
@ -112,12 +112,12 @@ void vgchange_resizeable(struct volume_group *vg)
int resizeable = !strcmp(arg_str_value(resizeable_ARG, "n"), "y");
if (resizeable && (vg->status & RESIZEABLE_VG)) {
log_error("Volume group %s is already resizeable", vg->name);
log_error("Volume group \"%s\" is already resizeable", vg->name);
return;
}
if (!resizeable && !(vg->status & RESIZEABLE_VG)) {
log_error("Volume group %s is already not resizeable",
log_error("Volume group \"%s\" is already not resizeable",
vg->name);
return;
}
@ -135,7 +135,7 @@ void vgchange_resizeable(struct volume_group *vg)
backup(vg);
log_print("Volume group %s successfully changed", vg->name);
log_print("Volume group \"%s\" successfully changed", vg->name);
return;
}
@ -145,14 +145,14 @@ void vgchange_logicalvolume(struct volume_group *vg)
int max_lv = arg_int_value(logicalvolume_ARG, 0);
if (!(vg->status & RESIZEABLE_VG)) {
log_error("Volume group '%s' must be resizeable "
log_error("Volume group \"%s\" must be resizeable "
"to change MaxLogicalVolume", vg->name);
return;
}
if (max_lv < vg->lv_count) {
log_error("MaxLogicalVolume is less than the current number "
"%d of logical volume(s) for '%s'", vg->lv_count,
"%d of logical volume(s) for \"%s\"", vg->lv_count,
vg->name);
return;
}
@ -184,7 +184,7 @@ void vgchange_logicalvolume(struct volume_group *vg)
backup(vg);
log_print("Volume group %s successfully changed", vg->name);
log_print("Volume group \"%s\" successfully changed", vg->name);
return;
}

11
tools/vgck.c
View File

@ -31,21 +31,22 @@ static int vgck_single(const char *vg_name)
{
struct volume_group *vg;
log_verbose("Checking volume group %s", vg_name);
log_verbose("Checking volume group \"%s\"", vg_name);
if (!(vg = fid->ops->vg_read(fid, vg_name))) {
log_error("Volume group %s not found", vg_name);
log_error("Volume group \"%s\" not found", vg_name);
return ECMD_FAILED;
}
if (vg->status & EXPORTED_VG) {
log_error("Volume group %s is exported", vg_name);
log_error("Volume group \"%s\" is exported", vg_name);
return ECMD_FAILED;
}
/******* FIXME Must be caught and logged by vg_read
log_error("not all physical volumes of volume group %s online",
log_error("volume group %s has physical volumes with invalid version",
log_error("not all physical volumes of volume group \"%s\" online",
log_error("volume group \"%s\" has physical volumes with ",
"invalid version",
********/
/* FIXME: free */

4
tools/vgcreate.c
View File

@ -70,7 +70,7 @@ int vgcreate(int argc, char **argv)
if (!dir_exists(vg_path)) return ECMD_FAILED;
if (!is_valid_chars(vg_name)) {
log_error("New volume group name '%s' has invalid characters",
log_error("New volume group name \"%s\" has invalid characters",
vg_name);
return ECMD_FAILED;
}
@ -97,7 +97,7 @@ int vgcreate(int argc, char **argv)
backup(vg);
log_print("Volume group %s successfully created", vg->name);
log_print("Volume group \"%s\" successfully created", vg->name);
return 0;
}

6
tools/vgdisplay.c
View File

@ -69,14 +69,14 @@ static int vgdisplay_single(const char *vg_name)
/* FIXME Do the active check here if activevolumegroups_ARG ? */
log_very_verbose("Finding volume group %s", vg_name);
log_very_verbose("Finding volume group \"%s\"", vg_name);
if (!(vg = fid->ops->vg_read(fid, vg_name))) {
log_error("Volume group %s doesn't exist", vg_name);
log_error("Volume group \"%s\" doesn't exist", vg_name);
return ECMD_FAILED;
}
if (vg->status & EXPORTED_VG)
log_print("WARNING: volume group %s is exported", vg_name);
log_print("WARNING: volume group \"%s\" is exported", vg_name);
if (arg_count(colon_ARG)) {
vgdisplay_colons(vg);

10
tools/vgexport.c
View File

@ -42,22 +42,22 @@ static int vgexport_single(const char *vg_name)
struct volume_group *vg;
if (!(vg = fid->ops->vg_read(fid, vg_name))) {
log_error("Unable to find volume group %s", vg_name);
log_error("Unable to find volume group \"%s\"", vg_name);
return ECMD_FAILED;
}
if (vg->status & EXPORTED_VG) {
log_error("Volume group %s is already exported", vg_name);
log_error("Volume group \"%s\" is already exported", vg_name);
return ECMD_FAILED;
}
if (!(vg->status & LVM_WRITE)) {
log_error("Volume group %s is read-only", vg_name);
log_error("Volume group \"%s\" is read-only", vg_name);
return ECMD_FAILED;
}
if (lvs_in_vg_activated(vg)) {
log_error("Volume group %s has active logical volumes",
log_error("Volume group \"%s\" has active logical volumes",
vg_name);
return ECMD_FAILED;
}
@ -72,7 +72,7 @@ static int vgexport_single(const char *vg_name)
backup(vg);
log_print("Volume group %s successfully exported", vg->name);
log_print("Volume group \"%s\" successfully exported", vg->name);
return 0;
}

14
tools/vgextend.c
View File

@ -40,24 +40,24 @@ int vgextend(int argc, char **argv)
argc--;
argv++;
log_verbose("Checking for volume group '%s'", vg_name);
log_verbose("Checking for volume group \"%s\"", vg_name);
if (!(vg = fid->ops->vg_read(fid, vg_name))) {
log_error("Volume group '%s' not found.", vg_name);
log_error("Volume group \"%s\" not found.", vg_name);
return ECMD_FAILED;
}
if (vg->status & EXPORTED_VG) {
log_error("Volume group %s is exported", vg->name);
log_error("Volume group \"%s\" is exported", vg->name);
return ECMD_FAILED;
}
if (!(vg->status & LVM_WRITE)) {
log_error("Volume group %s is read-only", vg_name);
log_error("Volume group \"%s\" is read-only", vg_name);
return ECMD_FAILED;
}
if (!(vg->status & RESIZEABLE_VG)) {
log_error("Volume group '%s' is not resizeable.", vg_name);
log_error("Volume group \"%s\" is not resizeable.", vg_name);
return ECMD_FAILED;
}
@ -76,7 +76,7 @@ int vgextend(int argc, char **argv)
return ECMD_FAILED;
/* ret > 0 */
log_verbose("Volume group '%s' will be extended by %d new "
log_verbose("Volume group \"%s\" will be extended by %d new "
"physical volumes", vg_name, argc);
/* store vg on disk(s) */
@ -85,7 +85,7 @@ int vgextend(int argc, char **argv)
backup(vg);
log_print("Volume group '%s' successfully extended", vg_name);
log_print("Volume group \"%s\" successfully extended", vg_name);
return 0;
}

9
tools/vgimport.c
View File

@ -42,17 +42,18 @@ static int vgimport_single(const char *vg_name)
struct volume_group *vg;
if (!(vg = fid->ops->vg_read(fid, vg_name))) {
log_error("Unable to find exported volume group %s", vg_name);
log_error("Unable to find exported volume group \"%s\"",
vg_name);
return ECMD_FAILED;
}
if (!(vg->status & EXPORTED_VG)) {
log_error("Volume group %s is not exported", vg_name);
log_error("Volume group \"%s\" is not exported", vg_name);
return ECMD_FAILED;
}
if (vg->status & PARTIAL_VG) {
log_error("Volume group %s is partially missing", vg_name);
log_error("Volume group \"%s\" is partially missing", vg_name);
return ECMD_FAILED;
}
@ -66,7 +67,7 @@ static int vgimport_single(const char *vg_name)
backup(vg);
log_print("Volume group %s successfully imported", vg->name);
log_print("Volume group \"%s\" successfully imported", vg->name);
return 0;
}

32
tools/vgmerge.c
View File

@ -53,44 +53,44 @@ int vgmerge_single(const char *vg_name_to, const char *vg_name_from)
int active;
if (!strcmp(vg_name_to, vg_name_from)) {
log_error("Duplicate volume group name %s", vg_name_from);
log_error("Duplicate volume group name \"%s\"", vg_name_from);
return ECMD_FAILED;
}
log_verbose("Checking for volume group %s", vg_name_to);
log_verbose("Checking for volume group \"%s\"", vg_name_to);
if (!(vg_to = fid->ops->vg_read(fid, vg_name_to))) {
log_error("Volume group %s doesn't exist", vg_name_to);
log_error("Volume group \"%s\" doesn't exist", vg_name_to);
return ECMD_FAILED;
}
if (vg_to->status & EXPORTED_VG) {
log_error("Volume group %s is exported", vg_to->name);
log_error("Volume group \"%s\" is exported", vg_to->name);
return ECMD_FAILED;
}
if (!(vg_to->status & LVM_WRITE)) {
log_error("Volume group %s is read-only", vg_to->name);
log_error("Volume group \"%s\" is read-only", vg_to->name);
return ECMD_FAILED;
}
log_verbose("Checking for volume group %s", vg_name_from);
log_verbose("Checking for volume group \"%s\"", vg_name_from);
if (!(vg_from = fid->ops->vg_read(fid, vg_name_from))) {
log_error("Volume group %s doesn't exist", vg_name_from);
log_error("Volume group \"%s\" doesn't exist", vg_name_from);
return ECMD_FAILED;
}
if (vg_from->status & EXPORTED_VG) {
log_error("Volume group %s is exported", vg_from->name);
log_error("Volume group \"%s\" is exported", vg_from->name);
return ECMD_FAILED;
}
if (!(vg_from->status & LVM_WRITE)) {
log_error("Volume group %s is read-only", vg_from->name);
log_error("Volume group \"%s\" is read-only", vg_from->name);
return ECMD_FAILED;
}
if ((active = lvs_in_vg_activated(vg_from))) {
log_error("Logical volumes in %s must be inactive",
log_error("Logical volumes in \"%s\" must be inactive",
vg_name_from);
return ECMD_FAILED;
}
@ -105,14 +105,14 @@ int vgmerge_single(const char *vg_name_to, const char *vg_name_from)
if (vg_to->max_pv < vg_to->pv_count + vg_from->pv_count) {
log_error("Maximum number of physical volumes (%d) exceeded "
" for %s and %s", vg_to->max_pv, vg_to->name,
" for \"%s\" and \"%s\"", vg_to->max_pv, vg_to->name,
vg_from->name);
return ECMD_FAILED;
}
if (vg_to->max_lv < vg_to->lv_count + vg_from->lv_count) {
log_error("Maximum number of logical volumes (%d) exceeded "
" for %s and %s", vg_to->max_lv, vg_to->name,
" for \"%s\" and \"%s\"", vg_to->max_lv, vg_to->name,
vg_from->name);
return ECMD_FAILED;
}
@ -126,8 +126,10 @@ int vgmerge_single(const char *vg_name_to, const char *vg_name_from)
char *name2 = list_item(lvh2,
struct lv_list)->lv->name;
if (!strcmp(name1, name2)) {
log_error("Duplicate logical volume name %s "
"in %s and %s", name1, vg_to->name,
log_error("Duplicate logical volume ",
"name \"%s\" "
"in \"%s\" and \"%s\"",
name1, vg_to->name,
vg_from->name);
return ECMD_FAILED;
}
@ -173,7 +175,7 @@ int vgmerge_single(const char *vg_name_to, const char *vg_name_from)
backup(vg_to);
log_print("Volume group %s successfully merged into %s",
log_print("Volume group \"%s\" successfully merged into \"%s\"",
vg_from->name, vg_to->name);
return 0;
}

31
tools/vgreduce.c
View File

@ -48,24 +48,24 @@ int vgreduce(int argc, char **argv)
argv++;
argc--;
log_verbose("Finding volume group %s", vg_name);
log_verbose("Finding volume group \"%s\"", vg_name);
if (!(vg = fid->ops->vg_read(fid, vg_name))) {
log_error("Volume group %s doesn't exist", vg_name);
log_error("Volume group \"%s\" doesn't exist", vg_name);
return ECMD_FAILED;
}
if (vg->status & EXPORTED_VG) {
log_error("Volume group %s is exported", vg->name);
log_error("Volume group \"%s\" is exported", vg->name);
return ECMD_FAILED;
}
if (!(vg->status & LVM_WRITE)) {
log_error("Volume group %s is read-only", vg_name);
log_error("Volume group \"%s\" is read-only", vg_name);
return ECMD_FAILED;
}
if (!(vg->status & RESIZEABLE_VG)) {
log_error("Volume group %s is not reducable", vg_name);
log_error("Volume group \"%s\" is not reducable", vg_name);
return ECMD_FAILED;
}
@ -79,7 +79,8 @@ int vgreduce(int argc, char **argv)
log_verbose
("volume group \"%s\" will be reduced by %d physical volume%s",
vg_name, np, np > 1 ? "s" : "");
log_verbose ("reducing volume group \"%s\" by physical volume \"%s\"", vg_name, pv_names[p]);
log_verbose ("reducing volume group \"%s\" by physical volume \"%s\"",
vg_name, pv_names[p]);
log_print
("volume group \"%s\" %ssuccessfully reduced by physical volume%s:",
@ -96,7 +97,7 @@ static int vgreduce_single(struct volume_group *vg, struct physical_volume *pv)
const char *name = dev_name(pv->dev);
if (pv->pe_allocated) {
log_error("Physical volume %s still in use", name);
log_error("Physical volume \"%s\" still in use", name);
return ECMD_FAILED;
}
@ -107,8 +108,8 @@ static int vgreduce_single(struct volume_group *vg, struct physical_volume *pv)
*********/
if (vg->pv_count == 1) {
log_error("Can't remove final physical volume %s from "
"volume group %s", name, vg->name);
log_error("Can't remove final physical volume \"%s\" from "
"volume group \"%s\"", name, vg->name);
return ECMD_FAILED;
}
@ -117,7 +118,7 @@ static int vgreduce_single(struct volume_group *vg, struct physical_volume *pv)
if (!archive(vg))
return ECMD_FAILED;
log_verbose("Removing %s from volume group %s", name, vg->name);
log_verbose("Removing \"%s\" from volume group \"%s\"", name, vg->name);
if (pvl)
list_del(&pvl->list);
@ -128,20 +129,22 @@ static int vgreduce_single(struct volume_group *vg, struct physical_volume *pv)
vg->extent_count -= pv->pe_count;
if (!(fid->ops->vg_write(fid, vg))) {
log_error("Removal of physical volume %s from %s failed",
log_error("Removal of physical volume \"%s\" from "
"\"%s\" failed",
name, vg->name);
return ECMD_FAILED;
}
if (!fid->ops->pv_write(fid, pv)) {
log_error("Failed to clear metadata from physical volume %s "
"after removal from %s", name, vg->name);
log_error("Failed to clear metadata from physical "
"volume \"%s\" "
"after removal from \"%s\"", name, vg->name);
return ECMD_FAILED;
}
backup(vg);
log_print("Removed %s from volume group %s", name, vg->name);
log_print("Removed \"%s\" from volume group \"%s\"", name, vg->name);
return 0;
}

27
tools/vgremove.c
View File

@ -34,24 +34,26 @@ static int vgremove_single(const char *vg_name)
struct list *pvh;
int ret = 0;
log_verbose("Checking for volume group %s", vg_name);
log_verbose("Checking for volume group \"%s\"", vg_name);
if (!(vg = fid->ops->vg_read(fid, vg_name))) {
log_error("Volume group %s doesn't exist", vg_name);
log_error("Volume group \"%s\" doesn't exist", vg_name);
return ECMD_FAILED;
}
if (vg->status & EXPORTED_VG) {
log_error("Volume group %s is exported", vg->name);
log_error("Volume group \"%s\" is exported", vg->name);
return ECMD_FAILED;
}
if (vg->status & PARTIAL_VG) {
log_error("Cannot remove partial volume group %s", vg->name);
log_error("Cannot remove partial volume group \"%s\"",
vg->name);
return ECMD_FAILED;
}
if (vg->lv_count) {
log_error("Volume group %s still contains %d logical volume(s)",
log_error("Volume group \"%s\" still contains %d "
"logical volume(s)",
vg_name, vg->lv_count);
return ECMD_FAILED;
}
@ -61,7 +63,7 @@ static int vgremove_single(const char *vg_name)
/************ FIXME
if (vg_remove_dir_and_group_and_nodes(vg_name) < 0) {
log_error("removing special files of volume group %s",
log_error("removing special files of volume group \"%s\"",
vg_name);
}
*************/
@ -69,13 +71,14 @@ static int vgremove_single(const char *vg_name)
/* init physical volumes */
list_iterate(pvh, &vg->pvs) {
pv = list_item(pvh, struct pv_list)->pv;
log_verbose("Removing physical volume %s from volume group %s",
log_verbose("Removing physical volume \"%s\" from "
"volume group \"%s\"",
dev_name(pv->dev), vg_name);
*pv->vg_name = '\0';
if (!(fid->ops->pv_write(fid, pv))) {
log_error("Failed to remove physical volume %s from "
"volume group %s", dev_name(pv->dev),
vg_name);
log_error("Failed to remove physical volume \"%s\""
" from volume group \"%s\"",
dev_name(pv->dev), vg_name);
ret = ECMD_FAILED;
}
}
@ -83,9 +86,9 @@ static int vgremove_single(const char *vg_name)
backup_remove(vg_name);
if (!ret)
log_print("Volume group %s successfully removed", vg_name);
log_print("Volume group \"%s\" successfully removed", vg_name);
else
log_error("Volume group %s not properly removed", vg_name);
log_error("Volume group \"%s\" not properly removed", vg_name);
return ret;
}

24
tools/vgrename.c
View File

@ -57,7 +57,7 @@ int vgrename(int argc, char **argv)
}
if (!is_valid_chars(vg_name_new)) {
log_error("New volume group name %s has invalid characters",
log_error("New volume group name \"%s\" has invalid characters",
vg_name_new);
return ECMD_FAILED;
}
@ -67,24 +67,25 @@ int vgrename(int argc, char **argv)
return ECMD_FAILED;
}
log_verbose("Checking for existing volume group %s", vg_name_old);
log_verbose("Checking for existing volume group \"%s\"", vg_name_old);
if (!(vg_old = fid->ops->vg_read(fid, vg_name_old))) {
log_error("Volume group %s doesn't exist", vg_name_old);
log_error("Volume group \"%s\" doesn't exist", vg_name_old);
return ECMD_FAILED;
}
if (vg_old->status & EXPORTED_VG) {
log_error("Volume group %s is exported", vg_old->name);
log_error("Volume group \"%s\" is exported", vg_old->name);
return ECMD_FAILED;
}
if (!(vg_old->status & LVM_WRITE)) {
log_error("Volume group %s is read-only", vg_old->name);
log_error("Volume group \"%s\" is read-only", vg_old->name);
return ECMD_FAILED;
}
if (lvs_in_vg_activated(vg_old)) {
log_error("Volume group %s still has active LVs", vg_name_old);
log_error("Volume group \"%s\" still has active LVs",
vg_name_old);
/***** FIXME Handle this with multiple LV renames!
if (!force_ARG) {
log_error("Use -f to force the rename");
@ -93,9 +94,10 @@ int vgrename(int argc, char **argv)
*****/
}
log_verbose("Checking for new volume group %s", vg_name_new);
log_verbose("Checking for new volume group \"%s\"", vg_name_new);
if ((vg_new = fid->ops->vg_read(fid, vg_name_new))) {
log_error("New volume group %s already exists", vg_name_new);
log_error("New volume group \"%s\" already exists",
vg_name_new);
return ECMD_FAILED;
}
@ -120,9 +122,9 @@ int vgrename(int argc, char **argv)
sprintf(old_path, "%s%s", dev_dir, vg_name_old);
sprintf(new_path, "%s%s", dev_dir, vg_name_new);
log_verbose("Renaming %s to %s", old_path, new_path);
log_verbose("Renaming \"%s\" to \"%s\"", old_path, new_path);
if (rename(old_path, new_path)) {
log_error("Renaming %s to %s failed: %s",
log_error("Renaming \"%s\" to \"%s\" failed: %s",
old_path, new_path, strerror(errno));
return ECMD_FAILED;
}
@ -137,7 +139,7 @@ int vgrename(int argc, char **argv)
backup(vg_old);
log_print("Volume group %s successfully renamed to %s",
log_print("Volume group \"%s\" successfully renamed to \"%s\"",
vg_name_old, vg_name_new);
/* FIXME: Deallocations */

6
tools/vgscan.c
View File

@ -44,13 +44,13 @@ static int vgscan_single(const char *vg_name)
{
struct volume_group *vg;
log_verbose("Checking for volume group %s", vg_name);
log_verbose("Checking for volume group \"%s\"", vg_name);
if (!(vg = fid->ops->vg_read(fid, vg_name))) {
log_error("Volume group %s not found", vg_name);
log_error("Volume group \"%s\" not found", vg_name);
return ECMD_FAILED;
}
log_print("Found %svolume group %s",
log_print("Found %svolume group \"%s\"",
(vg->status & EXPORTED_VG) ? "exported " : "",
vg_name);