vgchange

include/.symlinks

@@ -1,3 +1,4 @@
+../lib/activate/activate.h
 ../lib/config/config.h
 ../lib/datastruct/hash.h
 ../lib/datastruct/list.h

lib/Makefile.in

@@ -9,6 +9,7 @@ top_srcdir = @top_srcdir@
 VPATH = @srcdir@
 
 SOURCES=\
+	activate/activate.c \
 	config/config.c \
 	datastruct/hash.c \
 	device/dev-cache.c \

lib/activate/activate.c

@@ -4,18 +4,32 @@
  * This file is released under the GPL.
  */
 
+#include "metadata.h"
 #include "activate.h"
 
-int lv_activate(struct dmfs *dm,
-		struct volume_group *vg,
-		struct logical_volume *lv)
+int lv_activate(struct volume_group *vg, struct logical_volume *lv)
 {
-
+	return 0;
 }
 
-int lv_deactivate(struct dmfs *dm,
-		  struct volume_group *vg,
-		  struct logical_volume *lv)
+int lv_deactivate(struct volume_group *vg, struct logical_volume *lv)
 {
-
+	return 0;
 }
+
+int lvs_in_vg_activated(struct volume_group *vg)
+{
+	return 0;
+}
+
+int activate_lvs_in_vg(struct volume_group *vg)
+{
+	return 0;
+}
+
+int deactivate_lvs_in_vg(struct volume_group *vg)
+{
+	return 0;
+}
+
+

lib/activate/activate.h

@@ -4,17 +4,25 @@
  * This file is released under the GPL.
  */
 
-#ifndef ACTIVATE_H
-#define ACTIVATE_H
+#ifndef LVM_ACTIVATE_H
+#define LVM_ACTIVATE_H
 
-#include "dmfs-driver.h"
+/* FIXME Snapshot handling? */
 
