Merge lp:~yuningdodo/ubuntu/trusty/util-linux/util-linux.backport-wipefs-partition-table-erasing-support into lp:ubuntu/trusty-updates/util-linux

[Yu Ning]

  * wipefs: backport partition table erasing support from
    git://git.debian.org/git/collab-maint/pkg-util-linux.git
    - 6611a3dd783006fd8c6b924a76c4820287278d36
      wipefs: improve -a, use blkid_do_wipe()
    - 2b89be6c802bdbdf6830dbd060c96e33f179b135
      libblkid: add blkid_do_wipe()
    - 476b508e043b6b4c71d84b4f2fdeeffa68c204b3
      libblkid: add BLKID_PARTS_MAGIC to blkid_do_wipe() docs
    - 3c83b3b22f33fc7b17b504158e4a4db7b567bbe8
      libblkid: add BLKID_PARTS_MAGIC
    - 44765fdd841fb1369cf68f360131ed076f3a2771
      libblkid: export info about PT magic strings

[Timo Jyrinki (timo-jyrinki)]

I think this was workarounded in usb-creator instead, am I wrong? With the reasoning that this new feature backport would be a little too heavy in a core part like util-linux.

The latest usb-creator in 14.04 LTS is this https://launchpad.net/ubuntu/+source/usb-creator/0.2.56.3

So I'd mark this as rejected, please re-open if you think this should still be targeted towards trusty.

[Timo Jyrinki (timo-jyrinki)]

To be noted though for any core dev considering this, this version of the backport is much less invasive than the previous one https://code.launchpad.net/~yuningdodo/ubuntu/trusty/util-linux/util-linux.backport-utopic-2.25-8ubuntu1/+merge/232848

[Timo Jyrinki (timo-jyrinki)]

Hmm, reopening. As noted on the bug, the disk utility program would still need this.

[Mathieu Trudel-Lapierre (cyphermox)]

How does this affect https://launchpad.net/bugs/1046665? Have you also tested that this bug isn't regressed by these cherry-picks? What packages might be broken by the changes to libblkid?

It also seems to me like some of these commits probably aren't strictly required to support the changes to wipefs, since that's what is at stake here. Do you have a deep enough understanding of the changes here to know exactly why each of these commits are required? It looks to me like only a subset of these changes might be required to fix the targetted bug, but I only looked really quickly.

For example, it seems to me like the fix should work without the last three commits, and just the addition of blkid_do_wipe in libblkid/src/probe.c from 2b89be6c802bdbdf6830dbd060c96e33f179b135.

review: Needs Information

[Yu Ning (yuningdodo)]

Thanks for the review.

I checked the ubuntu branch, lp:ubuntu/util-linux, bug #1046665 was firstly fixed in rev90 by retrying the operation several times. Later in rev110 the code was entirely merged with debian experimental, and the previous retry was now implemented by calling blkid_do_probe() multiple times until it returns false. What I proposed to do for the trusty branch is similar, first retire the previous retrying logic then introduce the new implementation, so I believe it will not regress bug #1046665. About libblkid, here is a summary of what have been changed:

* new flag: BLKID_PARTS_MAGIC.
* new public method blkid_probe_wipe().
* declaration of blkid_probe_set_magic() is moved to libblkid/src/blkid.h from libblkid/src/superblocks/superblocks.h, so it will become a public method.

Besides these API changes, there are also some internal changes. I think they won't break the API backward compatibility of libblkid.

About the picked patches, I can't say I have a deep enough understanding about the patches, actually I picked them based on the test results of this simple testcase:

dd if=/dev/zero of=data bs=1M count=4
parted data --script -- mklabel msdos
parted data --script -- mkpart primary fat16 0 -0
wipefs -a data # it's expected to output "2 bytes were erased at offset 0x000001fe (dos): 55 aa"

With the first two patches it's not enough to erase the "55aa" signature. In fact the key patch is the last one, 44765fdd841fb1369cf68f360131ed076f3a2771, the other 4 patches are just its dependences. If we want to only pick the key patch, we may have to modify it a lot and causes future conflicts when other patches are being backported.

