int pvcreate(struct cmd_context *cmd, int argc, char **argv) { int i, r; int ret = ECMD_PROCESSED; struct pvcreate_params pp; if (!argc) { log_error("Please enter a physical volume path"); return EINVALID_CMD_LINE; } if (arg_count(cmd, restorefile_ARG) && !arg_count(cmd, uuidstr_ARG)) { log_error("--uuid is required with --restorefile"); return EINVALID_CMD_LINE; } if (arg_count(cmd, uuidstr_ARG) && argc != 1) { log_error("Can only set uuid on one volume at once"); return EINVALID_CMD_LINE; } if (arg_count(cmd, yes_ARG) && !arg_count(cmd, force_ARG)) { log_error("Option y can only be given with option f"); return EINVALID_CMD_LINE; } if (arg_int_value(cmd, labelsector_ARG, 0) >= LABEL_SCAN_SECTORS) { log_error("labelsector must be less than %lu", LABEL_SCAN_SECTORS); return EINVALID_CMD_LINE; } if (!(cmd->fmt->features & FMT_MDAS) && (arg_count(cmd, metadatacopies_ARG) || arg_count(cmd, metadatasize_ARG))) { log_error("Metadata parameters only apply to text format"); return EINVALID_CMD_LINE; } if (arg_count(cmd, metadatacopies_ARG) && arg_int_value(cmd, metadatacopies_ARG, -1) > 2) { log_error("Metadatacopies may only be 0, 1 or 2"); return EINVALID_CMD_LINE; } if (arg_count(cmd, zero_ARG)) pp.zero = strcmp(arg_str_value(cmd, zero_ARG, "y"), "n"); else if (arg_count(cmd, restorefile_ARG) || arg_count(cmd, uuidstr_ARG)) pp.zero = 0; else pp.zero = 1; for (i = 0; i < argc; i++) { r = pvcreate_single(cmd, argv[i], &pp); if (r > ret) ret = r; if (sigint_caught()) return ret; } return ret; }
static int lvchange_persistent(struct cmd_context *cmd, struct logical_volume *lv) { struct lvinfo info; int active = 0; if (!strcmp(arg_str_value(cmd, persistent_ARG, "n"), "n")) { if (!(lv->status & FIXED_MINOR)) { log_error("Minor number is already not persistent " "for \"%s\"", lv->name); return 0; } lv->status &= ~FIXED_MINOR; lv->minor = -1; lv->major = -1; log_verbose("Disabling persistent device number for \"%s\"", lv->name); } else { if (!arg_count(cmd, minor_ARG) && lv->minor < 0) { log_error("Minor number must be specified with -My"); return 0; } if (arg_count(cmd, major_ARG) > 1) { log_error("Option -j/--major may not be repeated."); return 0; } if (arg_count(cmd, minor_ARG) > 1) { log_error("Option --minor may not be repeated."); return 0; } if (!arg_count(cmd, major_ARG) && lv->major < 0) { log_error("Major number must be specified with -My"); return 0; } if (lv_info(cmd, lv, 0, &info, 0, 0) && info.exists) active = 1; if (active && !arg_count(cmd, force_ARG) && yes_no_prompt("Logical volume %s will be " "deactivated temporarily. " "Continue? [y/n]: ", lv->name) == 'n') { log_error("%s device number not changed.", lv->name); return 0; } if (sigint_caught()) return 0; log_verbose("Ensuring %s is inactive.", lv->name); if (!deactivate_lv(cmd, lv)) { log_error("%s: deactivation failed", lv->name); return 0; } lv->status |= FIXED_MINOR; lv->minor = arg_int_value(cmd, minor_ARG, lv->minor); lv->major = arg_int_value(cmd, major_ARG, lv->major); log_verbose("Setting persistent device number to (%d, %d) " "for \"%s\"", lv->major, lv->minor, lv->name); } log_very_verbose("Updating logical volume \"%s\" on disk(s)", lv->name); if (!vg_write(lv->vg) || !vg_commit(lv->vg)) return_0; backup(lv->vg); if (active) { log_verbose("Re-activating logical volume \"%s\"", lv->name); if (!activate_lv(cmd, lv)) { log_error("%s: reactivation failed", lv->name); return 0; } } return 1; }
static int pvcreate_single(struct cmd_context *cmd, const char *pv_name, void *handle) { struct pvcreate_params *pp = (struct pvcreate_params *) handle; void *pv; void *existing_pv; struct id id, *idp = NULL; const char *uuid = NULL; uint64_t size = 0; struct device *dev; struct list mdas; int pvmetadatacopies; uint64_t pvmetadatasize; struct volume_group *vg; const char *restorefile; uint64_t pe_start = 0; uint32_t extent_count = 0, extent_size = 0; if (arg_count(cmd, uuidstr_ARG)) { uuid = arg_str_value(cmd, uuidstr_ARG, ""); if (!id_read_format(&id, uuid)) return EINVALID_CMD_LINE; if ((dev = device_from_pvid(cmd, &id)) && (dev != dev_cache_get(pv_name, cmd->filter))) { log_error("uuid %s already in use on \"%s\"", uuid, dev_name(dev)); return ECMD_FAILED; } idp = &id; } if (arg_count(cmd, restorefile_ARG)) { restorefile = arg_str_value(cmd, restorefile_ARG, ""); /* The uuid won't already exist */ init_partial(1); if (!(vg = backup_read_vg(cmd, NULL, restorefile))) { log_error("Unable to read volume group from %s", restorefile); return ECMD_FAILED; } init_partial(0); if (!(existing_pv = find_pv_in_vg_by_uuid(vg, idp))) { log_error("Can't find uuid %s in backup file %s", uuid, restorefile); return ECMD_FAILED; } pe_start = pv_pe_start(existing_pv); extent_size = pv_pe_size(existing_pv); extent_count = pv_pe_count(existing_pv); } if (!lock_vol(cmd, ORPHAN, LCK_VG_WRITE)) { log_error("Can't get lock for orphan PVs"); return ECMD_FAILED; } if (!pvcreate_check(cmd, pv_name)) goto error; if (sigint_caught()) goto error; if (arg_sign_value(cmd, physicalvolumesize_ARG, 0) == SIGN_MINUS) { log_error("Physical volume size may not be negative"); goto error; } size = arg_uint64_value(cmd, physicalvolumesize_ARG, UINT64_C(0)) * 2; if (arg_sign_value(cmd, metadatasize_ARG, 0) == SIGN_MINUS) { log_error("Metadata size may not be negative"); goto error; } pvmetadatasize = arg_uint64_value(cmd, metadatasize_ARG, UINT64_C(0)) * 2; if (!pvmetadatasize) pvmetadatasize = find_config_tree_int(cmd, "metadata/pvmetadatasize", DEFAULT_PVMETADATASIZE); pvmetadatacopies = arg_int_value(cmd, metadatacopies_ARG, -1); if (pvmetadatacopies < 0) pvmetadatacopies = find_config_tree_int(cmd, "metadata/pvmetadatacopies", DEFAULT_PVMETADATACOPIES); if (!(dev = dev_cache_get(pv_name, cmd->filter))) { log_error("%s: Couldn't find device. Check your filters?", pv_name); goto error; } list_init(&mdas); if (!(pv = pv_create(cmd->fmt, dev, idp, size, pe_start, extent_count, extent_size, pvmetadatacopies, pvmetadatasize, &mdas))) { log_error("Failed to setup physical volume \"%s\"", pv_name); goto error; } log_verbose("Set up physical volume for \"%s\" with %" PRIu64 " available sectors", pv_name, pv_size(pv)); /* Wipe existing label first */ if (!label_remove(pv_dev(pv))) { log_error("Failed to wipe existing label on %s", pv_name); goto error; } if (pp->zero) { log_verbose("Zeroing start of device %s", pv_name); if (!dev_open_quiet(dev)) { log_error("%s not opened: device not zeroed", pv_name); goto error; } if (!dev_set(dev, UINT64_C(0), (size_t) 2048, 0)) { log_error("%s not wiped: aborting", pv_name); dev_close(dev); goto error; } dev_close(dev); } log_very_verbose("Writing physical volume data to disk \"%s\"", pv_name); if (!(pv_write(cmd, (struct physical_volume *)pv, &mdas, arg_int64_value(cmd, labelsector_ARG, DEFAULT_LABELSECTOR)))) { log_error("Failed to write physical volume \"%s\"", pv_name); goto error; } log_print("Physical volume \"%s\" successfully created", pv_name); unlock_vg(cmd, ORPHAN); return ECMD_PROCESSED; error: unlock_vg(cmd, ORPHAN); return ECMD_FAILED; }