void view_event(icalcomponent* calendar) { //Ask user if they want null fields in addition to filled ones bool show_null_fields_too = yes_no_prompt("Do you want to view empty fields? (y/n)"); icalcomponent* event = find_event(calendar); if (event == NULL) { append_action_to_closed_log("View event", false); } //Once user selects desired one, displays all needed fields icalproperty* p; for(p = icalcomponent_get_first_property(event,ICAL_ANY_PROPERTY); p != 0; p = icalcomponent_get_next_property(event,ICAL_ANY_PROPERTY)) { if ((icalproperty_get_comment(p) != NULL) || (show_null_fields_too)) { cout << icalproperty_get_x_name(p) << ": "; cout << icalproperty_get_comment(p) << endl; } } append_action_to_closed_log("View event", true); }
static int _wipe_signature(struct device *dev, const char *type, const char *name, int wipe_len, int yes, force_t force, int *wiped, int (*signature_detection_fn)(struct device *dev, uint64_t *offset_found)) { int wipe; uint64_t offset_found; wipe = signature_detection_fn(dev, &offset_found); if (wipe == -1) { log_error("Fatal error while trying to detect %s on %s.", type, name); return 0; } if (wipe == 0) return 1; /* Specifying --yes => do not ask. */ if (!yes && (force == PROMPT) && yes_no_prompt("WARNING: %s detected on %s. Wipe it? [y/n]: ", type, name) == 'n') { log_error("Aborted wiping of %s.", type); return 0; } log_print_unless_silent("Wiping %s on %s.", type, name); if (!dev_set(dev, offset_found, wipe_len, 0)) { log_error("Failed to wipe %s on %s.", type, name); return 0; } (*wiped)++; return 1; }
/* * Decide whether it is "safe" to wipe the labels on this device. * 0 indicates we may not. */ static int pvremove_check(struct cmd_context *cmd, const char *name) { struct physical_volume *pv; /* is the partition type set correctly ? */ if ((arg_count(cmd, force_ARG) < 1) && !is_lvm_partition(name)) { log_error("%s: Not LVM partition type: use -f to override", name); return 0; } /* Is there a pv here already? */ /* If not, this is an error unless you used -f. */ if (!(pv = pv_read(cmd, name, NULL, NULL, 1))) { if (arg_count(cmd, force_ARG)) return 1; log_error("Physical Volume %s not found", name); return 0; } /* orphan ? */ if (is_orphan(pv)) return 1; /* Allow partial & exported VGs to be destroyed. */ /* we must have -ff to overwrite a non orphan */ if (arg_count(cmd, force_ARG) < 2) { log_error("Can't pvremove physical volume \"%s\" of " "volume group \"%s\" without -ff", name, pv_vg_name(pv)); return 0; } /* prompt */ if (!arg_count(cmd, yes_ARG) && yes_no_prompt(_really_wipe, name, pv_vg_name(pv)) == 'n') { log_print("%s: physical volume label not removed", name); return 0; } if (arg_count(cmd, force_ARG)) { log_warn("WARNING: Wiping physical volume label from " "%s%s%s%s", name, !is_orphan(pv) ? " of volume group \"" : "", !is_orphan(pv) ? pv_vg_name(pv) : "", !is_orphan(pv) ? "\"" : ""); } return 1; }
void delete_event(icalcomponent* calendar) { icalcomponent* event = find_event(calendar); if (!yes_no_prompt("Are you sure you want to delete this event? (y/n")) { return; } //Find the event in the components icalcomponent* c = icalcomponent_get_first_component(calendar, ICAL_VEVENT_COMPONENT); bool found_event = false; while((c=icalcomponent_get_current_component(c)) != 0 ) { if(icalcomponent_isa(c) == ICAL_VEVENT_COMPONENT) { if (c == event) { icalcomponent_remove_component(calendar, c); found_event = true; } }else { icalcomponent_get_next_component(calendar, ICAL_VEVENT_COMPONENT); } } if (!found_event) { append_action_to_closed_log("Delete event", false); return; } append_action_to_closed_log("Delete event", true); }
int main() { vector<string> classes; //the first line of the ics7 file contains the elements of this icalproperty_set_x_name(ical_x_class_prop, "X-CLASS"); icalcomponent* calendar = NULL; struct icaltimetype atime; struct icalperiodtype rtime; //FIXME Later versions will try to load from the default file here //If we don't have a saved calendar, make a new one if (calendar == NULL) { atime = icaltime_from_timet( time(0),0); rtime.start = icaltime_from_timet( time(0),0); rtime.end = icaltime_from_timet( time(0),0); rtime.end.hour++; calendar = icalcomponent_new(ICAL_VCALENDAR_COMPONENT); } //FIXME Find all non-school days by prompt? //FIXME Ask for start/end of semester //Actually manipulating the calendar while (true) { //Prompt for user action cout << "What would you like to do?\n" << "1. Add a class\n" << "2. Add an event\n" << "3. Delete an event\n" << "4. Edit an event\n" << "5. Find an event\n" << "6. View an event\n" << "7. Delete a class\n" << "8. Exit the program\n" << endl; cout << "Enter the integer corresponding to your choice" << endl; string user_choice = ""; cin >> user_choice; bool user_choice_flag = true; //Check the string is all digits for (int i = 0; i < user_choice.size(); i++) { if (!isdigit(user_choice[i])) { cout << "Invalid selection (Not all digits)" << endl; user_choice_flag = false; break; } } if (!user_choice_flag) { continue; } //Given the choice, perform the desired action switch (atoi(user_choice.c_str())) { //ADD CLASS case 1: { add_class(calendar, classes); break; } //ADD EVENT (for a class or in general) case 2: { add_event(calendar); break; } //DELETE SINGLE EVENT case 3: { delete_event(calendar); break; } //EDIT EVENT (class or general) case 4: { edit_event(calendar); break; } //FIND EVENT case 5: { icalcomponent* event = find_event(calendar); if (event == NULL) { append_action_to_closed_log("Find event", false); }else { append_action_to_closed_log("Find event", true); } break; } //VIEW EVENT case 6: { view_event(calendar); break; } //DELETE CLASS //FIXME Not implemented in this sprint case 7: { //FIXME Ask for class name //FIXME Scan through first level of components for class //FIXME Print all matches and get the one to delete //FIXME Warn that all events for that class will be deleted //FIXME Delete class after user okay cout << "This feature is not implemented in this sprint." << endl; break; } //EXIT case 8: { //Prompt for okay if (yes_no_prompt("Your calendar data will not be saved. Continue? (y/n)")) { return 0; } break; } default: { cout << "Invalid selection (Not between 1 and 8 inclusive)" << endl; break; } } } return 0; }
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 lvchange_resync(struct cmd_context *cmd, struct logical_volume *lv) { int active = 0; int monitored; struct lvinfo info; struct logical_volume *log_lv; if (!(lv->status & MIRRORED)) { log_error("Unable to resync %s because it is not mirrored.", lv->name); return 1; } if (lv->status & PVMOVE) { log_error("Unable to resync pvmove volume %s", lv->name); return 0; } if (lv->status & LOCKED) { log_error("Unable to resync locked volume %s", lv->name); return 0; } if (lv_info(cmd, lv, 0, &info, 1, 0)) { if (info.open_count) { log_error("Can't resync open logical volume \"%s\"", lv->name); return 0; } if (info.exists) { if (!arg_count(cmd, yes_ARG) && yes_no_prompt("Do you really want to deactivate " "logical volume %s to resync it? [y/n]: ", lv->name) == 'n') { log_error("Logical volume \"%s\" not resynced", lv->name); return 0; } if (sigint_caught()) return 0; active = 1; } } /* Activate exclusively to ensure no nodes still have LV active */ monitored = dmeventd_monitor_mode(); init_dmeventd_monitor(0); if (!deactivate_lv(cmd, lv)) { log_error("Unable to deactivate %s for resync", lv->name); return 0; } if (vg_is_clustered(lv->vg) && lv_is_active(lv)) { log_error("Can't get exclusive access to clustered volume %s", lv->name); return 0; } init_dmeventd_monitor(monitored); log_lv = first_seg(lv)->log_lv; log_very_verbose("Starting resync of %s%s%s mirror \"%s\"", (active) ? "active " : "", vg_is_clustered(lv->vg) ? "clustered " : "", (log_lv) ? "disk-logged" : "core-logged", lv->name); /* * If this mirror has a core log (i.e. !log_lv), * then simply deactivating/activating will cause * it to reset the sync status. We only need to * worry about persistent logs. */ if (!log_lv && !(lv->status & LV_NOTSYNCED)) { if (active && !activate_lv(cmd, lv)) { log_error("Failed to reactivate %s to resynchronize " "mirror", lv->name); return 0; } return 1; } lv->status &= ~LV_NOTSYNCED; if (log_lv) { /* Separate mirror log so we can clear it */ detach_mirror_log(first_seg(lv)); if (!vg_write(lv->vg)) { log_error("Failed to write intermediate VG metadata."); if (!attach_mirror_log(first_seg(lv), log_lv)) stack; if (active && !activate_lv(cmd, lv)) stack; return 0; } if (!vg_commit(lv->vg)) { log_error("Failed to commit intermediate VG metadata."); if (!attach_mirror_log(first_seg(lv), log_lv)) stack; if (active && !activate_lv(cmd, lv)) stack; return 0; } backup(lv->vg); if (!activate_lv(cmd, log_lv)) { log_error("Unable to activate %s for mirror log resync", log_lv->name); return 0; } log_very_verbose("Clearing log device %s", log_lv->name); if (!set_lv(cmd, log_lv, log_lv->size, 0)) { log_error("Unable to reset sync status for %s", lv->name); if (!deactivate_lv(cmd, log_lv)) log_error("Failed to deactivate log LV after " "wiping failed"); return 0; } if (!deactivate_lv(cmd, log_lv)) { log_error("Unable to deactivate log LV %s after wiping " "for resync", log_lv->name); return 0; } /* Put mirror log back in place */ if (!attach_mirror_log(first_seg(lv), log_lv)) stack; } log_very_verbose("Updating logical volume \"%s\" on disk(s)", lv->name); if (!vg_write(lv->vg) || !vg_commit(lv->vg)) { log_error("Failed to update metadata on disk."); return 0; } if (active && !activate_lv(cmd, lv)) { log_error("Failed to reactivate %s after resync", lv->name); return 0; } return 1; }
static int _blkid_wipe(blkid_probe probe, struct device *dev, const char *name, uint32_t types_to_exclude, uint32_t types_no_prompt, int yes, force_t force) { static const char _msg_failed_offset[] = "Failed to get offset of the %s signature on %s."; static const char _msg_failed_length[] = "Failed to get length of the %s signature on %s."; static const char _msg_wiping[] = "Wiping %s signature on %s."; const char *offset = NULL, *type = NULL, *magic = NULL, *usage = NULL, *label = NULL, *uuid = NULL; loff_t offset_value; size_t len; if (!blkid_probe_lookup_value(probe, "TYPE", &type, NULL)) { if (_type_in_flag_list(type, types_to_exclude)) return 2; if (blkid_probe_lookup_value(probe, "SBMAGIC_OFFSET", &offset, NULL)) { log_error(_msg_failed_offset, type, name); return 0; } if (blkid_probe_lookup_value(probe, "SBMAGIC", &magic, &len)) { log_error(_msg_failed_length, type, name); return 0; } } else if (!blkid_probe_lookup_value(probe, "PTTYPE", &type, NULL)) { if (blkid_probe_lookup_value(probe, "PTMAGIC_OFFSET", &offset, NULL)) { log_error(_msg_failed_offset, type, name); return 0; } if (blkid_probe_lookup_value(probe, "PTMAGIC", &magic, &len)) { log_error(_msg_failed_length, type, name); return 0; } usage = "partition table"; } else return_0; offset_value = strtoll(offset, NULL, 10); if (!usage) (void) blkid_probe_lookup_value(probe, "USAGE", &usage, NULL); (void) blkid_probe_lookup_value(probe, "LABEL", &label, NULL); (void) blkid_probe_lookup_value(probe, "UUID", &uuid, NULL); /* Return values ignored here, in the worst case we print NULL */ log_verbose("Found existing signature on %s at offset %s: LABEL=\"%s\" " "UUID=\"%s\" TYPE=\"%s\" USAGE=\"%s\"", name, offset, label, uuid, type, usage); if (!_type_in_flag_list(type, types_no_prompt)) { if (!yes && (force == PROMPT) && yes_no_prompt("WARNING: %s signature detected on %s at offset %s. " "Wipe it? [y/n]: ", type, name, offset) == 'n') { log_error("Aborted wiping of %s.", type); return 0; } log_print_unless_silent(_msg_wiping, type, name); } else log_verbose(_msg_wiping, type, name); if (!dev_set(dev, offset_value, len, 0)) { log_error("Failed to wipe %s signature on %s.", type, name); return 0; } return 1; }
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; }
void add_event(icalcomponent* calendar) { string class_name; //Ask if the event is for a class bool is_class_event = yes_no_prompt("Is this event for a class? (y/n)"); //FIXME Following not implemented in this sprint if (is_class_event) { //FIXME If event for class, make sure the semester is not over //FIXME If the semester is over, notify the user //If event for class, prompt for class id cout << "What is the name of this class?" << endl; cin >> class_name; } //List each property field one at a time cout << "Enter information for each of the following properties." << endl; string all_props[] = {"ATTACH", "ATTENDEE", "CATEGORIES", "CLASS", "COMMENT", "CONTACT", "CREATED", "DESCRIPTION", "DTEND", "DTSTAMP", "DTSTART", "DURATION", "EXDATE", "EXRULE", "GEO", "LAST-MOD", "LOCATION", "ORGANIZER", "PRIORITY", "RDATE", "RECURID", "RELATED", "RESOURCES", "RRULE", "RSTATUS", "SEQ", "STATUS", "SUMMARY", "TRANSP", "UID", "URL"}; vector<string> values; for (int i = 0; i < 31; i++) { cout << all_props[i] << ": "; flush(cout); string value = ""; getline(cin, value); //FIXME Check for failbit //FIXME Take user input and validate values.push_back(value); cout << endl; } //If event for class, add property X-CLASS string value = ""; if (is_class_event) { cout << "X-CLASS: "; flush(cout); getline(cin, value); //FIXME Check for failbit //FIXME Take user input and validate values.push_back(value); cout << endl; } struct icaltimetype atime = icaltime_from_timet(time(0), 0); //Add the values to the event icalcomponent* event = icalcomponent_vanew( ICAL_VEVENT_COMPONENT, icalproperty_new_dtstamp(atime), icalproperty_new_contact(values[5].c_str()), icalproperty_new_comment(values[4].c_str()), icalproperty_vanew_attach( NULL, //FIXME is this the file encoding? values[0].c_str(), 0 ), //FIXME icalproperty_new_duration(values[11].c_str()), //FIXME icalproperty_new_exdate(values[13].c_str()), //FIXME icalproperty_new_geo(values[14].c_str()), //FIXME icalproperty_new_lastmod(values[15].c_str()), icalproperty_new_priority(atoi(values[18].c_str())), //FIXME icalproperty_vanew_recurid(), //FIXME icalproperty_vanew_related(), //FIXME icalproperty_vanew_resources(), //FIXME icalproperty_vanew_sequence(), //FIXME icalproperty_new_rrule(values[23].c_str()), //FIXME icalproperty_new_status(values[26].c_str()), //FIXME icalproperty_new_rstatus() may not exist... /*FIXME icalproperty_vanew_rdate( values[15].c_str(), icalparameter_new_tzid("US-Central"), //FIXME should get timezone from user 0 ),*/ /*FIXME icalproperty_vanew_exdate( values[12].c_str(), icalparameter_new_tzid("US-Central"), //FIXME should get timezone from user 0 ),*/ //FIXME icalproperty_new_transp(values[28].c_str()), icalproperty_new_uid(values[29].c_str()), icalproperty_new_url(values[30].c_str()), icalproperty_vanew_organizer( values[17].c_str(), icalparameter_new_role(ICAL_ROLE_CHAIR), //FIXME overwrites user settings 0 ), icalproperty_vanew_attendee( values[1].c_str(), icalparameter_new_role(ICAL_ROLE_REQPARTICIPANT), //FIXME overwrites user settings //FIXME icalparameter_new_rsvp(1), //FIXME overwrites user settings icalparameter_new_cutype(ICAL_CUTYPE_GROUP), //FIXME overwrites user settings 0 ), icalproperty_new_description(values[7].c_str()), icalproperty_new_categories(values[2].c_str()), icalproperty_new_class(ICAL_CLASS_PUBLIC), //FIXME overwrites user settings icalproperty_new_created(atime), //FIXME overwrites user settings icalproperty_new_summary(values[27].c_str()), icalproperty_vanew_dtstart( atime, //FIXME overwrites user settings icalparameter_new_tzid("US-Central"), //FIXME should get timezone from user 0 ), icalproperty_vanew_dtend( atime, //FIXME overwrites user settings icalparameter_new_tzid("US-Central"), //FIXME should get timezone from user 0 ), icalproperty_new_location(values[16].c_str()), 0 ); if (is_class_event) { icalproperty* p; icalproperty_set_x(p, value.c_str()); icalcomponent_add_property(event, p); } //Add component event to calendar icalcomponent_add_component(calendar,event); //FIXME Handle alarm threads (to be implemented later) append_action_to_closed_log("Add Event", true); }
static int lvremove_single(struct cmd_context *cmd, struct logical_volume *lv, void *handle) // __attribute((unused))) { struct volume_group *vg; struct lvinfo info; struct logical_volume *origin = NULL; vg = lv->vg; if (!vg_check_status(vg, LVM_WRITE)) return ECMD_FAILED; if (lv_is_origin(lv)) { log_error("Can't remove logical volume \"%s\" under snapshot", lv->name); return ECMD_FAILED; } if (lv->status & MIRROR_IMAGE) { log_error("Can't remove logical volume %s used by a mirror", lv->name); return ECMD_FAILED; } if (lv->status & MIRROR_LOG) { log_error("Can't remove logical volume %s used as mirror log", lv->name); return ECMD_FAILED; } if (lv->status & LOCKED) { log_error("Can't remove locked LV %s", lv->name); return ECMD_FAILED; } /* FIXME Ensure not referred to by another existing LVs */ if (lv_info(cmd, lv, &info, 1)) { if (info.open_count) { log_error("Can't remove open logical volume \"%s\"", lv->name); return ECMD_FAILED; } if (info.exists && !arg_count(cmd, force_ARG)) { if (yes_no_prompt("Do you really want to remove active " "logical volume \"%s\"? [y/n]: ", lv->name) == 'n') { log_print("Logical volume \"%s\" not removed", lv->name); return ECMD_FAILED; } } } if (!archive(vg)) return ECMD_FAILED; /* If the VG is clustered then make sure no-one else is using the LV we are about to remove */ if (vg_status(vg) & CLUSTERED) { if (!activate_lv_excl(cmd, lv)) { log_error("Can't get exclusive access to volume \"%s\"", lv->name); return ECMD_FAILED; } } /* FIXME Snapshot commit out of sequence if it fails after here? */ if (!deactivate_lv(cmd, lv)) { log_error("Unable to deactivate logical volume \"%s\"", lv->name); return ECMD_FAILED; } if (lv_is_cow(lv)) { origin = origin_from_cow(lv); log_verbose("Removing snapshot %s", lv->name); if (!vg_remove_snapshot(lv)) { stack; return ECMD_FAILED; } } log_verbose("Releasing logical volume \"%s\"", lv->name); if (!lv_remove(lv)) { log_error("Error releasing logical volume \"%s\"", lv->name); return ECMD_FAILED; } /* store it on disks */ if (!vg_write(vg)) return ECMD_FAILED; backup(vg); if (!vg_commit(vg)) return ECMD_FAILED; /* If no snapshots left, reload without -real. */ if (origin && !lv_is_origin(origin)) { if (!suspend_lv(cmd, origin)) log_error("Failed to refresh %s without snapshot.", origin->name); else if (!resume_lv(cmd, origin)) log_error("Failed to resume %s.", origin->name); } log_print("Logical volume \"%s\" successfully removed", lv->name); return ECMD_PROCESSED; }
/* * Decide whether it is "safe" to wipe the labels on this device. * 0 indicates we may not. */ static int pvremove_check(struct cmd_context *cmd, const char *name) { struct physical_volume *pv; struct dm_list mdas; dm_list_init(&mdas); /* FIXME Check partition type is LVM unless --force is given */ /* Is there a pv here already? */ /* If not, this is an error unless you used -f. */ if (!(pv = pv_read(cmd, name, &mdas, NULL, 1, 0))) { if (arg_count(cmd, force_ARG)) return 1; log_error("Physical Volume %s not found", name); return 0; } /* * If a PV has no MDAs it may appear to be an * orphan until the metadata is read off * another PV in the same VG. Detecting this * means checking every VG by scanning every * PV on the system. */ if (is_orphan(pv) && !dm_list_size(&mdas)) { if (!scan_vgs_for_pvs(cmd)) { log_error("Rescan for PVs without metadata areas " "failed."); return 0; } if (!(pv = pv_read(cmd, name, NULL, NULL, 1, 0))) { log_error("Failed to read physical volume %s", name); return 0; } } /* orphan ? */ if (is_orphan(pv)) return 1; /* Allow partial & exported VGs to be destroyed. */ /* we must have -ff to overwrite a non orphan */ if (arg_count(cmd, force_ARG) < 2) { log_error("Can't pvremove physical volume \"%s\" of " "volume group \"%s\" without -ff", name, pv_vg_name(pv)); return 0; } /* prompt */ if (!arg_count(cmd, yes_ARG) && yes_no_prompt(_really_wipe, name, pv_vg_name(pv)) == 'n') { log_error("%s: physical volume label not removed", name); return 0; } if (arg_count(cmd, force_ARG)) { log_warn("WARNING: Wiping physical volume label from " "%s%s%s%s", name, !is_orphan(pv) ? " of volume group \"" : "", !is_orphan(pv) ? pv_vg_name(pv) : "", !is_orphan(pv) ? "\"" : ""); } return 1; }
/* * Decide whether it is "safe" to wipe the labels on this device. * 0 indicates we may not. */ static int pvremove_check(struct cmd_context *cmd, const char *name) { struct physical_volume *pv; /* FIXME Check partition type is LVM unless --force is given */ /* Is there a pv here already? */ /* If not, this is an error unless you used -f. */ if (!(pv = pv_read(cmd, name, 1, 0))) { if (arg_count(cmd, force_ARG)) return 1; log_error("Physical Volume %s not found", name); return 0; } /* * If a PV has no MDAs it may appear to be an * orphan until the metadata is read off * another PV in the same VG. Detecting this * means checking every VG by scanning every * PV on the system. */ if (is_orphan(pv) && !dm_list_size(&pv->fid->metadata_areas_in_use) && !dm_list_size(&pv->fid->metadata_areas_ignored)) { if (!scan_vgs_for_pvs(cmd, 0)) { log_error("Rescan for PVs without metadata areas " "failed."); goto bad; } free_pv_fid(pv); if (!(pv = pv_read(cmd, name, 1, 0))) { log_error("Failed to read physical volume %s", name); goto bad; } } /* orphan ? */ if (is_orphan(pv)) { free_pv_fid(pv); return 1; } /* Allow partial & exported VGs to be destroyed. */ /* we must have -ff to overwrite a non orphan */ if (arg_count(cmd, force_ARG) < 2) { log_error("PV %s belongs to Volume Group %s so please use vgreduce first.", name, pv_vg_name(pv)); log_error("(If you are certain you need pvremove, then confirm by using --force twice.)"); goto bad; } /* prompt */ if (!arg_count(cmd, yes_ARG) && yes_no_prompt(_really_wipe, name, pv_vg_name(pv)) == 'n') { log_error("%s: physical volume label not removed", name); goto bad; } if (arg_count(cmd, force_ARG)) { log_warn("WARNING: Wiping physical volume label from " "%s%s%s%s", name, !is_orphan(pv) ? " of volume group \"" : "", !is_orphan(pv) ? pv_vg_name(pv) : "", !is_orphan(pv) ? "\"" : ""); } free_pv_fid(pv); return 1; bad: free_pv_fid(pv); return 0; }
/* * See if we may pvcreate on this device. * 0 indicates we may not. */ static int pvcreate_check(struct cmd_context *cmd, const char *name) { struct physical_volume *pv; struct device *dev; uint64_t md_superblock; /* is the partition type set correctly ? */ if ((arg_count(cmd, force_ARG) < 1) && !is_lvm_partition(name)) { log_error("%s: Not LVM partition type: use -f to override", name); return 0; } /* Is there a pv here already? */ /* FIXME Use partial mode here? */ pv = pv_read(cmd, name, NULL, NULL, 0); /* Allow partial & exported VGs to be destroyed. */ /* We must have -ff to overwrite a non orphan */ if (pv && !is_orphan(pv) && arg_count(cmd, force_ARG) != 2) { log_error("Can't initialize physical volume \"%s\" of " "volume group \"%s\" without -ff", name, pv_vg_name(pv)); return 0; } /* prompt */ if (pv && !is_orphan(pv) && !arg_count(cmd, yes_ARG) && yes_no_prompt(_really_init, name, pv_vg_name(pv)) == 'n') { log_print("%s: physical volume not initialized", name); return 0; } if (sigint_caught()) return 0; dev = dev_cache_get(name, cmd->filter); /* Is there an md superblock here? */ if (!dev && md_filtering()) { unlock_vg(cmd, ORPHAN); persistent_filter_wipe(cmd->filter); lvmcache_destroy(); init_md_filtering(0); if (!lock_vol(cmd, ORPHAN, LCK_VG_WRITE)) { log_error("Can't get lock for orphan PVs"); init_md_filtering(1); return 0; } dev = dev_cache_get(name, cmd->filter); init_md_filtering(1); } if (!dev) { log_error("Device %s not found (or ignored by filtering).", name); return 0; } if (!dev_test_excl(dev)) { log_error("Can't open %s exclusively. Mounted filesystem?", name); return 0; } /* Wipe superblock? */ if (dev_is_md(dev, &md_superblock) && ((!arg_count(cmd, uuidstr_ARG) && !arg_count(cmd, restorefile_ARG)) || arg_count(cmd, yes_ARG) || (yes_no_prompt("Software RAID md superblock " "detected on %s. Wipe it? [y/n] ", name) == 'y'))) { log_print("Wiping software RAID md superblock on %s", name); if (!dev_set(dev, md_superblock, 4, 0)) { log_error("Failed to wipe RAID md superblock on %s", name); return 0; } } if (sigint_caught()) return 0; if (pv && !is_orphan(pv) && arg_count(cmd, force_ARG)) { log_warn("WARNING: Forcing physical volume creation on " "%s%s%s%s", name, !is_orphan(pv) ? " of volume group \"" : "", !is_orphan(pv) ? pv_vg_name(pv) : "", !is_orphan(pv) ? "\"" : ""); } return 1; }