int pvcreate(struct cmd_context *cmd, int argc, char **argv) { int i; int ret = ECMD_PROCESSED; struct pvcreate_params pp; pvcreate_params_set_defaults(&pp); if (!pvcreate_restore_params_validate(cmd, argc, argv, &pp)) { return EINVALID_CMD_LINE; } if (!pvcreate_params_validate(cmd, argc, argv, &pp)) { return EINVALID_CMD_LINE; } for (i = 0; i < argc; i++) { if (sigint_caught()) return_ECMD_FAILED; dm_unescape_colons_and_at_signs(argv[i], NULL, NULL); if (ECMD_PROCESSED != pvcreate_locked(cmd, argv[i], &pp)) { ret = ECMD_FAILED; } } return ret; }
int pvcreate(struct cmd_context *cmd, int argc, char **argv) { int i; int ret = ECMD_PROCESSED; struct pvcreate_params pp; struct physical_volume *pv; pvcreate_params_set_defaults(&pp); if (!pvcreate_restore_params_validate(cmd, argc, argv, &pp)) { return EINVALID_CMD_LINE; } if (!pvcreate_params_validate(cmd, argc, argv, &pp)) { return EINVALID_CMD_LINE; } for (i = 0; i < argc; i++) { if (!lock_vol(cmd, VG_ORPHANS, LCK_VG_WRITE)) { log_error("Can't get lock for orphan PVs"); return ECMD_FAILED; } dm_unescape_colons_and_at_signs(argv[i], NULL, NULL); if (!(pv = pvcreate_single(cmd, argv[i], &pp, 1))) { stack; ret = ECMD_FAILED; } unlock_vg(cmd, VG_ORPHANS); if (sigint_caught()) return ret; } return ret; }
int vgextend(struct cmd_context *cmd, int argc, char **argv) { const char *vg_name; struct volume_group *vg = NULL; int r = ECMD_FAILED; struct pvcreate_params pp; int fixed = 0, i = 0; if (!argc) { log_error("Please enter volume group name and " "physical volume(s)"); return EINVALID_CMD_LINE; } vg_name = skip_dev_dir(cmd, argv[0], NULL); argc--; argv++; if (arg_count(cmd, metadatacopies_ARG)) { log_error("Invalid option --metadatacopies, " "use --pvmetadatacopies instead."); return EINVALID_CMD_LINE; } pvcreate_params_set_defaults(&pp); if (!pvcreate_params_validate(cmd, argc, argv, &pp)) { return EINVALID_CMD_LINE; } /* * It is always ok to add new PVs to a VG - even if there are * missing PVs. No LVs are affected by this operation, but * repair processes - particularly for RAID segtypes - can * be facilitated. */ cmd->handles_missing_pvs = 1; log_verbose("Checking for volume group \"%s\"", vg_name); vg = vg_read_for_update(cmd, vg_name, NULL, 0); if (vg_read_error(vg)) { release_vg(vg); return_ECMD_FAILED; } if (!archive(vg)) goto_bad; if (arg_count(cmd, restoremissing_ARG)) { for (i = 0; i < argc; ++i) { if (_restore_pv(vg, argv[i])) ++ fixed; } if (!fixed) { log_error("No PV has been restored."); goto bad; } } else { /* no --restore, normal vgextend */ if (!lock_vol(cmd, VG_ORPHANS, LCK_VG_WRITE, NULL)) { log_error("Can't get lock for orphan PVs"); unlock_and_release_vg(cmd, vg, vg_name); return ECMD_FAILED; } if (arg_count(cmd, metadataignore_ARG) && (vg_mda_copies(vg) != VGMETADATACOPIES_UNMANAGED) && (pp.force == PROMPT) && yes_no_prompt("Override preferred number of copies " "of VG %s metadata? [y/n]: ", vg_name) == 'n') { log_error("Volume group %s not changed", vg_name); goto bad; } /* extend vg */ if (!vg_extend(vg, argc, (const char* const*)argv, &pp)) goto_bad; if (arg_count(cmd, metadataignore_ARG) && (vg_mda_copies(vg) != VGMETADATACOPIES_UNMANAGED) && (vg_mda_copies(vg) != vg_mda_used_count(vg))) { log_warn("WARNING: Changing preferred number of copies of VG %s " "metadata from %"PRIu32" to %"PRIu32, vg_name, vg_mda_copies(vg), vg_mda_used_count(vg)); vg_set_mda_copies(vg, vg_mda_used_count(vg)); } /* ret > 0 */ log_verbose("Volume group \"%s\" will be extended by %d new " "physical volumes", vg_name, argc); } /* store vg on disk(s) */ if (!vg_write(vg) || !vg_commit(vg)) goto_bad; backup(vg); log_print_unless_silent("Volume group \"%s\" successfully extended", vg_name); r = ECMD_PROCESSED; bad: if (!arg_count(cmd, restoremissing_ARG)) unlock_vg(cmd, VG_ORPHANS); unlock_and_release_vg(cmd, vg, vg_name); return r; }
int vgcreate(struct cmd_context *cmd, int argc, char **argv) { struct vgcreate_params vp_new; struct vgcreate_params vp_def; struct volume_group *vg; const char *tag; const char *clustered_message = ""; char *vg_name; struct pvcreate_params pp; if (!argc) { log_error("Please provide volume group name and " "physical volumes"); return EINVALID_CMD_LINE; } vg_name = argv[0]; argc--; argv++; pvcreate_params_set_defaults(&pp); if (!pvcreate_params_validate(cmd, argc, argv, &pp)) { return EINVALID_CMD_LINE; } vgcreate_params_set_defaults(&vp_def, NULL); vp_def.vg_name = vg_name; if (vgcreate_params_set_from_args(cmd, &vp_new, &vp_def)) return EINVALID_CMD_LINE; if (vgcreate_params_validate(cmd, &vp_new)) return EINVALID_CMD_LINE; /* Create the new VG */ vg = vg_create(cmd, vp_new.vg_name); if (vg_read_error(vg)) { if (vg_read_error(vg) == FAILED_EXIST) log_error("A volume group called %s already exists.", vp_new.vg_name); else log_error("Can't get lock for %s.", vp_new.vg_name); vg_release(vg); return ECMD_FAILED; } if (!vg_set_extent_size(vg, vp_new.extent_size) || !vg_set_max_lv(vg, vp_new.max_lv) || !vg_set_max_pv(vg, vp_new.max_pv) || !vg_set_alloc_policy(vg, vp_new.alloc) || !vg_set_clustered(vg, vp_new.clustered) || !vg_set_mda_copies(vg, vp_new.vgmetadatacopies)) goto bad_orphan; if (!lock_vol(cmd, VG_ORPHANS, LCK_VG_WRITE)) { log_error("Can't get lock for orphan PVs"); goto bad_orphan; } /* attach the pv's */ if (!vg_extend(vg, argc, argv, &pp)) goto_bad; if (vp_new.max_lv != vg->max_lv) log_warn("WARNING: Setting maxlogicalvolumes to %d " "(0 means unlimited)", vg->max_lv); if (vp_new.max_pv != vg->max_pv) log_warn("WARNING: Setting maxphysicalvolumes to %d " "(0 means unlimited)", vg->max_pv); if (arg_count(cmd, addtag_ARG)) { if (!(tag = arg_str_value(cmd, addtag_ARG, NULL))) { log_error("Failed to get tag"); goto bad; } if (!vg_change_tag(vg, tag, 1)) goto_bad; } if (vg_is_clustered(vg)) { clustered_message = "Clustered "; } else { if (locking_is_clustered()) clustered_message = "Non-clustered "; } if (!archive(vg)) goto_bad; /* Store VG on disk(s) */ if (!vg_write(vg) || !vg_commit(vg)) goto_bad; unlock_vg(cmd, VG_ORPHANS); unlock_vg(cmd, vp_new.vg_name); backup(vg); log_print("%s%colume group \"%s\" successfully created", clustered_message, *clustered_message ? 'v' : 'V', vg->name); vg_release(vg); return ECMD_PROCESSED; bad: unlock_vg(cmd, VG_ORPHANS); bad_orphan: vg_release(vg); unlock_vg(cmd, vp_new.vg_name); return ECMD_FAILED; }
int vgextend(struct cmd_context *cmd, int argc, char **argv) { char *vg_name; struct volume_group *vg = NULL; int r = ECMD_FAILED; struct pvcreate_params pp; if (!argc) { log_error("Please enter volume group name and " "physical volume(s)"); return EINVALID_CMD_LINE; } vg_name = skip_dev_dir(cmd, argv[0], NULL); argc--; argv++; if (arg_count(cmd, metadatacopies_ARG)) { log_error("Invalid option --metadatacopies, " "use --pvmetadatacopies instead."); return EINVALID_CMD_LINE; } pvcreate_params_set_defaults(&pp); if (!pvcreate_params_validate(cmd, argc, argv, &pp)) { return EINVALID_CMD_LINE; } log_verbose("Checking for volume group \"%s\"", vg_name); vg = vg_read_for_update(cmd, vg_name, NULL, 0); if (vg_read_error(vg)) { vg_release(vg); stack; return ECMD_FAILED; } if (!lock_vol(cmd, VG_ORPHANS, LCK_VG_WRITE)) { log_error("Can't get lock for orphan PVs"); unlock_and_release_vg(cmd, vg, vg_name); return ECMD_FAILED; } if (!archive(vg)) goto_bad; /* extend vg */ if (!vg_extend(vg, argc, argv, &pp)) goto_bad; /* ret > 0 */ log_verbose("Volume group \"%s\" will be extended by %d new " "physical volumes", vg_name, argc); /* store vg on disk(s) */ if (!vg_write(vg) || !vg_commit(vg)) goto_bad; backup(vg); log_print("Volume group \"%s\" successfully extended", vg_name); r = ECMD_PROCESSED; bad: unlock_vg(cmd, VG_ORPHANS); unlock_and_release_vg(cmd, vg, vg_name); return r; }
int pvcreate(struct cmd_context *cmd, int argc, char **argv) { struct processing_handle *handle; struct pvcreate_params pp; int ret; /* * Five kinds of pvcreate param values: * 1. defaults * 2. recovery-related command line args * 3. recovery-related args from backup file * 4. normal command line args * (this also checks some settings from 2 & 3) * 5. argc/argv free args specifying devices */ pvcreate_params_set_defaults(&pp); if (!_pvcreate_restore_params_from_args(cmd, argc, &pp)) return EINVALID_CMD_LINE; if (!_pvcreate_restore_params_from_backup(cmd, &pp)) return EINVALID_CMD_LINE; if (!pvcreate_params_from_args(cmd, &pp)) return EINVALID_CMD_LINE; /* * If --metadatasize was not given with --restorefile, set it to pe_start. * Later code treats this as a maximum size and reduces it to fit. */ if (!arg_is_set(cmd, metadatasize_ARG) && arg_is_set(cmd, restorefile_ARG)) pp.pva.pvmetadatasize = pp.pva.pe_start; /* FIXME Also needs to check any 2nd metadata area isn't inside the data area! */ pp.pv_count = argc; pp.pv_names = argv; /* Check for old md signatures at the end of devices. */ cmd->use_full_md_check = 1; /* * Needed to change the set of orphan PVs. * (disable afterward to prevent process_each_pv from doing * a shared global lock since it's already acquired it ex.) */ if (!lockd_gl(cmd, "ex", 0)) return_ECMD_FAILED; cmd->lockd_gl_disable = 1; clear_hint_file(cmd); if (!(handle = init_processing_handle(cmd, NULL))) { log_error("Failed to initialize processing handle."); return ECMD_FAILED; } if (!pvcreate_each_device(cmd, handle, &pp)) ret = ECMD_FAILED; else { /* pvcreate_each_device returns with orphans locked */ unlock_vg(cmd, NULL, VG_ORPHANS); ret = ECMD_PROCESSED; } destroy_processing_handle(cmd, handle); return ret; }