o activate/reactivate merge

o unlocking macro

12 files changed, 65 insertions, 65 deletions

diff --git a/tools/lvchange.c b/tools/lvchange.c
index 4b648932..b4d4103a 100644
--- a/tools/lvchange.c
+++ b/tools/lvchange.c
@@ -159,14 +159,14 @@ static int lvchange_permission(struct cmd_context *cmd,
 	log_very_verbose("Updating logical volume \"%s\" on disk(s)", lv->name);
 	if (!cmd->fid->ops->vg_write(cmd->fid, lv->vg)) {
                 /* FIXME: Attempt reversion? */
-                lock_vol(cmd, lv->lvid.s, LCK_LV_UNLOCK);
+                unlock_lv(cmd, lv->lvid.s);
 		return 0;
 	}
 
 	backup(lv->vg);
 
 	log_very_verbose("Updating permissions for \"%s\" in kernel", lv->name);
-        if (!lock_vol(cmd, lv->lvid.s, LCK_LV_UNLOCK)) {
+        if (!unlock_lv(cmd, lv->lvid.s)) {
                 log_error("Problem reactivating %s", lv->name);
                 return 0;
         }
@@ -247,14 +247,14 @@ static int lvchange_contiguous(struct cmd_context *cmd,
 	log_very_verbose("Updating logical volume \"%s\" on disk(s)", lv->name);
 	if (!cmd->fid->ops->vg_write(cmd->fid, lv->vg)) {
                 /* FIXME: Attempt reversion? */
-                lock_vol(cmd, lv->lvid.s, LCK_LV_UNLOCK);
+                unlock_lv(cmd, lv->lvid.s);
 		return 0;
 	}
 
 	backup(lv->vg);
 
 	log_very_verbose("Reactivating \"%s\" in kernel", lv->name);
-        if (!lock_vol(cmd, lv->lvid.s, LCK_LV_UNLOCK)) {
+        if (!unlock_lv(cmd, lv->lvid.s)) {
                 log_error("Problem reactivating %s", lv->name);
                 return 0;
         }
@@ -296,14 +296,14 @@ static int lvchange_readahead(struct cmd_context *cmd,
 	log_very_verbose("Updating logical volume \"%s\" on disk(s)", lv->name);
 	if (!cmd->fid->ops->vg_write(cmd->fid, lv->vg)) {
                 /* FIXME: Attempt reversion? */
-                lock_vol(cmd, lv->lvid.s, LCK_LV_UNLOCK);
+                unlock_lv(cmd, lv->lvid.s);
 		return 0;
 	}
 
 	backup(lv->vg);
 
 	log_very_verbose("Reactivating \"%s\" in kernel", lv->name);
-        if (!lock_vol(cmd, lv->lvid.s, LCK_LV_UNLOCK)) {
+        if (!unlock_lv(cmd, lv->lvid.s)) {
                 log_error("Problem reactivating %s", lv->name);
                 return 0;
         }
@@ -347,14 +347,14 @@ static int lvchange_persistent(struct cmd_context *cmd,
 	log_very_verbose("Updating logical volume \"%s\" on disk(s)", lv->name);
 	if (!cmd->fid->ops->vg_write(cmd->fid, lv->vg)) {
                 /* FIXME: Attempt reversion? */
-                lock_vol(cmd, lv->lvid.s, LCK_LV_UNLOCK);
+                unlock_lv(cmd, lv->lvid.s);
 		return 0;
 	}
 
 	backup(lv->vg);
 
 	log_very_verbose("Reactivating \"%s\" in kernel", lv->name);
-        if (!lock_vol(cmd, lv->lvid.s, LCK_LV_UNLOCK)) {
+        if (!unlock_lv(cmd, lv->lvid.s)) {
                 log_error("Problem reactivating %s", lv->name);
                 return 0;
         }
diff --git a/tools/lvcreate.c b/tools/lvcreate.c
index 3a9bd272..ff921125 100644
--- a/tools/lvcreate.c
+++ b/tools/lvcreate.c
@@ -465,6 +465,6 @@ int lvcreate(struct cmd_context *cmd, int argc, char **argv)
 	r = 0;
 
       out:
-	lock_vol(cmd, lp.vg_name, LCK_VG_UNLOCK);
+	unlock_vg(cmd, lp.vg_name);
 	return r;
 }
diff --git a/tools/lvrename.c b/tools/lvrename.c
index 282e6921..e9bea0f7 100644
--- a/tools/lvrename.c
+++ b/tools/lvrename.c
@@ -136,11 +136,11 @@ int lvrename(struct cmd_context *cmd, int argc, char **argv)
 	if (!(cmd->fid->ops->vg_write(cmd->fid, vg)))
 		goto lverror;
 
-	lock_vol(cmd, lv->lvid.s, LCK_LV_UNLOCK);
+	unlock_lv(cmd, lv->lvid.s);
 
 	backup(lv->vg);
 
-	lock_vol(cmd, vg_name, LCK_VG_UNLOCK);
+	unlock_vg(cmd, vg_name);
 
 	log_print("Renamed \"%s\" to \"%s\" in volume group \"%s\"",
 		  lv_name_old, lv_name_new, vg_name);
@@ -149,9 +149,9 @@ int lvrename(struct cmd_context *cmd, int argc, char **argv)
 
 
       lverror:
-	lock_vol(cmd, lv->lvid.s, LCK_LV_UNLOCK);
+	unlock_lv(cmd, lv->lvid.s);
 
       error:
-	lock_vol(cmd, vg_name, LCK_VG_UNLOCK);
+	unlock_vg(cmd, vg_name);
 	return ECMD_FAILED;
 }
diff --git a/tools/lvresize.c b/tools/lvresize.c
index a8c7256b..99cd6c67 100644
--- a/tools/lvresize.c
+++ b/tools/lvresize.c
@@ -339,28 +339,28 @@ int lvresize(struct cmd_context *cmd, int argc, char **argv)
 	/* store vg on disk(s) */
 	if (!cmd->fid->ops->vg_write(cmd->fid, vg)) {
 		/* FIXME: Attempt reversion? */
-		lock_vol(cmd, lv->lvid.s, LCK_LV_UNLOCK);
+		unlock_lv(cmd, lv->lvid.s);
 		goto error;
 	}
 
 	backup(vg);
 
-	if (!lock_vol(cmd, lv->lvid.s, LCK_LV_UNLOCK)) {
+	if (!unlock_lv(cmd, lv->lvid.s)) {
 		log_error("Problem reactivating %s", lv_name);
 		goto error;
 	}
 
-	lock_vol(cmd, vg_name, LCK_VG_UNLOCK);
+	unlock_vg(cmd, vg_name);
 
 	log_print("Logical volume %s successfully resized", lv_name);
 
 	return 0;
 
       error:
-	lock_vol(cmd, vg_name, LCK_VG_UNLOCK);
+	unlock_vg(cmd, vg_name);
 	return ECMD_FAILED;
 
       error_cmdline:
-	lock_vol(cmd, vg_name, LCK_VG_UNLOCK);
+	unlock_vg(cmd, vg_name);
 	return EINVALID_CMD_LINE;
 }
diff --git a/tools/pvchange.c b/tools/pvchange.c
index 7277c9a0..97f22d0d 100644
--- a/tools/pvchange.c
+++ b/tools/pvchange.c
@@ -104,26 +104,26 @@ int pvchange_single(struct cmd_context *cmd, struct physical_volume *pv)
 		}
 
 		if (!(vg = cmd->fid->ops->vg_read(cmd->fid, pv->vg_name))) {
-			lock_vol(cmd, pv->vg_name, LCK_VG_UNLOCK);
+			unlock_vg(cmd, pv->vg_name);
 			log_error("Unable to find volume group of \"%s\"",
 				  pv_name);
 			return 0;
 		}
 
 		if (vg->status & EXPORTED_VG) {
-			lock_vol(cmd, pv->vg_name, LCK_VG_UNLOCK);
+			unlock_vg(cmd, pv->vg_name);
 			log_error("Volume group \"%s\" is exported", vg->name);
 			return ECMD_FAILED;
 		}
 
 		if (!(vg->status & LVM_WRITE)) {
-			lock_vol(cmd, pv->vg_name, LCK_VG_UNLOCK);
+			unlock_vg(cmd, pv->vg_name);
 			log_error("Volume group \"%s\" is read-only", vg->name);
 			return ECMD_FAILED;
 		}
 
 		if (!(pvl = find_pv_in_vg(vg, pv_name))) {
-			lock_vol(cmd, pv->vg_name, LCK_VG_UNLOCK);
+			unlock_vg(cmd, pv->vg_name);
 			log_error
 			    ("Unable to find \"%s\" in volume group \"%s\"",
 			     pv_name, vg->name);
@@ -139,7 +139,7 @@ int pvchange_single(struct cmd_context *cmd, struct physical_volume *pv)
 		log_error("Physical volume \"%s\" is already allocatable",
 			  pv_name);
 		if (*pv->vg_name)
-			lock_vol(cmd, pv->vg_name, LCK_VG_UNLOCK);
+			unlock_vg(cmd, pv->vg_name);
 		return 0;
 	}
 
@@ -147,7 +147,7 @@ int pvchange_single(struct cmd_context *cmd, struct physical_volume *pv)
 		log_error("Physical volume \"%s\" is already unallocatable",
 			  pv_name);
 		if (*pv->vg_name)
-			lock_vol(cmd, pv->vg_name, LCK_VG_UNLOCK);
+			unlock_vg(cmd, pv->vg_name);
 		return 0;
 	}
 
@@ -164,13 +164,13 @@ int pvchange_single(struct cmd_context *cmd, struct physical_volume *pv)
 	log_verbose("Updating physical volume \"%s\"", pv_name);
 	if (*pv->vg_name) {
 		if (!(cmd->fid->ops->vg_write(cmd->fid, vg))) {
-			lock_vol(cmd, pv->vg_name, LCK_VG_UNLOCK);
+			unlock_vg(cmd, pv->vg_name);
 			log_error("Failed to store physical volume \"%s\" in "
 				  "volume group \"%s\"", pv_name, vg->name);
 			return 0;
 		}
 		backup(vg);
-		lock_vol(cmd, pv->vg_name, LCK_VG_UNLOCK);
+		unlock_vg(cmd, pv->vg_name);
 	} else {
 		if (!(cmd->fid->ops->pv_write(cmd->fid, pv))) {
 			log_error("Failed to store physical volume \"%s\"",
diff --git a/tools/toollib.c b/tools/toollib.c
index 39e7e9a7..ff60184a 100644
--- a/tools/toollib.c
+++ b/tools/toollib.c
@@ -134,13 +134,13 @@ int process_each_vg(struct cmd_context *cmd, int argc, char **argv,
 		log_verbose("Using volume group(s) on command line");
 		for (; opt < argc; opt++) {
 			vg_name = argv[opt];
-			if (!lock_vol(cmd, (void *) vg_name, LCK_VG | lock_type)) {
+			if (!lock_vol(cmd, vg_name, LCK_VG | lock_type)) {
 				log_error("Can't lock %s: skipping", vg_name);
 				continue;
 			}
 			if ((ret = process_single(cmd, vg_name)) > ret_max)
 				ret_max = ret;
-			lock_vol(cmd, (void *) vg_name, LCK_VG_UNLOCK);
+			unlock_vg(cmd, vg_name);
 		}
 	} else {
 		log_verbose("Finding all volume groups");
@@ -150,7 +150,7 @@ int process_each_vg(struct cmd_context *cmd, int argc, char **argv,
 		}
 		list_iterate(vgh, vgs) {
 			vg_name = list_item(vgh, struct name_list)->name;
-			if (!lock_vol(cmd, (void *) vg_name, LCK_VG | lock_type)) {
+			if (!lock_vol(cmd, vg_name, LCK_VG | lock_type)) {
 				log_error("Can't lock %s: skipping", vg_name);
 				continue;
 			}
@@ -158,7 +158,7 @@ int process_each_vg(struct cmd_context *cmd, int argc, char **argv,
 
 			if (ret > ret_max)
 				ret_max = ret;
-			lock_vol(cmd, (void *) vg_name, LCK_VG_UNLOCK);
+			unlock_vg(cmd, vg_name);
 		}
 	}
 
diff --git a/tools/vgcreate.c b/tools/vgcreate.c
index bc83ef2a..1eb5adef 100644
--- a/tools/vgcreate.c
+++ b/tools/vgcreate.c
@@ -99,25 +99,25 @@ int vgcreate(struct cmd_context *cmd, int argc, char **argv)
 
 	if (!lock_vol(cmd, vg_name, LCK_VG_WRITE | LCK_NONBLOCK)) {
 		log_error("Can't get lock for %s", vg_name);
-		lock_vol(cmd, "", LCK_VG_UNLOCK);
+		unlock_vg(cmd, "");
 		return ECMD_FAILED;
 	}
 
 	if (!archive(vg)) {
-		lock_vol(cmd, vg_name, LCK_VG_UNLOCK);
-		lock_vol(cmd, "", LCK_VG_UNLOCK);
+		unlock_vg(cmd, vg_name);
+		unlock_vg(cmd, "");
 		return ECMD_FAILED;
 	}
 
 	/* Store VG on disk(s) */
 	if (!cmd->fid->ops->vg_write(cmd->fid, vg)) {
-		lock_vol(cmd, vg_name, LCK_VG_UNLOCK);
-		lock_vol(cmd, "", LCK_VG_UNLOCK);
+		unlock_vg(cmd, vg_name);
+		unlock_vg(cmd, "");
 		return ECMD_FAILED;
 	}
 
-	lock_vol(cmd, vg_name, LCK_VG_UNLOCK);
-	lock_vol(cmd, "", LCK_VG_UNLOCK);
+	unlock_vg(cmd, vg_name);
+	unlock_vg(cmd, "");
 
 	backup(vg);
 
diff --git a/tools/vgextend.c b/tools/vgextend.c
index f6082f27..62ee8de3 100644
--- a/tools/vgextend.c
+++ b/tools/vgextend.c
@@ -47,7 +47,7 @@ int vgextend(struct cmd_context *cmd, int argc, char **argv)
 
 	log_verbose("Checking for volume group \"%s\"", vg_name);
 	if (!lock_vol(cmd, vg_name, LCK_VG_WRITE | LCK_NONBLOCK)) {
-		lock_vol(cmd, "", LCK_VG_UNLOCK);
+		unlock_vg(cmd, "");
 		log_error("Can't get lock for %s", vg_name);
 		goto error;
 	}
@@ -96,15 +96,15 @@ int vgextend(struct cmd_context *cmd, int argc, char **argv)
 
 	backup(vg);
 
-	lock_vol(cmd, vg_name, LCK_VG_UNLOCK);
-	lock_vol(cmd, "", LCK_VG_UNLOCK);
+	unlock_vg(cmd, vg_name);
+	unlock_vg(cmd, "");
 
 	log_print("Volume group \"%s\" successfully extended", vg_name);
 
 	return 0;
 
       error:
-	lock_vol(cmd, vg_name, LCK_VG_UNLOCK);
-	lock_vol(cmd, "", LCK_VG_UNLOCK);
+	unlock_vg(cmd, vg_name);
+	unlock_vg(cmd, "");
 	return ECMD_FAILED;
 }
diff --git a/tools/vgmerge.c b/tools/vgmerge.c
index 26a52312..72c4b7e1 100644
--- a/tools/vgmerge.c
+++ b/tools/vgmerge.c
@@ -67,26 +67,26 @@ int vgmerge_single(struct cmd_context *cmd, const char *vg_name_to,
 
 	if (!(vg_to = cmd->fid->ops->vg_read(cmd->fid, vg_name_to))) {
 		log_error("Volume group \"%s\" doesn't exist", vg_name_to);
-		lock_vol(cmd, vg_name_to, LCK_VG_UNLOCK);
+		unlock_vg(cmd, vg_name_to);
 		return ECMD_FAILED;
 	}
 
 	if (vg_to->status & EXPORTED_VG) {
 		log_error("Volume group \"%s\" is exported", vg_to->name);
-		lock_vol(cmd, vg_name_to, LCK_VG_UNLOCK);
+		unlock_vg(cmd, vg_name_to);
 		return ECMD_FAILED;
 	}
 
 	if (!(vg_to->status & LVM_WRITE)) {
 		log_error("Volume group \"%s\" is read-only", vg_to->name);
-		lock_vol(cmd, vg_name_to, LCK_VG_UNLOCK);
+		unlock_vg(cmd, vg_name_to);
 		return ECMD_FAILED;
 	}
 
 	log_verbose("Checking for volume group \"%s\"", vg_name_from);
 	if (!lock_vol(cmd, vg_name_from, LCK_VG_WRITE | LCK_NONBLOCK)) {
 		log_error("Can't get lock for %s", vg_name_from);
-		lock_vol(cmd, vg_name_to, LCK_VG_UNLOCK);
+		unlock_vg(cmd, vg_name_to);
 		return ECMD_FAILED;
 	}
 
@@ -190,15 +190,15 @@ int vgmerge_single(struct cmd_context *cmd, const char *vg_name_to,
 
 	backup(vg_to);
 
-	lock_vol(cmd, vg_name_from, LCK_VG_UNLOCK);
-	lock_vol(cmd, vg_name_to, LCK_VG_UNLOCK);
+	unlock_vg(cmd, vg_name_from);
+	unlock_vg(cmd, vg_name_to);
 
 	log_print("Volume group \"%s\" successfully merged into \"%s\"",
 		  vg_from->name, vg_to->name);
 	return 0;
 
       error:
-	lock_vol(cmd, vg_name_from, LCK_VG_UNLOCK);
-	lock_vol(cmd, vg_name_to, LCK_VG_UNLOCK);
+	unlock_vg(cmd, vg_name_from);
+	unlock_vg(cmd, vg_name_to);
 	return ECMD_FAILED;
 }
diff --git a/tools/vgreduce.c b/tools/vgreduce.c
index ff51ca30..0bdfd33c 100644
--- a/tools/vgreduce.c
+++ b/tools/vgreduce.c
@@ -58,25 +58,25 @@ int vgreduce(struct cmd_context *cmd, int argc, char **argv)
 
 	if (!(vg = cmd->fid->ops->vg_read(cmd->fid, vg_name))) {
 		log_error("Volume group \"%s\" doesn't exist", vg_name);
-		lock_vol(cmd, vg_name, LCK_VG_UNLOCK);
+		unlock_vg(cmd, vg_name);
 		return ECMD_FAILED;
 	}
 
 	if (vg->status & EXPORTED_VG) {
 		log_error("Volume group \"%s\" is exported", vg->name);
-		lock_vol(cmd, vg_name, LCK_VG_UNLOCK);
+		unlock_vg(cmd, vg_name);
 		return ECMD_FAILED;
 	}
 
 	if (!(vg->status & LVM_WRITE)) {
 		log_error("Volume group \"%s\" is read-only", vg_name);
-		lock_vol(cmd, vg_name, LCK_VG_UNLOCK);
+		unlock_vg(cmd, vg_name);
 		return ECMD_FAILED;
 	}
 
 	if (!(vg->status & RESIZEABLE_VG)) {
 		log_error("Volume group \"%s\" is not reducable", vg_name);
-		lock_vol(cmd, vg_name, LCK_VG_UNLOCK);
+		unlock_vg(cmd, vg_name);
 		return ECMD_FAILED;
 	}
 
@@ -84,7 +84,7 @@ int vgreduce(struct cmd_context *cmd, int argc, char **argv)
 	/* and update in batch here? */
 	ret = process_each_pv(cmd, argc, argv, vg, vgreduce_single);
 
-	lock_vol(cmd, vg_name, LCK_VG_UNLOCK);
+	unlock_vg(cmd, vg_name);
 
 	return ret;
 
diff --git a/tools/vgremove.c b/tools/vgremove.c
index 5f898ff9..8ae46e3e 100644
--- a/tools/vgremove.c
+++ b/tools/vgremove.c
@@ -34,7 +34,7 @@ int vgremove(struct cmd_context *cmd, int argc, char **argv)
 	ret = process_each_vg(cmd, argc, argv, LCK_WRITE | LCK_NONBLOCK,
 			      &vgremove_single);
 
-	lock_vol(cmd, "", LCK_VG_UNLOCK);
+	unlock_vg(cmd, "");
 
 	return ret;
 }
diff --git a/tools/vgrename.c b/tools/vgrename.c
index de178059..cde54217 100644
--- a/tools/vgrename.c
+++ b/tools/vgrename.c
@@ -76,18 +76,18 @@ int vgrename(struct cmd_context *cmd, int argc, char **argv)
 
 	if (!(vg_old = cmd->fid->ops->vg_read(cmd->fid, vg_name_old))) {
 		log_error("Volume group \"%s\" doesn't exist", vg_name_old);
-		lock_vol(cmd, vg_name_old, LCK_VG_UNLOCK);
+		unlock_vg(cmd, vg_name_old);
 		return ECMD_FAILED;
 	}
 
 	if (vg_old->status & EXPORTED_VG) {
-		lock_vol(cmd, vg_name_old, LCK_VG_UNLOCK);
+		unlock_vg(cmd, vg_name_old);
 		log_error("Volume group \"%s\" is exported", vg_old->name);
 		return ECMD_FAILED;
 	}
 
 	if (!(vg_old->status & LVM_WRITE)) {
-		lock_vol(cmd, vg_name_old, LCK_VG_UNLOCK);
+		unlock_vg(cmd, vg_name_old);
 		log_error("Volume group \"%s\" is read-only", vg_old->name);
 		return ECMD_FAILED;
 	}
@@ -98,7 +98,7 @@ int vgrename(struct cmd_context *cmd, int argc, char **argv)
 /***** FIXME Handle this with multiple LV renames!
 		if (!force_ARG) {
 			log_error("Use -f to force the rename");
-			lock_vol(cmd, vg_name_old, LCK_VG_UNLOCK);
+			unlock_vg(cmd, vg_name_old);
 			return ECMD_FAILED;
 		}
 *****/
@@ -107,7 +107,7 @@ int vgrename(struct cmd_context *cmd, int argc, char **argv)
 	log_verbose("Checking for new volume group \"%s\"", vg_name_new);
 
 	if (!lock_vol(cmd, vg_name_new, LCK_VG_WRITE | LCK_NONBLOCK)) {
-		lock_vol(cmd, vg_name_old, LCK_VG_UNLOCK);
+		unlock_vg(cmd, vg_name_old);
 		log_error("Can't get lock for %s", vg_name_new);
 		return ECMD_FAILED;
 	}
@@ -158,8 +158,8 @@ int vgrename(struct cmd_context *cmd, int argc, char **argv)
 
 	backup(vg_old);
 
-	lock_vol(cmd, vg_name_new, LCK_VG_UNLOCK);
-	lock_vol(cmd, vg_name_old, LCK_VG_UNLOCK);
+	unlock_vg(cmd, vg_name_new);
+	unlock_vg(cmd, vg_name_old);
 
 	log_print("Volume group \"%s\" successfully renamed to \"%s\"",
 		  vg_name_old, vg_name_new);
@@ -167,8 +167,8 @@ int vgrename(struct cmd_context *cmd, int argc, char **argv)
 	return 0;
 
       error:
-	lock_vol(cmd, vg_name_new, LCK_VG_UNLOCK);
-	lock_vol(cmd, vg_name_old, LCK_VG_UNLOCK);
+	unlock_vg(cmd, vg_name_new);
+	unlock_vg(cmd, vg_name_old);
 	return ECMD_FAILED;
 }