mirror of
git://sourceware.org/git/lvm2.git
synced 2025-01-03 05:18:29 +03:00
2bce6faed0
Calling clear_hint_file() to invalidate hints would acquire the hints flock before the global flock which could cause deadlock. The lock order requires the global lock to be taken first. pvchange was always invalidating hints, which was unnecessary; only invalidate hints when changing a PV uuid. Because of the lock ordering, take the global lock before clear_hint_file which locks the hints file.
288 lines
8.2 KiB
C
288 lines
8.2 KiB
C
/*
|
|
* Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
|
|
* Copyright (C) 2004-2015 Red Hat, Inc. All rights reserved.
|
|
*
|
|
* This file is part of LVM2.
|
|
*
|
|
* This copyrighted material is made available to anyone wishing to use,
|
|
* modify, copy, or redistribute it subject to the terms and conditions
|
|
* of the GNU Lesser General Public License v.2.1.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
#include "tools.h"
|
|
|
|
struct pvchange_params {
|
|
unsigned done;
|
|
unsigned total;
|
|
};
|
|
|
|
static int _pvchange_single(struct cmd_context *cmd, struct volume_group *vg,
|
|
struct physical_volume *pv, struct processing_handle *handle)
|
|
{
|
|
struct pvchange_params *params = (struct pvchange_params *) handle->custom_handle;
|
|
const char *pv_name = pv_dev_name(pv);
|
|
char uuid[64] __attribute__((aligned(8)));
|
|
struct dev_use *du = NULL;
|
|
unsigned done = 0;
|
|
int used;
|
|
|
|
int allocatable = arg_int_value(cmd, allocatable_ARG, 0);
|
|
int mda_ignore = arg_int_value(cmd, metadataignore_ARG, 0);
|
|
int tagargs = arg_is_set(cmd, addtag_ARG) + arg_is_set(cmd, deltag_ARG);
|
|
|
|
params->total++;
|
|
|
|
/*
|
|
* The primary location of this check is in vg_write(), but it needs
|
|
* to be copied here to prevent the pv_write() which is called before
|
|
* the vg_write().
|
|
*/
|
|
if (vg && lvmcache_has_duplicate_devs() && vg_has_duplicate_pvs(vg)) {
|
|
if (!find_config_tree_bool(vg->cmd, devices_allow_changes_with_duplicate_pvs_CFG, NULL)) {
|
|
log_error("Cannot update volume group %s with duplicate PV devices.",
|
|
vg->name);
|
|
goto bad;
|
|
}
|
|
if (arg_is_set(cmd, uuid_ARG)) {
|
|
log_error("Resolve duplicate PV UUIDs with vgimportclone (or filters).");
|
|
goto bad;
|
|
}
|
|
}
|
|
|
|
/* If in a VG, must change using volume group. */
|
|
if (vg && !is_orphan(pv)) {
|
|
if (tagargs && !(vg->fid->fmt->features & FMT_TAGS)) {
|
|
log_error("Volume group containing %s does not "
|
|
"support tags", pv_name);
|
|
goto bad;
|
|
}
|
|
if (arg_is_set(cmd, uuid_ARG) && lvs_in_vg_activated(vg)) {
|
|
log_error("Volume group containing %s has active "
|
|
"logical volumes", pv_name);
|
|
goto bad;
|
|
}
|
|
if (!archive(vg))
|
|
goto_bad;
|
|
} else {
|
|
if (tagargs) {
|
|
log_error("Can't change tag on Physical Volume %s not "
|
|
"in volume group", pv_name);
|
|
goto bad;
|
|
}
|
|
|
|
if ((used = is_used_pv(pv)) < 0)
|
|
goto_bad;
|
|
|
|
if (used && (arg_count(cmd, force_ARG) != DONT_PROMPT_OVERRIDE)) {
|
|
log_error("PV %s is used by a VG but its metadata is missing.", pv_name);
|
|
log_error("Can't change PV '%s' without -ff.", pv_name);
|
|
goto bad;
|
|
}
|
|
}
|
|
|
|
if (arg_is_set(cmd, allocatable_ARG)) {
|
|
if (is_orphan(pv) &&
|
|
!(pv->fmt->features & FMT_ORPHAN_ALLOCATABLE)) {
|
|
log_error("Allocatability not supported by orphan "
|
|
"%s format PV %s", pv->fmt->name, pv_name);
|
|
goto bad;
|
|
}
|
|
|
|
/* change allocatability for a PV */
|
|
if (allocatable && (pv_status(pv) & ALLOCATABLE_PV)) {
|
|
log_warn("Physical volume \"%s\" is already "
|
|
"allocatable.", pv_name);
|
|
} else if (!allocatable && !(pv_status(pv) & ALLOCATABLE_PV)) {
|
|
log_warn("Physical volume \"%s\" is already "
|
|
"unallocatable.", pv_name);
|
|
} else if (allocatable) {
|
|
log_verbose("Setting physical volume \"%s\" "
|
|
"allocatable", pv_name);
|
|
pv->status |= ALLOCATABLE_PV;
|
|
done = 1;
|
|
} else {
|
|
log_verbose("Setting physical volume \"%s\" NOT "
|
|
"allocatable", pv_name);
|
|
pv->status &= ~ALLOCATABLE_PV;
|
|
done = 1;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Needed to change a property on an orphan PV.
|
|
* i.e. the global lock is only needed for orphans.
|
|
* Convert sh to ex.
|
|
*/
|
|
if (is_orphan(pv)) {
|
|
if (!lock_global_convert(cmd, "ex"))
|
|
return_ECMD_FAILED;
|
|
}
|
|
|
|
if (tagargs) {
|
|
/* tag or deltag */
|
|
if (arg_is_set(cmd, addtag_ARG) && !change_tag(cmd, NULL, NULL, pv, addtag_ARG))
|
|
goto_bad;
|
|
|
|
if (arg_is_set(cmd, deltag_ARG) && !change_tag(cmd, NULL, NULL, pv, deltag_ARG))
|
|
goto_bad;
|
|
|
|
done = 1;
|
|
}
|
|
|
|
if (arg_is_set(cmd, metadataignore_ARG)) {
|
|
if (vg && (vg_mda_copies(vg) != VGMETADATACOPIES_UNMANAGED) &&
|
|
(arg_count(cmd, force_ARG) == PROMPT) &&
|
|
yes_no_prompt("Override preferred number of copies "
|
|
"of VG %s metadata? [y/n]: ",
|
|
pv_vg_name(pv)) == 'n')
|
|
goto_bad;
|
|
if (!pv_change_metadataignore(pv, mda_ignore))
|
|
goto_bad;
|
|
|
|
done = 1;
|
|
}
|
|
|
|
if (arg_is_set(cmd, uuid_ARG)) {
|
|
/* --uuid: Change PV ID randomly */
|
|
|
|
du = get_du_for_pvid(cmd, pv->dev->pvid);
|
|
|
|
memcpy(&pv->old_id, &pv->id, sizeof(pv->id));
|
|
if (!id_create(&pv->id)) {
|
|
log_error("Failed to generate new random UUID for %s.",
|
|
pv_name);
|
|
goto bad;
|
|
}
|
|
if (!id_write_format(&pv->id, uuid, sizeof(uuid)))
|
|
goto_bad;
|
|
log_verbose("Changing uuid of %s to %s.", pv_name, uuid);
|
|
if (!is_orphan(pv) && (!pv_write(cmd, pv, 1))) {
|
|
log_error("pv_write with new uuid failed "
|
|
"for %s.", pv_name);
|
|
goto bad;
|
|
}
|
|
|
|
done = 1;
|
|
}
|
|
|
|
if (!done) {
|
|
log_print_unless_silent("Physical volume %s not changed", pv_name);
|
|
return ECMD_PROCESSED;
|
|
}
|
|
|
|
log_verbose("Updating physical volume \"%s\"", pv_name);
|
|
if (vg && !is_orphan(pv)) {
|
|
if (!vg_write(vg) || !vg_commit(vg)) {
|
|
log_error("Failed to store physical volume \"%s\" in "
|
|
"volume group \"%s\"", pv_name, vg->name);
|
|
goto bad;
|
|
}
|
|
backup(vg);
|
|
} else if (!(pv_write(cmd, pv, 0))) {
|
|
log_error("Failed to store physical volume \"%s\"",
|
|
pv_name);
|
|
goto bad;
|
|
}
|
|
|
|
if (du) {
|
|
free(du->pvid);
|
|
if (!(du->pvid = strndup((char *)&pv->id, ID_LEN)))
|
|
log_error("Failed to set pvid for devices file.");
|
|
if (!device_ids_write(cmd))
|
|
log_warn("Failed to update devices file.");
|
|
unlock_devices_file(cmd);
|
|
}
|
|
|
|
log_print_unless_silent("Physical volume \"%s\" changed", pv_name);
|
|
|
|
params->done++;
|
|
return ECMD_PROCESSED;
|
|
|
|
bad:
|
|
log_error("Physical volume %s not changed", pv_name);
|
|
|
|
return ECMD_FAILED;
|
|
}
|
|
|
|
int pvchange(struct cmd_context *cmd, int argc, char **argv)
|
|
{
|
|
struct pvchange_params params = { 0 };
|
|
struct processing_handle *handle = NULL;
|
|
int ret;
|
|
|
|
if (!(arg_is_set(cmd, allocatable_ARG) + arg_is_set(cmd, addtag_ARG) +
|
|
arg_is_set(cmd, deltag_ARG) + arg_is_set(cmd, uuid_ARG) +
|
|
arg_is_set(cmd, metadataignore_ARG))) {
|
|
log_error("Please give one or more of -x, -uuid, "
|
|
"--addtag, --deltag or --metadataignore");
|
|
ret = EINVALID_CMD_LINE;
|
|
goto out;
|
|
}
|
|
|
|
if (arg_is_set(cmd, uuid_ARG))
|
|
cmd->edit_devices_file = 1;
|
|
|
|
if (!(handle = init_processing_handle(cmd, NULL))) {
|
|
log_error("Failed to initialize processing handle.");
|
|
ret = ECMD_FAILED;
|
|
goto out;
|
|
}
|
|
|
|
handle->custom_handle = ¶ms;
|
|
|
|
if (!(arg_is_set(cmd, all_ARG)) && !argc && !handle->internal_report_for_select) {
|
|
log_error("Please give a physical volume path or use --select for selection.");
|
|
ret = EINVALID_CMD_LINE;
|
|
goto out;
|
|
}
|
|
|
|
if (arg_is_set(cmd, all_ARG) && argc) {
|
|
log_error("Option --all and PhysicalVolumePath are exclusive.");
|
|
ret = EINVALID_CMD_LINE;
|
|
goto out;
|
|
}
|
|
|
|
set_pv_notify(cmd);
|
|
|
|
/*
|
|
* Changing a PV uuid is the only pvchange that invalidates hints.
|
|
* Invalidating hints (clear_hint_file) is called at the start of
|
|
* the command and takes the hints lock.
|
|
* The global lock must always be taken first, then the hints lock
|
|
* (the required lock ordering.)
|
|
*
|
|
* Because of these constraints, the global lock is taken ex here
|
|
* for any PV uuid change, even though the global lock is technically
|
|
* required only for changing an orphan PV (we don't know until later
|
|
* if the PV is an orphan). The VG lock is used when changing
|
|
* non-orphan PVs.
|
|
*
|
|
* For changes other than uuid on an orphan PV, the global lock is
|
|
* taken sh by process_each, then converted to ex in pvchange_single,
|
|
* which works because the hints lock is not held.
|
|
*
|
|
* (Eventually, perhaps always do lock_global(ex) here to simplify.)
|
|
*/
|
|
if (arg_is_set(cmd, uuid_ARG)) {
|
|
if (!lock_global(cmd, "ex")) {
|
|
ret = ECMD_FAILED;
|
|
goto out;
|
|
}
|
|
clear_hint_file(cmd);
|
|
}
|
|
|
|
ret = process_each_pv(cmd, argc, argv, NULL, 0, READ_FOR_UPDATE, handle, _pvchange_single);
|
|
|
|
log_print_unless_silent("%d physical volume%s changed / %d physical volume%s not changed",
|
|
params.done, params.done == 1 ? "" : "s",
|
|
params.total - params.done, (params.total - params.done) == 1 ? "" : "s");
|
|
|
|
out:
|
|
destroy_processing_handle(cmd, handle);
|
|
return ret;
|
|
}
|