[Amr Ibrahim (amribrahim1987)]

Any updates on this?

Unmerged revisions

114. By Yu Ning on 2014-10-10

44765fdd841fb1369cf68f360131ed076f3a2771 libblkid: export info about PT magic strings

113. By Yu Ning on 2014-10-10

3c83b3b22f33fc7b17b504158e4a4db7b567bbe8 libblkid: add BLKID_PARTS_MAGIC

112. By Yu Ning on 2014-10-10

476b508e043b6b4c71d84b4f2fdeeffa68c204b3 libblkid: add BLKID_PARTS_MAGIC to blkid_do_wipe() docs

111. By Yu Ning on 2014-10-10

2b89be6c802bdbdf6830dbd060c96e33f179b135 libblkid: add blkid_do_wipe()

110. By Yu Ning on 2014-10-10

* wipefs: backport partition table erasing support from
  git://git.debian.org/git/collab-maint/pkg-util-linux.git
  - 6611a3dd783006fd8c6b924a76c4820287278d36
    wipefs: improve -a, use blkid_do_wipe()

=== modified file 'debian/changelog'
--- debian/changelog	2014-06-02 13:36:20 +0000
+++ debian/changelog	2014-10-10 06:30:46 +0000
@@ -1,3 +1,20 @@
+util-linux (2.20.1-5.1ubuntu20.1~test1) UNRELEASED; urgency=medium
+
+  * wipefs: backport partition table erasing support from
+    git://git.debian.org/git/collab-maint/pkg-util-linux.git
+    - 6611a3dd783006fd8c6b924a76c4820287278d36
+      wipefs: improve -a, use blkid_do_wipe()
+    - 2b89be6c802bdbdf6830dbd060c96e33f179b135
+      libblkid: add blkid_do_wipe()
+    - 476b508e043b6b4c71d84b4f2fdeeffa68c204b3
+      libblkid: add BLKID_PARTS_MAGIC to blkid_do_wipe() docs
+    - 3c83b3b22f33fc7b17b504158e4a4db7b567bbe8
+      libblkid: add BLKID_PARTS_MAGIC
+    - 44765fdd841fb1369cf68f360131ed076f3a2771
+      libblkid: export info about PT magic strings
+
+ -- Yu Ning <[e-mail]>  Fri, 10 Oct 2014 14:16:52 +0800
+
 util-linux (2.20.1-5.1ubuntu20.1) trusty-proposed; urgency=medium
 
   * fstrim-all: Fix typo that made unwanted stderr output from hdparm appear.
 
=== modified file 'libblkid/src/blkid.h.in'
--- libblkid/src/blkid.h.in	2011-11-03 15:38:23 +0000
+++ libblkid/src/blkid.h.in	2014-10-10 06:30:46 +0000
@@ -278,6 +278,7 @@
 /* partitions probing flags */
 #define BLKID_PARTS_FORCE_GPT		(1 << 1)
 #define BLKID_PARTS_ENTRY_DETAILS	(1 << 2)
+#define BLKID_PARTS_MAGIC		(1 << 3)
 extern int blkid_probe_set_partitions_flags(blkid_probe pr, int flags);
 
 /* binary interface */
@@ -319,6 +320,8 @@
                         const char **data, size_t *len);
 extern int blkid_probe_has_value(blkid_probe pr, const char *name);
 
+extern int blkid_do_wipe(blkid_probe pr, int dryrun);
+
 /*
  * Deprecated functions/macros
  */
 
=== modified file 'libblkid/src/blkid.sym'
--- libblkid/src/blkid.sym	2011-11-03 15:38:23 +0000
+++ libblkid/src/blkid.sym	2014-10-10 06:30:46 +0000
@@ -140,3 +140,11 @@
 	blkid_superblocks_get_name;
 } BLKID_2.18;
 
+/*
+ * symbols since util-linux 2.21
+ */
+BLKID_2.21 {
+global:
+	blkid_do_wipe;
+} BLKID_2.20;
+
 