-int lv_activate(struct dmfs *dm,
-		struct volume_group *vg,
+int lv_activate(struct volume_group *vg,
 		struct logical_volume *lv);
 
-int lv_deactivate(struct dmfs *dm,
-		  struct volume_group *vg,
+int lv_deactivate(struct volume_group *vg,
 		  struct logical_volume *lv);
 
+/* Return number of LVs in the VG that are active */
+int lvs_in_vg_activated(struct volume_group *vg);
+
+/* Activate all LVs in the VG.  Ignore any that are already active. */
+/* Return number activated */
+int activate_lvs_in_vg(struct volume_group *vg);
+
+/* Deactivate all LVs in the VG */
+int deactivate_lvs_in_vg(struct volume_group *vg);
+
 #endif

lib/filters/filter.c

@@ -84,6 +84,7 @@ struct dev_filter *config_filter_create()
 
 void config_filter_destroy(struct dev_filter *f)
 {
+	dbg_free(f->private);
 	dbg_free(f);
 	return;
 }

lib/format1/disk-rep.c

@@ -319,6 +319,9 @@ int read_pvs_in_vg(const char *vg_name, struct dev_filter *filter,
 	}
 	dev_iter_destroy(iter);
 
+	if (list_empty(head))
+		return 0;
+
 	return 1;
 }
 

lib/format1/format1.c

@@ -12,22 +12,34 @@
 #include "log.h"
 #include "display.h"
 
+/* VG consistency checks */
 static int _check_vgs(struct list_head *pvs)
 {
 	struct list_head *tmp;
 	struct disk_list *dl;
-	struct vg_disk *first = NULL;
+	struct disk_list *first = NULL;
+
+	int pv_count = 0;
 
 	/* check all the vg's are the same */
 	list_for_each(tmp, pvs) {
 		dl = list_entry(tmp, struct disk_list, list);
 
 		if (!first)
-			first = &dl->vg;
-		else if (memcmp(first, &dl->vg, sizeof(*first))) {
-			log_err("vg data differs on pvs\n");
+			first = dl;
+		else if (memcmp(&first->vg, &dl->vg, sizeof(first->vg))) {
+			log_err("VG data differs between PVs %s and %s",
+				first->dev->name, dl->dev->name);
 			return 0;
 		}
+		pv_count++;
+	}
+
+	/* On entry to fn, list known to be non-empty */
+	if (!(pv_count == dl->vg.pv_cur)) {
+		log_error("Only %d out of %d PV(s) found for VG %s",
+			  pv_count, dl->vg.pv_cur, dl->pv.vg_name);
+		return 0;
 	}
 
 	return 1;
@@ -313,6 +325,9 @@ static struct list_head *_get_vgs(struct io_space *is)
 		list_add(&nl->list, names);
 	}
 
+	if (list_empty(names))
+		goto bad;
+
 	return names;
 
  bad:

lib/format1/layout.c

@@ -64,6 +64,25 @@ static void _calc_simple_layout(struct pv_disk *pvd)
         pvd->pe_on_disk.size = pvd->pe_total * sizeof(struct pe_disk);
 }
 
+int _check_vg_limits(struct disk_list *dl)
+{
+	if (dl->vg.lv_max >= MAX_LV) {
+		log_error("MaxLogicalVolumes of %d exceeds format limit of %d "
+			  "for VG '%s'", dl->vg.lv_max, MAX_LV - 1, 
+			  dl->pv.vg_name);
+		return 0;
+	}
+
+	if (dl->vg.pv_max >= MAX_PV) {
+		log_error("MaxPhysicalVolumes of %d exceeds format limit of %d "
+			  "for VG '%s'", dl->vg.pv_max, MAX_PV - 1, 
+			  dl->pv.vg_name);
+		return 0;
+	}
+
+	return 1;
+}
+
 /*
  * This assumes pe_count and pe_start have already
  * been calculated correctly.
@@ -74,10 +93,13 @@ int calculate_layout(struct disk_list *dl)
 
 	_calc_simple_layout(pvd);
 	if (!_adjust_pe_on_disk(pvd)) {
-		log_err("insufficient space for metadata and PE's.");
+		log_error("Insufficient space for metadata and PE's.");
 		return 0;
 	}
 
+	if (!_check_vg_limits(dl))
+		return 0;
+
 	return 1;
 }
 

lib/mm/dbg_malloc.c

@@ -155,7 +155,7 @@ int dump_memory(void)
 	unsigned long tot = 0;
 	struct memblock *mb;
 	if (_head)
-		log_info("you have a memory leak:");
+		log_very_verbose("You have a memory leak:");
 
 	for (mb = _head; mb; mb = mb->next) {
 		print_log(_LOG_INFO, mb->file, mb->line, 
@@ -165,7 +165,7 @@ int dump_memory(void)
 	}
 
 	if (_head)
-		log_info("%ld bytes leaked in total", tot);
+		log_very_verbose("%ld bytes leaked in total", tot);
 
 	return 1;
 }

tools/Makefile.in

@@ -26,6 +26,7 @@ SOURCES=\
 	pvcreate.c \
 	toollib.c \
 	vgck.c \
+	vgchange.c \
 	vgcreate.c \
 	vgextend.c \
 	vgreduce.c \

tools/commands.h

@@ -325,15 +325,16 @@ xx(vgcfgrestore,
 
 xx(vgchange,
    "Change volume group attributes",
-   "vgchange "
+   "vgchange\n\t"
    "[-A|--autobackup {y|n}] "
    "[-d|--debug] "
    "[-h|--help]\n\t"
-   "{-a|--available {y|n} [VolumeGroupName...] |\n\t "
-   " -x|--allocation {y|n} [VolumeGroupName...]\n\t"
-   " -l|--logicalvolume MaxLogicalVolumes}\n\t"
    "[-v|--verbose] "
-   "[--version]\n",
+   "[--version]\n\t"
+   "{-a|--available {y|n} |\n\t"
+   " -x|--allocation {y|n} |\n\t"
+   " -l|--logicalvolume MaxLogicalVolumes}\n\t"
+   "[VolumeGroupName...]\n",
 
    autobackup_ARG, available_ARG, logicalvolume_ARG, allocation_ARG )
 

tools/stub.h

@@ -35,7 +35,6 @@ int pvdisplay(int argc, char **argv) {return 1;}
 int pvdata(int argc, char **argv) {return 1;}
 int pvscan(int argc, char **argv) {return 1;}
 int vgcfgbackup(int argc, char **argv) {return 1;}
-int vgchange(int argc, char **argv) {return 1;}
 int vgcfgrestore(int argc, char **argv) {return 1;}
 int vgdisplay(int argc, char **argv) {return 1;}
 int vgexport(int argc, char **argv) {return 1;}

tools/tools.h

@@ -40,6 +40,7 @@
 #include "filter.h"
 #include "format1.h"
 #include "toollib.h"
+#include "activate.h"
 
 #define CMD_LEN 256
 #define MAX_ARGS 64

tools/vgchange.c

@@ -0,0 +1,206 @@
+/*
+ * Copyright (C) 2001  Sistina Software
+ *
+ * LVM is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * LVM is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with LVM; see the file COPYING.  If not, write to
+ * the Free Software Foundation, 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ */
+
+#include "tools.h"
+
+static int vgchange_single(const char *vg_name);
+void vgchange_available(struct volume_group *vg);
+void vgchange_allocation(struct volume_group *vg);
+void vgchange_logicalvolume(struct volume_group *vg);
+
+int vgchange(int argc, char **argv)
+{
+	if (!(arg_count(available_ARG) + arg_count(logicalvolume_ARG) +
+	      arg_count(allocation_ARG))) {
+		log_error("One of -a, -l or -x options required");
+		return EINVALID_CMD_LINE;
+	}
+
+	if (arg_count(available_ARG) + arg_count(logicalvolume_ARG) +
+	    arg_count(allocation_ARG) > 1) {
+		log_error("Only one of -a, -l or -x options allowed");
+		return EINVALID_CMD_LINE;
+	}
+
+	if (arg_count(available_ARG) == 1 && arg_count(autobackup_ARG)) {
+		log_error("-A option not necessary with -a option");
+		return EINVALID_CMD_LINE;
+	}
+
+	return process_each_vg(argc, argv, &vgchange_single);
+}
+
+static int vgchange_single(const char *vg_name)
+{
+	struct volume_group *vg;
+
+	if (!(vg = ios->vg_read(ios, vg_name))) {
+		log_error("Unable to find volume group %s", vg_name);
+		return ECMD_FAILED;
+	}
+
+	if (vg->status & EXPORTED_VG) {
+		log_error("Volume group %s is exported", vg_name);
+		return ECMD_FAILED;
+	}
+
+	if (arg_count(available_ARG)) {
+		vgchange_available(vg);
+	}
+
+	if (arg_count(allocation_ARG)) {
+		vgchange_allocation(vg);
+	}
+
+	if (arg_count(logicalvolume_ARG)) {
+		vgchange_logicalvolume(vg);
+	}
+
+	return 0;
+}
+
+void vgchange_available(struct volume_group *vg)
+{
+	int lv_open;
+	int available = !strcmp(arg_str_value(available_ARG, "n"), "y");
+
+	/* FIXME Kernel status to override disk flags ! */
+	if (available && (vg->status & ACTIVE)) {
+		log_error("Volume group '%s' is already active", vg->name);
+		return;
+	}
+
+	if (!available && !(vg->status & ACTIVE)) {
+		log_error("Volume group '%s' is already not active", vg->name);
+		return;
+	}
+
+	/* FIXME: Force argument to deactivate them? */
+	if (!available && (lv_open = lvs_in_vg_activated(vg))) {
+		log_error("Can't deactivate volume group '%s' with %d active "
+			  "logical volume(s)", vg->name, lv_open);
+		return;
+	}
+
+	if (available)
+		vg->status |= ACTIVE;
+	else
+		vg->status &= ~ACTIVE;
+
+	if (!ios->vg_write(ios, vg))
+		return;
+
+	if (available && (lv_open = activate_lvs_in_vg(vg)))
+		log_verbose("Activated %d logical volumes in "
+			    "volume group '%s'", lv_open, vg->name);
+
+	if (!available && (lv_open = deactivate_lvs_in_vg(vg)))
+		log_verbose("Deactivated %d logical volumes in "
+			    "volume group '%s'", lv_open, vg->name);
+
+	log_print("Volume group %s successfully changed", vg->name);
+
+	return;
+}
+
+void vgchange_allocation(struct volume_group *vg)
+{
+	int extendable = !strcmp(arg_str_value(allocation_ARG, "n"), "y");
+
+	if (extendable && (vg->status & EXTENDABLE_VG)) {
+		log_error("Volume group %s is already extendable", vg->name);
+		return;
+	}
+
+	if (!extendable && !(vg->status & EXTENDABLE_VG)) {
+		log_error("Volume group %s is already not extendable",
+			  vg->name);
+		return;
+	}
+
+	if (extendable)
+		vg->status |= EXTENDABLE_VG;
+	else
+		vg->status &= ~EXTENDABLE_VG;
+
+	if (!ios->vg_write(ios, vg))
+		return;
+
+	log_print("Volume group %s successfully changed", vg->name);
+
+/********FIXME
+	do_autobackup(vg->name, vg);
+*********/
+
+	return;
+}
+
+void vgchange_logicalvolume(struct volume_group *vg)
+{
+	int max_lv = arg_int_value(logicalvolume_ARG, 0);
+
+	if (vg->status & ACTIVE) {
+		log_error("MaxLogicalVolume can't be changed in "
+			  "active volume group '%s'", vg->name);
+		return;
+	}
+
+	if (!(vg->status & EXTENDABLE_VG)) {
+		log_error("Volume group '%s' must be extendable "
+			  "to change MaxLogicalVolume", vg->name);
+		return;
+	}
+
+	if (max_lv < vg->lv_count) {
+		log_error("MaxLogicalVolume is less than the current number "
+			  "%d of logical volume(s) for '%s'", vg->lv_count,
+			  vg->name);
+		return;
+	}
+
+/************** FIXME  To be handled within vg_write
+	    for (p = 0, pp = *vg->pv; p < vg->pv_max; p++, pp++) {
+		if (pp != NULL) {
+		    pp->lv_on_disk.size =
+			round_up((max_lv + 1) * sizeof(lv_disk_t), LVM_VGDA_ALIGN);
+		    pe_on_disk_base_sav = pp->pe_on_disk.base;
+		    pp->pe_on_disk.base = pp->lv_on_disk.base + pp->lv_on_disk.size;
+		    pp->pe_on_disk.size -= pp->pe_on_disk.base - pe_on_disk_base_sav;
+		    if (LVM_VGDA_SIZE(pp) / SECTOR_SIZE >
+			(pp->pv_size & ~LVM_PE_ALIGN) - pp->pe_total * pp->pe_size) {
+			log_error("extended VGDA would overlap first physical extent");
+			return LVM_E_PE_OVERLAP;
+		    }
+		}
+	    }
+****************/
+
+	vg->max_lv = max_lv;
+
+	if (!ios->vg_write(ios, vg))
+		return;
+
+	log_print("Volume group %s successfully changed", vg->name);
+
+/*******FIXME
+	do_autobackup(vg->name, vg);
+********/
+	return;
+}