/* Check if given LV is usable as snapshot origin LV */ int validate_snapshot_origin(const struct logical_volume *origin_lv) { const char *err = NULL; /* For error string */ if (lv_is_cow(origin_lv)) err = "snapshots"; else if (lv_is_locked(origin_lv)) err = "locked volumes"; else if (lv_is_pvmove(origin_lv)) err = "pvmoved volumes"; else if (!lv_is_visible(origin_lv)) err = "hidden volumes"; else if (lv_is_merging_origin(origin_lv)) err = "an origin that has a merging snapshot"; else if (lv_is_cache_type(origin_lv) && !lv_is_cache(origin_lv)) err = "cache type volumes"; else if (lv_is_thin_type(origin_lv) && !lv_is_thin_volume(origin_lv)) err = "thin pool type volumes"; else if (lv_is_mirror_type(origin_lv)) { if (!lv_is_mirror(origin_lv)) err = "mirror subvolumes"; else { log_warn("WARNING: Snapshots of mirrors can deadlock under rare device failures."); log_warn("WARNING: Consider using the raid1 mirror type to avoid this."); log_warn("WARNING: See global/mirror_segtype_default in lvm.conf."); } } else if (lv_is_raid_type(origin_lv) && !lv_is_raid(origin_lv)) err = "raid subvolumes"; if (err) { log_error("Snapshots of %s are not supported.", err); return 0; } if (vg_is_clustered(origin_lv->vg) && lv_is_active(origin_lv) && !lv_is_active_exclusive_locally(origin_lv)) { log_error("Snapshot origin must be active exclusively."); 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; }
int vg_remove_snapshot(struct logical_volume *cow) { int merging_snapshot = 0; struct logical_volume *origin = origin_from_cow(cow); int is_origin_active = lv_is_active(origin); if (is_origin_active && lv_is_virtual_origin(origin)) { if (!deactivate_lv(origin->vg->cmd, origin)) { log_error("Failed to deactivate logical volume \"%s\"", origin->name); return 0; } is_origin_active = 0; } dm_list_del(&cow->snapshot->origin_list); origin->origin_count--; if (lv_is_merging_origin(origin) && (find_snapshot(origin) == find_snapshot(cow))) { clear_snapshot_merge(origin); /* * preload origin IFF "snapshot-merge" target is active * - IMPORTANT: avoids preload if inactivate merge is pending */ if (lv_has_target_type(origin->vg->vgmem, origin, NULL, TARGET_NAME_SNAPSHOT_MERGE)) { /* * preload origin to: * - allow proper release of -cow * - avoid allocations with other devices suspended * when transitioning from "snapshot-merge" to * "snapshot-origin after a merge completes. */ merging_snapshot = 1; } } if (!lv_remove(cow->snapshot->lv)) { log_error("Failed to remove internal snapshot LV %s", cow->snapshot->lv->name); return 0; } cow->snapshot = NULL; lv_set_visible(cow); /* format1 must do the change in one step, with the commit last. */ if (!(origin->vg->fid->fmt->features & FMT_MDAS)) { /* Get the lock for COW volume */ if (is_origin_active && !activate_lv(cow->vg->cmd, cow)) { log_error("Unable to activate logical volume \"%s\"", cow->name); return 0; } return 1; } if (!vg_write(origin->vg)) return_0; /* Skip call suspend, if device is not active */ if (is_origin_active && !suspend_lv(origin->vg->cmd, origin)) { log_error("Failed to refresh %s without snapshot.", origin->name); vg_revert(origin->vg); return 0; } if (!vg_commit(origin->vg)) return_0; if (is_origin_active) { /* * If the snapshot was active and the COW LV is taken away * the LV lock on cluster has to be grabbed, so use * activate_lv() which resumes suspend cow device. */ if (!merging_snapshot && !activate_lv(cow->vg->cmd, cow)) { log_error("Failed to activate %s.", cow->name); return 0; } if (!resume_lv(origin->vg->cmd, origin)) { log_error("Failed to resume %s.", origin->name); return 0; } /* * For merged snapshot and clustered VG activate cow LV so * the following call to deactivate_lv() can clean-up table * entries. For this clustered lock need to be held. */ if (vg_is_clustered(cow->vg) && merging_snapshot && !activate_lv(cow->vg->cmd, cow)) { log_error("Failed to activate %s.", cow->name); return 0; } } return 1; }
static int lvchange_pool_update(struct cmd_context *cmd, struct logical_volume *lv) { int r = 0; int update = 0; unsigned val; thin_discards_t discards; if (!lv_is_thin_pool(lv)) { log_error("Logical volume \"%s\" is not a thin pool.", lv->name); return 0; } if (arg_count(cmd, discards_ARG)) { discards = (thin_discards_t) arg_uint_value(cmd, discards_ARG, THIN_DISCARDS_IGNORE); if (discards != first_seg(lv)->discards) { if ((discards != THIN_DISCARDS_IGNORE) && (first_seg(lv)->chunk_size & (first_seg(lv)->chunk_size - 1))) log_error("Cannot change discards state for " "logical volume \"%s\" " "with non power of 2 chunk size.", lv->name); else if (((discards == THIN_DISCARDS_IGNORE) || (first_seg(lv)->discards == THIN_DISCARDS_IGNORE)) && lv_is_active(lv)) log_error("Cannot change discards state for active " "logical volume \"%s\".", lv->name); else { first_seg(lv)->discards = discards; update++; } } else log_error("Logical volume \"%s\" already uses --discards %s.", lv->name, get_pool_discards_name(discards)); } if (arg_count(cmd, zero_ARG)) { val = arg_uint_value(cmd, zero_ARG, 1); if (val != first_seg(lv)->zero_new_blocks) { first_seg(lv)->zero_new_blocks = val; update++; } else log_error("Logical volume \"%s\" already %szero new blocks.", lv->name, val ? "" : "does not "); } if (!update) return 0; log_very_verbose("Updating logical volume \"%s\" on disk(s).", lv->name); if (!vg_write(lv->vg)) return_0; if (!suspend_lv_origin(cmd, lv)) { log_error("Failed to update active %s/%s (deactivation is needed).", lv->vg->name, lv->name); vg_revert(lv->vg); goto out; } if (!vg_commit(lv->vg)) { if (!resume_lv_origin(cmd, lv)) stack; goto_out; } if (!resume_lv_origin(cmd, lv)) { log_error("Problem reactivating %s.", lv->name); goto out; } r = 1; out: backup(lv->vg); return r; }