=== modified file 'libblkid/src/blkidP.h'
--- libblkid/src/blkidP.h	2011-11-03 15:38:23 +0000
+++ libblkid/src/blkidP.h	2014-10-10 06:30:46 +0000
@@ -426,6 +426,8 @@
                 const char *fmt, va_list ap);
 extern int blkid_probe_sprintf_value(blkid_probe pr, const char *name,
                 const char *fmt, ...);
+extern int blkid_probe_set_magic(blkid_probe pr, blkid_loff_t offset,
+		size_t len, unsigned char *magic);
 
 extern void blkid_unparse_uuid(const unsigned char *uuid, char *str, size_t len);
 extern size_t blkid_rtrim_whitespace(unsigned char *str);
 
=== modified file 'libblkid/src/partitions/gpt.c'
--- libblkid/src/partitions/gpt.c	2011-11-03 15:38:23 +0000
+++ libblkid/src/partitions/gpt.c	2014-10-10 06:30:46 +0000
@@ -26,6 +26,7 @@
 
 /* Signature - “EFI PART” */
 #define GPT_HEADER_SIGNATURE 0x5452415020494645ULL
+#define GPT_HEADER_SIGNATURE_STR "EFI PART"
 
 /* basic types */
 typedef uint16_t efi_char16_t;
@@ -326,6 +327,14 @@
 	if (!tab)
 		goto err;
 
+	blkid_probe_set_magic(pr, lba << 9,
+			      sizeof(GPT_HEADER_SIGNATURE_STR) - 1,
+			      (unsigned char *) GPT_HEADER_SIGNATURE_STR);
+
+	blkid_probe_set_magic(pr, lba << 9,
+			      sizeof(GPT_HEADER_SIGNATURE_STR) - 1,
+			      (unsigned char *) GPT_HEADER_SIGNATURE_STR);
+
 	ssf = blkid_probe_get_sectorsize(pr) / 512;
 
 	fu = le64_to_cpu(h->first_usable_lba);
 
=== modified file 'libblkid/src/partitions/partitions.c'
--- libblkid/src/partitions/partitions.c	2011-11-03 15:38:23 +0000
+++ libblkid/src/partitions/partitions.c	2014-10-10 06:30:46 +0000
@@ -530,15 +530,17 @@
 	return 1;
 }
 
-static int idinfo_probe(blkid_probe pr, const struct blkid_idinfo *id)
+static int idinfo_probe(blkid_probe pr, const struct blkid_idinfo *id,
+			struct blkid_chain *chn)
 {
 	const struct blkid_idmag *mag;
+	blkid_loff_t off;
 	int rc = 1;		/* = nothing detected */
 
 	if (pr->size <= 0 || (id->minsz && id->minsz > pr->size))
 		goto nothing;	/* the device is too small */
 
-	if (blkid_probe_get_idmag(pr, id, NULL, &mag))
+	if (blkid_probe_get_idmag(pr, id, &off, &mag))
 		goto nothing;
 
 	/* final check by probing function */
@@ -549,9 +551,15 @@
 	        if (rc == -1) {
 			/* reset after error */
 			reset_partlist(blkid_probe_get_partlist(pr));
+			if (chn && !chn->binary)
+				blkid_probe_chain_reset_vals(pr, chn);
 			DBG(DEBUG_LOWPROBE, printf(
 				"%s probefunc failed\n", id->name));
 		}
+		if (rc == 0 && mag && chn && !chn->binary)
+			blkid_probe_set_magic(pr, off, mag->len,
+					(unsigned char *) mag->magic);
+
 		DBG(DEBUG_LOWPROBE, printf(
 			"%s: <--- (rc = %d)\n", id->name, rc));
 	}
@@ -594,7 +602,7 @@
 			continue;
 
 		/* apply checks from idinfo */
-		if (idinfo_probe(pr, idinfos[i]) != 0)
+		if (idinfo_probe(pr, idinfos[i], chn) != 0)
 			continue;
 
 		name = idinfos[i]->name;
