text: /*	$NetBSD: vgsplit.c,v 1.1.1.2 2009/12/02 00:25:46 haad Exp $	*/
  
  /*
   * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
   * Copyright (C) 2004-2009 Red Hat, Inc. All rights reserved.
   *
   * This file is part of LVM2.
   *
   * This copyrighted material is made available to anyone wishing to use,
   * modify, copy, or redistribute it subject to the terms and conditions
   * of the GNU Lesser General Public License v.2.1.
   *
   * You should have received a copy of the GNU Lesser General Public License
   * along with this program; if not, write to the Free Software Foundation,
   * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   */
  
  #include "tools.h"
  
  /* FIXME Why not (lv->vg == vg) ? */
  static int _lv_is_in_vg(struct volume_group *vg, struct logical_volume *lv)
  {
  	struct lv_list *lvl;
  
  	dm_list_iterate_items(lvl, &vg->lvs)
  		if (lv == lvl->lv)
  			 return 1;
  
  	return 0;
  }
  
  static int _move_one_lv(struct volume_group *vg_from,
  			 struct volume_group *vg_to,
  			 struct dm_list *lvh)
  {
  	struct logical_volume *lv = dm_list_item(lvh, struct lv_list)->lv;
  
  	dm_list_move(&vg_to->lvs, lvh);
  
  	if (lv_is_active(lv)) {
  		log_error("Logical volume \"%s\" must be inactive", lv->name);
  		return 0;
  	}
  
  	return 1;
  }
  
  static int _move_lvs(struct volume_group *vg_from, struct volume_group *vg_to)
  {
  	struct dm_list *lvh, *lvht;
  	struct logical_volume *lv;
  	struct lv_segment *seg;
  	struct physical_volume *pv;
  	struct volume_group *vg_with;
  	unsigned s;
  
  	dm_list_iterate_safe(lvh, lvht, &vg_from->lvs) {
  		lv = dm_list_item(lvh, struct lv_list)->lv;
  
  		if ((lv->status & SNAPSHOT))
  			continue;
  
  		if ((lv->status & MIRRORED))
  			continue;
  
  		/* Ensure all the PVs used by this LV remain in the same */
  		/* VG as each other */
  		vg_with = NULL;
  		dm_list_iterate_items(seg, &lv->segments) {
  			for (s = 0; s < seg->area_count; s++) {
  				/* FIXME Check AREA_LV too */
  				if (seg_type(seg, s) != AREA_PV)
  					continue;
  
  				pv = seg_pv(seg, s);
  				if (vg_with) {
  					if (!pv_is_in_vg(vg_with, pv)) {
  						log_error("Can't split Logical "
  							  "Volume %s between "
  							  "two Volume Groups",
  							  lv->name);
  						return 0;
  					}
  					continue;
  				}
  
  				if (pv_is_in_vg(vg_from, pv)) {
  					vg_with = vg_from;
  					continue;
  				}
  				if (pv_is_in_vg(vg_to, pv)) {
  					vg_with = vg_to;
  					continue;
  				}
  				log_error("Physical Volume %s not found",
  					  pv_dev_name(pv));
  				return 0;
  			}
  
  		}
  
  		if (vg_with == vg_from)
  			continue;
  
  		/* Move this LV */
  		if (!_move_one_lv(vg_from, vg_to, lvh))
  			return_0;
  	}
  
  	/* FIXME Ensure no LVs contain segs pointing at LVs in the other VG */
  
  	return 1;
  }
  
  /*
   * Move the hidden / internal "snapshotN" LVs.from 'vg_from' to 'vg_to'.
   */
  static int _move_snapshots(struct volume_group *vg_from,
  			   struct volume_group *vg_to)
  {
  	struct dm_list *lvh, *lvht;
  	struct logical_volume *lv;
  	struct lv_segment *seg;
  	int cow_from = 0;
  	int origin_from = 0;
  
  	dm_list_iterate_safe(lvh, lvht, &vg_from->lvs) {
  		lv = dm_list_item(lvh, struct lv_list)->lv;
  
  		if (!(lv->status & SNAPSHOT))
  			continue;
  
  		dm_list_iterate_items(seg, &lv->segments) {
  			cow_from = _lv_is_in_vg(vg_from, seg->cow);
  			origin_from = _lv_is_in_vg(vg_from, seg->origin);
  
  			if (cow_from && origin_from)
  				continue;
  			if ((!cow_from && origin_from) ||
  			     (cow_from && !origin_from)) {
  				log_error("Can't split snapshot %s between"
  					  " two Volume Groups", seg->cow->name);
  				return 0;
  			}
  
  			/*
  			 * At this point, the cow and origin should already be
  			 * in vg_to.
  			 */
  			if (_lv_is_in_vg(vg_to, seg->cow) &&
  			    _lv_is_in_vg(vg_to, seg->origin)) {
  				if (!_move_one_lv(vg_from, vg_to, lvh))
  					return_0;
  			}
  		}
  
  	}
  
  	return 1;
  }
  
  static int _move_mirrors(struct volume_group *vg_from,
  			 struct volume_group *vg_to)
  {
  	struct dm_list *lvh, *lvht;
  	struct logical_volume *lv;
  	struct lv_segment *seg;
  	unsigned s, seg_in, log_in;
  
  	dm_list_iterate_safe(lvh, lvht, &vg_from->lvs) {
  		lv = dm_list_item(lvh, struct lv_list)->lv;
  
  		if (!(lv->status & MIRRORED))
  			continue;
  
  		seg = first_seg(lv);
  
  		seg_in = 0;
  		for (s = 0; s < seg->area_count; s++)
  			if (_lv_is_in_vg(vg_to, seg_lv(seg, s)))
  			    seg_in++;
  
  		log_in = (!seg->log_lv || _lv_is_in_vg(vg_to, seg->log_lv));
  
  		if ((seg_in && seg_in < seg->area_count) ||
  		    (seg_in && seg->log_lv && !log_in) ||
  		    (!seg_in && seg->log_lv && log_in)) {
  			log_error("Can't split mirror %s between "
  				  "two Volume Groups", lv->name);
  			return 0;
  		}
  
  		if (seg_in == seg->area_count && log_in) {
  			if (!_move_one_lv(vg_from, vg_to, lvh))
  				return_0;
  		}
  	}
  
  	return 1;
  }
  
  /*
   * Create or open the destination of the vgsplit operation.
   * Returns
   * - non-NULL: VG handle w/VG lock held
   * - NULL: no VG lock held
   */
  static struct volume_group *_vgsplit_to(struct cmd_context *cmd,
  					const char *vg_name_to,
  					int *existing_vg)
  {
  	struct volume_group *vg_to = NULL;
  
  	log_verbose("Checking for new volume group \"%s\"", vg_name_to);
  	/*
  	 * First try to create a new VG.  If we cannot create it,
  	 * and we get FAILED_EXIST (we will not be holding a lock),
  	 * a VG must already exist with this name.  We then try to
  	 * read the existing VG - the vgsplit will be into an existing VG.
  	 *
  	 * Otherwise, if the lock was successful, it must be the case that
  	 * we obtained a WRITE lock and could not find the vgname in the
  	 * system.  Thus, the split will be into a new VG.
  	 */
  	vg_to = vg_create(cmd, vg_name_to);
  	if (vg_read_error(vg_to) == FAILED_LOCKING) {
  		log_error("Can't get lock for %s", vg_name_to);
  		vg_release(vg_to);
  		return NULL;
  	}
  	if (vg_read_error(vg_to) == FAILED_EXIST) {
  		*existing_vg = 1;
  		vg_release(vg_to);
  		vg_to = vg_read_for_update(cmd, vg_name_to, NULL, 0);
  
  		if (vg_read_error(vg_to)) {
  			vg_release(vg_to);
  			stack;
  			return NULL;
  		}
  
  	} else if (vg_read_error(vg_to) == SUCCESS) {
  		*existing_vg = 0;
  	}
  	return vg_to;
  }
  
  /*
   * Open the source of the vgsplit operation.
   * Returns
   * - non-NULL: VG handle w/VG lock held
   * - NULL: no VG lock held
   */
  static struct volume_group *_vgsplit_from(struct cmd_context *cmd,
  					  const char *vg_name_from)
  {
  	struct volume_group *vg_from;
  
  	log_verbose("Checking for volume group \"%s\"", vg_name_from);
  
  	vg_from = vg_read_for_update(cmd, vg_name_from, NULL, 0);
  	if (vg_read_error(vg_from)) {
  		vg_release(vg_from);
  		return NULL;
  	}
  	return vg_from;
  }
  
  /*
   * Has the user given an option related to a new vg as the split destination?
   */
  static int new_vg_option_specified(struct cmd_context *cmd)
  {
  	return(arg_count(cmd, clustered_ARG) ||
  	       arg_count(cmd, alloc_ARG) ||
  	       arg_count(cmd, maxphysicalvolumes_ARG) ||
  	       arg_count(cmd, maxlogicalvolumes_ARG));
  }
  
  int vgsplit(struct cmd_context *cmd, int argc, char **argv)
  {
  	struct vgcreate_params vp_new;
  	struct vgcreate_params vp_def;
  	char *vg_name_from, *vg_name_to;
  	struct volume_group *vg_to = NULL, *vg_from = NULL;
  	int opt;
  	int existing_vg = 0;
  	int r = ECMD_FAILED;
  	const char *lv_name;
  	int lock_vg_from_first = 1;
  
  	if ((arg_count(cmd, name_ARG) + argc) < 3) {
  		log_error("Existing VG, new VG and either physical volumes "
  			  "or logical volume required.");
  		return EINVALID_CMD_LINE;
  	}
  
  	if (arg_count(cmd, name_ARG) && (argc > 2)) {
  		log_error("A logical volume name cannot be given with "
  			  "physical volumes.");
  		return ECMD_FAILED;
  	}
  
  	if (arg_count(cmd, name_ARG))
  		lv_name = arg_value(cmd, name_ARG);
  	else
  		lv_name = NULL;
  
  	vg_name_from = skip_dev_dir(cmd, argv[0], NULL);
  	vg_name_to = skip_dev_dir(cmd, argv[1], NULL);
  	argc -= 2;
  	argv += 2;
  
  	if (!strcmp(vg_name_to, vg_name_from)) {
  		log_error("Duplicate volume group name \"%s\"", vg_name_from);
  		return ECMD_FAILED;
  	}
  
  	if (strcmp(vg_name_to, vg_name_from) < 0)
  		lock_vg_from_first = 0;
  
  	if (lock_vg_from_first) {
  		vg_from = _vgsplit_from(cmd, vg_name_from);
  		if (!vg_from) {
  			stack;
  			return ECMD_FAILED;
  		}
  		/*
  		 * Set metadata format of original VG.
  		 * NOTE: We must set the format before calling vg_create()
  		 * since vg_create() calls the per-format constructor.
  		 */
  		cmd->fmt = vg_from->fid->fmt;
  
  		vg_to = _vgsplit_to(cmd, vg_name_to, &existing_vg);
  		if (!vg_to) {
  			unlock_and_release_vg(cmd, vg_from, vg_name_from);
  			stack;
  			return ECMD_FAILED;
  		}
  	} else {
  		vg_to = _vgsplit_to(cmd, vg_name_to, &existing_vg);
  		if (!vg_to) {
  			stack;
  			return ECMD_FAILED;
  		}
  		vg_from = _vgsplit_from(cmd, vg_name_from);
  		if (!vg_from) {
  			unlock_and_release_vg(cmd, vg_to, vg_name_to);
  			stack;
  			return ECMD_FAILED;
  		}
  
  		if (cmd->fmt != vg_from->fid->fmt) {
  			/* In this case we don't know the vg_from->fid->fmt */
  			log_error("Unable to set new VG metadata type based on "
  				  "source VG format - use -M option.");
  			goto bad;
  		}
  	}
  
  	if (existing_vg) {
  		if (new_vg_option_specified(cmd)) {
  			log_error("Volume group \"%s\" exists, but new VG "
  				    "option specified", vg_name_to);
  			goto bad;
  		}
  		if (!vgs_are_compatible(cmd, vg_from,vg_to))
  			goto_bad;
  	} else {
  		vgcreate_params_set_defaults(&vp_def, vg_from);
  		vp_def.vg_name = vg_name_to;
  		if (vgcreate_params_set_from_args(cmd, &vp_new, &vp_def)) {
  			r = EINVALID_CMD_LINE;
  			goto_bad;
  		}
  
  		if (vgcreate_params_validate(cmd, &vp_new)) {
  			r = EINVALID_CMD_LINE;
  			goto_bad;
  		}
  
  		if (!vg_set_extent_size(vg_to, vp_new.extent_size) ||
  		    !vg_set_max_lv(vg_to, vp_new.max_lv) ||
  		    !vg_set_max_pv(vg_to, vp_new.max_pv) ||
  		    !vg_set_alloc_policy(vg_to, vp_new.alloc) ||
  		    !vg_set_clustered(vg_to, vp_new.clustered))
  			goto_bad;
  	}
  
  	/* Archive vg_from before changing it */
  	if (!archive(vg_from))
  		goto_bad;
  
  	/* Move PVs across to new structure */
  	for (opt = 0; opt < argc; opt++) {
  		if (!move_pv(vg_from, vg_to, argv[opt]))
  			goto_bad;
  	}
  
  	/* If an LV given on the cmdline, move used_by PVs */
  	if (lv_name && !move_pvs_used_by_lv(vg_from, vg_to, lv_name))
  		goto_bad;
  
  	/* Move required LVs across, checking consistency */
  	if (!(_move_lvs(vg_from, vg_to)))
  		goto_bad;
  
  	/* FIXME Separate the 'move' from the 'validation' to fix dev stacks */
  	/* Move required mirrors across */
  	if (!(_move_mirrors(vg_from, vg_to)))
  		goto_bad;
  
  	/* Move required snapshots across */
  	if (!(_move_snapshots(vg_from, vg_to)))
  		goto_bad;
  
  	/* Split metadata areas and check if both vgs have at least one area */
  	if (!(vg_split_mdas(cmd, vg_from, vg_to)) && vg_from->pv_count) {
  		log_error("Cannot split: Nowhere to store metadata for new Volume Group");
  		goto bad;
  	}
  
  	/* Set proper name for all PVs in new VG */
  	if (!vg_rename(cmd, vg_to, vg_name_to))
  		goto_bad;
  
  	/* store it on disks */
  	log_verbose("Writing out updated volume groups");
  
  	/*
  	 * First, write out the new VG as EXPORTED.  We do this first in case
  	 * there is a crash - we will still have the new VG information, in an
  	 * exported state.  Recovery after this point would be removal of the
  	 * new VG and redoing the vgsplit.
  	 * FIXME: recover automatically or instruct the user?
  	 */
  	vg_to->status |= EXPORTED_VG;
  
  	if (!archive(vg_to))
  		goto_bad;
  
  	if (!vg_write(vg_to) || !vg_commit(vg_to))
  		goto_bad;
  
  	backup(vg_to);
  
  	/*
  	 * Next, write out the updated old VG.  If we crash after this point,
  	 * recovery is a vgimport on the new VG.
  	 * FIXME: recover automatically or instruct the user?
  	 */
  	if (vg_from->pv_count) {
  		if (!vg_write(vg_from) || !vg_commit(vg_from))
  			goto_bad;
  
  		backup(vg_from);
  	}
  
  	/*
  	 * Finally, remove the EXPORTED flag from the new VG and write it out.
  	 */
  	if (!test_mode()) {
  		vg_release(vg_to);
  		vg_to = vg_read_for_update(cmd, vg_name_to, NULL,
  					   READ_ALLOW_EXPORTED);
  		if (vg_read_error(vg_to)) {
  			log_error("Volume group \"%s\" became inconsistent: "
  				  "please fix manually", vg_name_to);
  			goto bad;
  		}
  	}
  
  	vg_to->status &= ~EXPORTED_VG;
  
  	if (!vg_write(vg_to) || !vg_commit(vg_to))
  		goto_bad;
  
  	backup(vg_to);
  
  	log_print("%s volume group \"%s\" successfully split from \"%s\"",
  		  existing_vg ? "Existing" : "New",
  		  vg_to->name, vg_from->name);
  
  	r = ECMD_PROCESSED;
  
  bad:
  	if (lock_vg_from_first) {
  		unlock_and_release_vg(cmd, vg_to, vg_name_to);
  		unlock_and_release_vg(cmd, vg_from, vg_name_from);
  	} else {
  		unlock_and_release_vg(cmd, vg_from, vg_name_from);
  		unlock_and_release_vg(cmd, vg_to, vg_name_to);
  	}
  	return r;
  }
  