int vgcfgrestore(struct cmd_context *cmd, int argc, char **argv)
{
const char *vg_name = NULL;
if (argc == 1) {
vg_name = skip_dev_dir(cmd, argv[0], NULL);
if (!validate_name(vg_name)) {
log_error("Volume group name \"%s\" is invalid", vg_name);
return ECMD_FAILED;
}
} else if (!(arg_count(cmd, list_ARG) && arg_count(cmd, file_ARG))) {
log_error("Please specify a *single* volume group to restore.");
return ECMD_FAILED;
}
/*
* FIXME: overloading the -l arg for now to display a
* list of archive files for a particular vg
*/
if (arg_count(cmd, list_ARG)) {
if (!(arg_count(cmd,file_ARG) ?
archive_display_file(cmd,
arg_str_value(cmd, file_ARG, "")) :
archive_display(cmd, vg_name))) {
stack;
return ECMD_FAILED;
}
return ECMD_PROCESSED;
}
lvmcache_seed_infos_from_lvmetad(cmd);
if (!lock_vol(cmd, vg_name, LCK_VG_WRITE)) {
log_error("Unable to lock volume group %s", vg_name);
return ECMD_FAILED;
}
if (!lock_vol(cmd, VG_ORPHANS, LCK_VG_WRITE)) {
log_error("Unable to lock orphans");
unlock_vg(cmd, vg_name);
return ECMD_FAILED;
}
cmd->handles_unknown_segments = 1;
if (!(arg_count(cmd, file_ARG) ?
backup_restore_from_file(cmd, vg_name,
arg_str_value(cmd, file_ARG, "")) :
backup_restore(cmd, vg_name))) {
unlock_vg(cmd, VG_ORPHANS);
unlock_vg(cmd, vg_name);
log_error("Restore failed.");
return ECMD_FAILED;
}
log_print("Restored volume group %s", vg_name);
unlock_vg(cmd, VG_ORPHANS);
unlock_vg(cmd, vg_name);
return ECMD_PROCESSED;
}
/*
* Intial sanity checking of recovery-related command-line arguments.
* These args are: --restorefile, --uuid, and --physicalvolumesize
*
* Output arguments:
* pp: structure allocated by caller, fields written / validated here
*/
static int pvcreate_restore_params_validate(struct cmd_context *cmd,
int argc, char **argv,
struct pvcreate_params *pp)
{
const char *uuid = NULL;
struct volume_group *vg;
struct pv_list *existing_pvl;
if (arg_count(cmd, restorefile_ARG) && !arg_count(cmd, uuidstr_ARG)) {
log_error("--uuid is required with --restorefile");
return 0;
}
if (!arg_count(cmd, restorefile_ARG) && arg_count(cmd, uuidstr_ARG)) {
if (!arg_count(cmd, norestorefile_ARG) &&
find_config_tree_bool(cmd, devices_require_restorefile_with_uuid_CFG, NULL)) {
log_error("--restorefile is required with --uuid");
return 0;
}
}
if (arg_count(cmd, uuidstr_ARG) && argc != 1) {
log_error("Can only set uuid on one volume at once");
return 0;
}
if (arg_count(cmd, uuidstr_ARG)) {
uuid = arg_str_value(cmd, uuidstr_ARG, "");
if (!id_read_format(&pp->rp.id, uuid))
return 0;
pp->rp.idp = &pp->rp.id;
lvmcache_seed_infos_from_lvmetad(cmd); /* need to check for UUID dups */
}
if (arg_count(cmd, restorefile_ARG)) {
pp->rp.restorefile = arg_str_value(cmd, restorefile_ARG, "");
/* The uuid won't already exist */
if (!(vg = backup_read_vg(cmd, NULL, pp->rp.restorefile))) {
log_error("Unable to read volume group from %s",
pp->rp.restorefile);
return 0;
}
if (!(existing_pvl = find_pv_in_vg_by_uuid(vg, pp->rp.idp))) {
release_vg(vg);
log_error("Can't find uuid %s in backup file %s",
uuid, pp->rp.restorefile);
return 0;
}
pp->rp.ba_start = pv_ba_start(existing_pvl->pv);
pp->rp.ba_size = pv_ba_size(existing_pvl->pv);
pp->rp.pe_start = pv_pe_start(existing_pvl->pv);
pp->rp.extent_size = pv_pe_size(existing_pvl->pv);
pp->rp.extent_count = pv_pe_count(existing_pvl->pv);
release_vg(vg);
}
if (arg_sign_value(cmd, physicalvolumesize_ARG, SIGN_NONE) == SIGN_MINUS) {
log_error("Physical volume size may not be negative");
return 0;
}
pp->size = arg_uint64_value(cmd, physicalvolumesize_ARG, UINT64_C(0));
if (arg_count(cmd, restorefile_ARG) || arg_count(cmd, uuidstr_ARG))
pp->zero = 0;
return 1;
}
static int _vgrename_single(struct cmd_context *cmd, const char *vg_name,
struct volume_group *vg, struct processing_handle *handle)
{
struct vgrename_params *vp = (struct vgrename_params *) handle->custom_handle;
struct lvmcache_vginfo *vginfo;
char old_path[NAME_LEN];
char new_path[NAME_LEN];
struct id id;
const char *name;
char *dev_dir;
/*
* vg_name_old may be a UUID which process_each_vg
* replaced with the real VG name. In that case,
* vp->vg_name_old will be the UUID and vg_name will be
* the actual VG name. Check again if the old and new
* names match, using the real names.
*/
if (vp->old_name_is_uuid && !strcmp(vp->vg_name_new, vg_name)) {
log_error("New VG name must differ from the old VG name.");
return ECMD_FAILED;
}
/*
* Check if a VG already exists with the new VG name.
*
* When not using lvmetad, it's essential that a full scan has
* been done to ensure we see all existing VG names, so we
* do not use an existing name. This has been done by
* process_each_vg REQUIRES_FULL_LABEL_SCAN.
*
* (FIXME: We could look for the new name in the list of all
* VGs that process_each_vg created, but we don't have access
* to that list here, so we have to look in lvmcache.
* This requires populating lvmcache when using lvmetad.)
*/
lvmcache_seed_infos_from_lvmetad(cmd);
if ((vginfo = lvmcache_vginfo_from_vgname(vp->vg_name_new, NULL))) {
log_error("New VG name \"%s\" already exists", vp->vg_name_new);
return ECMD_FAILED;
}
if (id_read_format_try(&id, vp->vg_name_new) &&
(name = lvmcache_vgname_from_vgid(cmd->mem, (const char *)&id))) {
log_error("New VG name \"%s\" matches the UUID of existing VG %s", vp->vg_name_new, name);
return ECMD_FAILED;
}
/*
* Lock the old VG name first:
* . The old VG name has already been locked by process_each_vg.
* . Now lock the new VG name here, second.
*
* Lock the new VG name first:
* . The new VG name has already been pre-locked below,
* before process_each_vg was called.
* . process_each_vg then locked the old VG name second.
* . Nothing to do here.
*
* Special case when the old VG name is a uuid:
* . The old VG's real name wasn't known before process_each_vg,
* so the correct lock ordering wasn't known beforehand,
* so no pre-locking was done.
* . The old VG's real name has been locked by process_each_vg.
* . Now lock the new VG name here, second.
* . Suppress lock ordering checks because the lock order may
* have wanted the new name first, which wasn't possible in
* this uuid-for-name case.
*/
if (vp->lock_vg_old_first || vp->old_name_is_uuid) {
if (vp->old_name_is_uuid)
lvmcache_lock_ordering(0);
if (!_lock_new_vg_for_rename(cmd, vp->vg_name_new))
return ECMD_FAILED;
lvmcache_lock_ordering(1);
}
dev_dir = cmd->dev_dir;
if (!archive(vg))
goto error;
/* Remove references based on old name */
if (!drop_cached_metadata(vg))
stack;
if (!lockd_rename_vg_before(cmd, vg)) {
stack;
goto error;
}
/* Change the volume group name */
vg_rename(cmd, vg, vp->vg_name_new);
/* store it on disks */
log_verbose("Writing out updated volume group");
if (!vg_write(vg) || !vg_commit(vg)) {
goto error;
}
sprintf(old_path, "%s%s", dev_dir, vg_name);
sprintf(new_path, "%s%s", dev_dir, vp->vg_name_new);
if (activation() && dir_exists(old_path)) {
log_verbose("Renaming \"%s\" to \"%s\"", old_path, new_path);
if (test_mode())
log_verbose("Test mode: Skipping rename.");
else if (lvs_in_vg_activated(vg)) {
if (!vg_refresh_visible(cmd, vg)) {
log_error("Renaming \"%s\" to \"%s\" failed",
old_path, new_path);
goto error;
}
}
}
lockd_rename_vg_final(cmd, vg, 1);
if (!backup(vg))
stack;
if (!backup_remove(cmd, vg_name))
stack;
unlock_vg(cmd, vp->vg_name_new);
vp->unlock_new_name = 0;
log_print_unless_silent("Volume group \"%s\" successfully renamed to \"%s\"",
vp->vg_name_old, vp->vg_name_new);
return 1;
error:
unlock_vg(cmd, vp->vg_name_new);
vp->unlock_new_name = 0;
lockd_rename_vg_final(cmd, vg, 0);
return 0;
}