@@ -678,7 +686,7 @@
 
 	blkid_probe_set_partlist(prc, ls);
 
-	rc = idinfo_probe(prc, id);
+	rc = idinfo_probe(prc, id, blkid_probe_get_chain(pr));
 
 	blkid_probe_set_partlist(prc, NULL);
 	blkid_partlist_set_parent(ls, NULL);
 
=== modified file 'libblkid/src/partitions/ultrix.c'
--- libblkid/src/partitions/ultrix.c	2011-11-03 15:38:23 +0000
+++ libblkid/src/partitions/ultrix.c	2014-10-10 06:30:46 +0000
@@ -15,7 +15,9 @@
 #include "partitions.h"
 
 #define ULTRIX_MAXPARTITIONS	8
+
 #define ULTRIX_MAGIC		0x032957
+#define ULTRIX_MAGIC_STR	"\x02\x29\x57"
 
 /* sector with partition table */
 #define ULTRIX_SECTOR		((16384 - sizeof(struct ultrix_disklabel)) >> 9)
@@ -62,6 +64,14 @@
 	if (!tab)
 		goto err;
 
+	blkid_probe_set_magic(pr, (ULTRIX_SECTOR << 9) + ULTRIX_OFFSET,
+			sizeof(ULTRIX_MAGIC_STR) - 1,
+			(unsigned char *) ULTRIX_MAGIC_STR);
+
+	blkid_probe_set_magic(pr, (ULTRIX_SECTOR << 9) + ULTRIX_OFFSET,
+			sizeof(ULTRIX_MAGIC_STR) - 1,
+			(unsigned char *) ULTRIX_MAGIC_STR);
+
 	for (i = 0; i < ULTRIX_MAXPARTITIONS; i++) {
 		if (!l->pt_part[i].pi_nblocks)
 			 blkid_partlist_increment_partno(ls);
 
=== modified file 'libblkid/src/probe.c'
--- libblkid/src/probe.c	2011-11-03 15:38:23 +0000
+++ libblkid/src/probe.c	2014-10-10 06:30:46 +0000
@@ -109,6 +109,7 @@
 #endif
 
 #include "blkidP.h"
+#include "writeall.h"
 
 /* chains */
 extern const struct blkid_chaindrv superblocks_drv;
@@ -914,6 +915,105 @@
 }
 
 /**
+ * blkid_do_wipe:
+ * @pr: prober
+ * @dryrun: if TRUE then don't touch the device.
+ *
+ * This function erases the current signature detected by @pr. The @pr has to
+ * be open in O_RDWR mode, BLKID_SUBLKS_MAGIC or/and BLKID_PARTS_MAGIC flags
+ * has to be enabled.
+ *
+ * After successful signature removing the @pr prober will be moved one step
+ * back and the next blkid_do_probe() call will again call previously called
+ * probing function.
+ *
+ *  <example>
+ *  <title>wipe all filesystems or raids from the device</title>
+ *   <programlisting>
+ *      fd = open(devname, O_RDWR);
+ *      blkid_probe_set_device(pr, fd, 0, 0);
+ *
+ *      blkid_probe_enable_superblocks(pr, 1);
+ *      blkid_probe_set_superblocks_flags(pr, BLKID_SUBLKS_MAGIC);
+ *
+ *	while (blkid_do_probe(pr) == 0)
+ *		blkid_do_wipe(pr, FALSE);
+ *  </programlisting>
+ * </example>
+ *
+ * Returns: 0 on success, 1 when probing is done and -1 in case of error.
+ */
+int blkid_do_wipe(blkid_probe pr, int dryrun)
+{
+	const char *off = NULL;
+	size_t len = 0;
+	loff_t offset, l;
+	char buf[BUFSIZ];
+	int fd, rc;
+	struct blkid_chain *chn;
+
+	if (!pr)
+		return -1;
+
+	chn = pr->cur_chain;
+	if (!chn)
+		return -1;
+
+	switch (chn->driver->id) {
+	case BLKID_CHAIN_SUBLKS:
+		rc = blkid_probe_lookup_value(pr, "SBMAGIC_OFFSET", &off, NULL);
+		if (!rc)
+			rc = blkid_probe_lookup_value(pr, "SBMAGIC", NULL, &len);
+		break;
+	case BLKID_CHAIN_PARTS:
+		rc = blkid_probe_lookup_value(pr, "PTMAGIC_OFFSET", &off, NULL);
+		if (!rc)
+			rc = blkid_probe_lookup_value(pr, "PTMAGIC", NULL, &len);
+		break;
+	default:
+		return 0;
+	}
+
+	if (rc || len == 0 || off == NULL)
+		return 0;
+
+	offset = strtoll(off, NULL, 10);
+	fd = blkid_probe_get_fd(pr);
+	if (fd < 0)
+		return -1;
+
+	if (len > sizeof(buf))
+		len = sizeof(buf);
+
+	DBG(DEBUG_LOWPROBE, printf(
+	    "wiping [offset=0x%jx, len=%zd, chain=%s, idx=%d, dryrun=%s]\n",
+	    offset, len, chn->driver->name, chn->idx, dryrun ? "yes" : "not"));
+
+	l = lseek(fd, offset, SEEK_SET);
+	if (l == (off_t) -1)
+		return -1;
+
+	memset(buf, 0, len);
+
+	if (!dryrun && len) {
+		if (write_all(fd, buf, len))
+			return -1;
+		fsync(fd);
+
+		blkid_probe_reset_buffer(pr);
+
+		if (chn->idx >= 0) {
+			chn->idx--;
+			DBG(DEBUG_LOWPROBE,
+				printf("wipe: moving %s chain index to %d\n",
+				chn->driver->name,
+				chn->idx));
+		}
+	}
+	return 0;
+}
+
+/**
  * blkid_do_safeprobe:
  * @pr: prober
  *
@@ -1124,6 +1224,39 @@
 	return rc;
 }
 
+int blkid_probe_set_magic(blkid_probe pr, blkid_loff_t offset,
+			size_t len, unsigned char *magic)
+{
+	int rc = 0;
+	struct blkid_chain *chn = blkid_probe_get_chain(pr);
+
+	if (!chn || !magic || !len || chn->binary)
+		return 0;
+
+	switch (chn->driver->id) {
+	case BLKID_CHAIN_SUBLKS:
+		if (!(chn->flags & BLKID_SUBLKS_MAGIC))
+			return 0;
+		rc = blkid_probe_set_value(pr, "SBMAGIC", magic, len);
+		if (!rc)
+			rc = blkid_probe_sprintf_value(pr,
+					"SBMAGIC_OFFSET", "%llu", offset);
+		break;
+	case BLKID_CHAIN_PARTS:
+		if (!(chn->flags & BLKID_PARTS_MAGIC))
+			return 0;
+		rc = blkid_probe_set_value(pr, "PTMAGIC", magic, len);
+		if (!rc)
+			rc = blkid_probe_sprintf_value(pr,
+					"PTMAGIC_OFFSET", "%llu", offset);
+		break;
+	default:
+		break;
+	}
+
+	return rc;
+}
+
 /**
  * blkid_probe_get_devno:
  * @pr: probe
 
=== modified file 'libblkid/src/superblocks/superblocks.c'
--- libblkid/src/superblocks/superblocks.c	2011-11-03 15:38:23 +0000
+++ libblkid/src/superblocks/superblocks.c	2014-10-10 06:30:46 +0000
@@ -478,21 +478,6 @@
 	return 0;
 }
 
-int blkid_probe_set_magic(blkid_probe pr, blkid_loff_t offset,
-			size_t len, unsigned char *magic)
-{
-	int rc = 0;
-	struct blkid_chain *chn = blkid_probe_get_chain(pr);
-
-	if (magic && len && (chn->flags & BLKID_SUBLKS_MAGIC)) {
-		rc = blkid_probe_set_value(pr, "SBMAGIC", magic, len);
-		if (!rc)
-			rc = blkid_probe_sprintf_value(pr, "SBMAGIC_OFFSET",
-					"%llu",	offset);
-	}
-	return rc;
-}
-
 int blkid_probe_set_version(blkid_probe pr, const char *version)
 {
 	struct blkid_chain *chn = blkid_probe_get_chain(pr);
 
=== modified file 'libblkid/src/superblocks/superblocks.h'
--- libblkid/src/superblocks/superblocks.h	2011-11-03 15:38:23 +0000
+++ libblkid/src/superblocks/superblocks.h	2014-10-10 06:30:46 +0000
@@ -71,8 +71,6 @@
 /*
  * superblock functions
  */
