static void treatstackoption (lv_State *L, lv_State *L1, const char *fname) { if (L == L1) { lv_pushvalue(L, -2); lv_remove(L, -3); } else lv_xmove(L1, L, 1); lv_setfield(L, -2, fname); }
int vg_remove_snapshot(struct logical_volume *cow) { int preload_origin = 0; struct logical_volume *origin = origin_from_cow(cow); dm_list_del(&cow->snapshot->origin_list); origin->origin_count--; if (find_merging_cow(origin) == find_cow(cow)) { clear_snapshot_merge(origin); /* * preload origin IFF "snapshot-merge" target is active * - IMPORTANT: avoids preload if onactivate merge is pending */ if (lv_has_target_type(origin->vg->cmd->mem, origin, NULL, "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. */ preload_origin = 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); if (preload_origin) { if (!vg_write(origin->vg)) return_0; if (!suspend_lv(origin->vg->cmd, origin)) { log_error("Failed to refresh %s without snapshot.", origin->name); return 0; } if (!vg_commit(origin->vg)) return_0; if (!resume_lv(origin->vg->cmd, origin)) { log_error("Failed to resume %s.", origin->name); return 0; } } return 1; }
int vg_remove_snapshot(struct logical_volume *cow) { dm_list_del(&cow->snapshot->origin_list); cow->snapshot->origin->origin_count--; 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); return 1; }
static int db_gethook (lv_State *L) { int arg; lv_State *L1 = getthread(L, &arg); char buff[5]; int mask = lv_gethookmask(L1); lv_Hook hook = lv_gethook(L1); if (hook != NULL && hook != hookf) /* external hook? */ lv_pushliteral(L, "external hook"); else { gethooktable(L); lv_pushlightuserdata(L, L1); lv_rawget(L, -2); /* get hook */ lv_remove(L, -2); /* remove hook table */ } lv_pushstring(L, unmakemask(mask, buff)); lv_pushinteger(L, lv_gethookcount(L1)); return 3; }
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 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; }
/* * lv_cache_remove * @cache_lv * * Given a cache LV, remove the cache layer. This will unlink * the origin and cache_pool, remove the cache LV layer, and promote * the origin to a usable non-cached LV of the same name as the * given cache_lv. * * Returns: 1 on success, 0 on failure */ int lv_cache_remove(struct logical_volume *cache_lv) { struct cmd_context *cmd = cache_lv->vg->cmd; const char *policy_name; uint64_t dirty_blocks; struct lv_segment *cache_seg = first_seg(cache_lv); struct logical_volume *corigin_lv; struct logical_volume *cache_pool_lv; if (!lv_is_cache(cache_lv)) { log_error(INTERNAL_ERROR "LV %s is not cached.", cache_lv->name); return 0; } /* Active volume is needed (writeback only?) */ if (!lv_is_active_locally(cache_lv) && !activate_lv_excl_local(cache_lv->vg->cmd, cache_lv)) { log_error("Failed to active cache locally %s.", cache_lv->name); return 0; } /* * FIXME: * Before the link can be broken, we must ensure that the * cache has been flushed. This may already be the case * if the cache mode is writethrough (or the cleaner * policy is in place from a previous half-finished attempt * to remove the cache_pool). It could take a long time to * flush the cache - it should probably be done in the background. * * Also, if we do perform the flush in the background and we * happen to also be removing the cache/origin LV, then we * could check if the cleaner policy is in place and simply * remove the cache_pool then without waiting for the flush to * complete. */ if (!lv_cache_policy_info(cache_lv, &policy_name, NULL, NULL)) return_0; if (strcmp(policy_name, "cleaner")) { /* We must swap in the cleaner to flush the cache */ log_print_unless_silent("Flushing cache for %s.", cache_lv->name); /* * Is there are clean way to free the memory for the name * and argv when changing the policy? */ cache_seg->policy_name = "cleaner"; cache_seg->policy_argc = 0; cache_seg->policy_argv = NULL; /* update the kernel to put the cleaner policy in place */ if (!vg_write(cache_lv->vg)) return_0; if (!suspend_lv(cmd, cache_lv)) return_0; if (!vg_commit(cache_lv->vg)) return_0; if (!resume_lv(cmd, cache_lv)) return_0; } //FIXME: use polling to do this... do { if (!lv_cache_block_info(cache_lv, NULL, &dirty_blocks, NULL, NULL)) return_0; log_print_unless_silent("%" PRIu64 " blocks must still be flushed.", dirty_blocks); if (dirty_blocks) sleep(1); } while (dirty_blocks); cache_pool_lv = cache_seg->pool_lv; if (!detach_pool_lv(cache_seg)) return_0; /* Regular LV which user may remove if there are problems */ corigin_lv = seg_lv(cache_seg, 0); lv_set_visible(corigin_lv); if (!remove_layer_from_lv(cache_lv, corigin_lv)) return_0; if (!vg_write(cache_lv->vg)) return_0; /* * suspend_lv on this cache LV suspends all components: * - the top-level cache LV * - the origin * - the cache_pool _cdata and _cmeta */ if (!suspend_lv(cmd, cache_lv)) return_0; if (!vg_commit(cache_lv->vg)) return_0; /* resume_lv on this (former) cache LV will resume all */ /* * FIXME: currently we can't easily avoid execution of * blkid on resumed error device */ if (!resume_lv(cmd, cache_lv)) return_0; /* * cleanup orphan devices * * FIXME: * fix _add_dev() to support this case better * since the should be handled interanlly by resume_lv() * which should autoremove any orhpans */ if (!_cleanup_orphan_lv(corigin_lv)) /* _corig */ return_0; if (!_cleanup_orphan_lv(seg_lv(first_seg(cache_pool_lv), 0))) /* _cdata */ return_0; if (!_cleanup_orphan_lv(first_seg(cache_pool_lv)->metadata_lv)) /* _cmeta */ return_0; if (!lv_remove(corigin_lv)) return_0; return 1; }