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; }