-extern int blkid_probe_set_magic(blkid_probe pr, blkid_loff_t offset,
-		size_t len, unsigned char *magic);
 extern int blkid_probe_set_version(blkid_probe pr, const char *version);
 extern int blkid_probe_sprintf_version(blkid_probe pr, const char *fmt, ...)
 		__attribute__ ((format (printf, 2, 3)));
 
=== modified file 'misc-utils/wipefs.c'
--- misc-utils/wipefs.c	2012-09-06 05:47:03 +0000
+++ misc-utils/wipefs.c	2014-10-10 06:30:46 +0000
@@ -49,6 +49,8 @@
 	char		*label;		/* FS label */
 	char		*uuid;		/* FS uuid */
 
+	int		on_disk;
+
 	struct wipe_desc	*next;
 };
 
@@ -138,73 +140,103 @@
 }
 
 static struct wipe_desc *
-get_offset_from_probe(struct wipe_desc *wp, blkid_probe pr, int zap)
+get_desc_for_probe(struct wipe_desc *wp, blkid_probe pr)
 {
-	const char *off, *type, *usage, *mag;
+	const char *off, *type, *mag, *p, *usage = NULL;
 	size_t len;
-
-	if (blkid_probe_lookup_value(pr, "TYPE", &type, NULL) == 0 &&
-	    blkid_probe_lookup_value(pr, "SBMAGIC_OFFSET", &off, NULL) == 0 &&
-	    blkid_probe_lookup_value(pr, "SBMAGIC", &mag, &len) == 0 &&
-	    blkid_probe_lookup_value(pr, "USAGE", &usage, NULL) == 0) {
-
-		loff_t offset = strtoll(off, NULL, 10);
-		const char *p;
-
-		wp = add_offset(wp, offset, zap);
-		if (!wp)
-			return NULL;
-
+	loff_t offset;
+	int rc;
+
+	/* superblocks */
+	if (blkid_probe_lookup_value(pr, "TYPE", &type, NULL) == 0) {
+		rc = blkid_probe_lookup_value(pr, "SBMAGIC_OFFSET", &off, NULL);
+		if (!rc)
+			rc = blkid_probe_lookup_value(pr, "SBMAGIC", &mag, &len);
+		if (rc)
+			return wp;
+
+	/* partitions */
+	} else if (blkid_probe_lookup_value(pr, "PTTYPE", &type, NULL) == 0) {
+		rc = blkid_probe_lookup_value(pr, "PTMAGIC_OFFSET", &off, NULL);
+		if (!rc)
+			rc = blkid_probe_lookup_value(pr, "PTMAGIC", &mag, &len);
+		if (rc)
+			return wp;
+		usage = "partition table";
+	} else
+		return wp;
+
+	offset = strtoll(off, NULL, 10);
+
+	wp = add_offset(wp, offset, 0);
+	if (!wp)
+		return NULL;
+
+	if (usage || blkid_probe_lookup_value(pr, "USAGE", &usage, NULL) == 0)
 		wp->usage = xstrdup(usage);
-		wp->type = xstrdup(type);
-
-		wp->magic = xmalloc(len);
-		memcpy(wp->magic, mag, len);
-		wp->len = len;
-
-		if (blkid_probe_lookup_value(pr, "LABEL", &p, NULL) == 0)
-			wp->label = xstrdup(p);
-
-		if (blkid_probe_lookup_value(pr, "UUID", &p, NULL) == 0)
-			wp->uuid = xstrdup(p);
-	}
+
+	wp->type = xstrdup(type);
+	wp->on_disk = 1;
+
+	wp->magic = xmalloc(len);
+	memcpy(wp->magic, mag, len);
+	wp->len = len;
+
+	if (blkid_probe_lookup_value(pr, "LABEL", &p, NULL) == 0)
+		wp->label = xstrdup(p);
+
+	if (blkid_probe_lookup_value(pr, "UUID", &p, NULL) == 0)
+		wp->uuid = xstrdup(p);
 
 	return wp;
 }
 
-static struct wipe_desc *
-read_offsets(struct wipe_desc *wp, const char *fname, int zap)
+static blkid_probe
+new_probe(const char *devname, int mode)
 {
 	blkid_probe pr;
-	int rc;
 
-	if (!fname)
+	if (!devname)
 		return NULL;
 
-	pr = blkid_new_probe_from_filename(fname);
+	if (mode) {
+		int fd = open(devname, mode);
+		if (fd < 0)
+			goto error;
+
+		pr = blkid_new_probe();
+		if (pr && blkid_probe_set_device(pr, fd, 0, 0))
+			goto error;
+	} else
+		pr = blkid_new_probe_from_filename(devname);
+
 	if (!pr)
-		errx(EXIT_FAILURE, _("error: %s: probing initialization failed"), fname);
-
-	blkid_probe_enable_superblocks(pr, 0);	/* enabled by default ;-( */
-
-	blkid_probe_enable_partitions(pr, 1);
-	rc = blkid_do_fullprobe(pr);
-	blkid_probe_enable_partitions(pr, 0);
-
-	if (rc == 0) {
-		const char *type = NULL;
-		blkid_probe_lookup_value(pr, "PTTYPE", &type, NULL);
-		warnx(_("WARNING: %s: appears to contain '%s' "
-				"partition table"), fname, type);
-	}
+		goto error;
 
 	blkid_probe_enable_superblocks(pr, 1);
 	blkid_probe_set_superblocks_flags(pr, BLKID_SUBLKS_MAGIC |
 			BLKID_SUBLKS_TYPE | BLKID_SUBLKS_USAGE |
 			BLKID_SUBLKS_LABEL | BLKID_SUBLKS_UUID);
 
+	blkid_probe_enable_partitions(pr, 1);
+	blkid_probe_set_partitions_flags(pr, BLKID_PARTS_MAGIC);
+
+	return pr;
+error:
+	err(EXIT_FAILURE, _("error: %s: probing initialization failed"), devname);
+	return NULL;
+}
+
+static struct wipe_desc *
+read_offsets(struct wipe_desc *wp, const char *devname)
+{
+	blkid_probe pr = new_probe(devname, 0);
+
+	if (!pr)
+		return NULL;
+
 	while (blkid_do_probe(pr) == 0) {
-		wp = get_offset_from_probe(wp, pr, zap);
+		wp = get_desc_for_probe(wp, pr);
 		if (!wp)
 			break;
 	}
@@ -213,60 +245,54 @@
 	return wp;
 }
 
-static int
-do_wipe_offset(int fd, struct wipe_desc *wp, const char *fname, int noact)
-{
-	char buf[BUFSIZ];
-	off_t l;
-	size_t i, len;
-
-	if (!wp->type) {
-		warnx(_("no magic string found at offset "
-			"0x%jx -- ignored"), wp->offset);
-		return 0;
-	}
-
-	l = lseek(fd, wp->offset, SEEK_SET);
-	if (l == (off_t) -1)
-		err(EXIT_FAILURE, _("%s: failed to seek to offset 0x%jx"),
-				fname, wp->offset);
-
-	len = wp->len > sizeof(buf) ? sizeof(buf) : wp->len;
-
-	memset(buf, 0, len);
-	if (noact == 0 && write_all(fd, buf, len))
-		err(EXIT_FAILURE, _("%s: write failed"), fname);
-
-	printf(_("%zd bytes were erased at offset 0x%jx (%s)\nthey were: "),
-	       wp->len, wp->offset, wp->type);
-
-	for (i = 0; i < len; i++) {
-		printf("%02x", wp->magic[i]);
-		if (i + 1 < len)
-			fputc(' ', stdout);
-	}
-
-	printf("\n");
-	return 0;
-}
-
-static int
-do_wipe(struct wipe_desc *wp, const char *fname, int noact)
-{
-	int fd;
-
-	fd = open(fname, O_WRONLY);
-	if (fd < 0)
-		err(EXIT_FAILURE, _("%s: open failed"), fname);
-
-	while (wp) {
-		if (wp->zap)
-			do_wipe_offset(fd, wp, fname, noact);
-		wp = wp->next;
-	}
-
-	close(fd);
-	return 0;
+static struct wipe_desc *
+do_wipe(struct wipe_desc *wp, const char *devname, int noact, int all)
+{
+	blkid_probe pr = new_probe(devname, O_RDWR);
+	struct wipe_desc *w;
+
+	if (!pr)
+		return NULL;
+
+	while (blkid_do_probe(pr) == 0) {
+		w = get_desc_for_probe(wp, pr);
+		if (!w)
+			break;
+		wp = w;
+		if (!wp->on_disk)
+			continue;
+		wp->zap = all ? 1 : wp->zap;
+		if (!wp->zap)
+			continue;
+
+		if (blkid_do_wipe(pr, noact))
+			warn(_("failed to erase %s magic string at offset 0x%08jx"),
+			     wp->type, wp->offset);
+		else {
+			size_t i;
+
+			printf(_("%zd bytes were erased at offset 0x%08jx (%s): "),
+				wp->len, wp->offset, wp->type);
+
+			for (i = 0; i < wp->len; i++) {
+				printf("%02x", wp->magic[i]);
+				if (i + 1 < wp->len)
+					fputc(' ', stdout);
+			}
+			putchar('\n');
+		}
+	}
+
+	for (w = wp; w != NULL; w = w->next) {
+		if (!w->on_disk)
+			warnx(_("offset 0x%jx not found"), w->offset);
+	}
+
+	fsync(blkid_probe_get_fd(pr));
+	close(blkid_probe_get_fd(pr));
+	blkid_free_probe(pr);
+
+	return wp;
 }
 
 static void
@@ -323,7 +349,7 @@
 {
 	struct wipe_desc *wp = NULL;
 	int c, all = 0, has_offset = 0, noact = 0, mode = 0;
-	const char *fname;
+	const char *devname;
 
 	static const struct option longopts[] = {
 	    { "all",       0, 0, 'a' },
@@ -372,26 +398,25 @@
 	if (optind == argc)
 		usage(stderr);
 
-	fname = argv[optind++];
+	devname = argv[optind++];
 
 	if (optind != argc)
 		errx(EXIT_FAILURE, _("only one device as argument is currently supported."));
 
-        /* we need to wipe several times for some file systems like VFAT, see
-         * https://launchpad.net/bugs/1046665 */
-        do {
-                wp = read_offsets(wp, fname, all);
-
-                if (wp) {
-                        if (has_offset || all)
-                                do_wipe(wp, fname, noact);
-                        else
-                                print_all(wp, mode);
-
-                        free_wipe(wp);
-                        wp = NULL;
-                } else
-                        break;
-        } while (!noact && all);
+	if (!all && !has_offset) {
+		/*
+		 * Print only
+		 */
+		wp = read_offsets(wp, devname);
+		if (wp)
+			print_all(wp, mode);
+	} else {
+		/*
+		 * Erase
+		 */
+		wp = do_wipe(wp, devname, noact, all);
+	}
+
+	free_wipe(wp);
 	return EXIT_SUCCESS;
 }