libfdisk: add fdisk_wipe_partition()

Now libfdisk provides functionality wipe disk device only ([s]fdisk
option --wipe).

This patch allows to probe for filesystems/RAIDs on newly created
partitions.  It means we can remove signatures before the partition
node (device) is created. This reduces udev events and it's
unnecessary to call wipefs for all partitions.  For example

  sfdisk --wipe=always --wipe-partitions=always /dev/sda <<<
  ...
  EOF

is a elegant way how to create new disk layout without any obsolete
filesystems/RAIDs.

Signed-off-by: Karel Zak <kzak@redhat.com>

diff --git a/libfdisk/docs/libfdisk-sections.txt b/libfdisk/docs/libfdisk-sections.txt
index dd8df21efa1bc8963c8e7ce2da3e56cbd1ebda81..14d770b7ed086c8673bfc4629bf555333a7a8ab9 100644 (file)
--- a/libfdisk/docs/libfdisk-sections.txt
+++ b/libfdisk/docs/libfdisk-sections.txt
@@ -162,6 +162,7 @@ fdisk_delete_partition
 fdisk_get_partition
 fdisk_is_partition_used
 fdisk_set_partition
+fdisk_wipe_partition
 <SUBSECTION>
 fdisk_partition
 fdisk_new_partition

diff --git a/libfdisk/src/Makemodule.am b/libfdisk/src/Makemodule.am
index bc7f1a378ed3cfecac687df2f05d671720b68e09..d7e7f16d8360b3db0bc23e1d944c447ebbdf6f8f 100644 (file)
--- a/libfdisk/src/Makemodule.am
+++ b/libfdisk/src/Makemodule.am
@@ -21,6 +21,7 @@ libfdisk_la_SOURCES = \
        libfdisk/src/iter.c \
        libfdisk/src/script.c \
        libfdisk/src/version.c \
+       libfdisk/src/wipe.c \
        \
        libfdisk/src/sun.c \
        libfdisk/src/sgi.c \

diff --git a/libfdisk/src/context.c b/libfdisk/src/context.c
index 88b9f8afb66f35e65b8709b6a614d5db1eeba5cc..26f526a78a82fec7a697970658fdcd9605da9fd4 100644 (file)
--- a/libfdisk/src/context.c
+++ b/libfdisk/src/context.c
@@ -47,6 +47,8 @@ struct fdisk_context *fdisk_new_context(void)
        cxt->dev_fd = -1;
        cxt->refcount = 1;
 
+       INIT_LIST_HEAD(&cxt->wipes);
+
        /*
         * Allocate label specific structs.
         *
@@ -112,6 +114,8 @@ static int init_nested_from_parent(struct fdisk_context *cxt, int isnew)
                        return -ENOMEM;
        }
 
+       INIT_LIST_HEAD(&cxt->wipes);
+
        return 0;
 }
 
@@ -339,9 +343,15 @@ int fdisk_enable_bootbits_protection(struct fdisk_context *cxt, int enable)
  * @cxt: fdisk context
  * @enable: 1 or 0
  *
- * The library removes all filesystem/RAID signatures before write PT. This is
- * no-op if any collision has not been detected by fdisk_assign_device(). See
- * fdisk_has_collision(). The default is not wipe a device.
+ * The library removes all filesystem/RAID signatures before it writes
+ * partition table. The probing area where it looks for filesystem/RAID is from
+ * the begin of the disk. The device is wiped by libblkid.
+ *
+ * See also fdisk_wipe_partition().
+ *
+ * This is no-op if any collision has not been detected by
+ * fdisk_assign_device(). See fdisk_has_collision(). The default is not wipe a
+ * device.
  *
  * Returns: 0 on success, < 0 on error.
  */
@@ -349,7 +359,8 @@ int fdisk_enable_wipe(struct fdisk_context *cxt, int enable)
 {
        if (!cxt)
                return -EINVAL;
-       cxt->wipe_device = enable ? 1 : 0;
+
+       fdisk_set_wipe_area(cxt, 0, cxt->total_sectors * cxt->sector_size, enable);
        return 0;
 }
 
@@ -363,7 +374,10 @@ int fdisk_enable_wipe(struct fdisk_context *cxt, int enable)
  */
 int fdisk_has_wipe(struct fdisk_context *cxt)
 {
-       return cxt && cxt->wipe_device;
+       if (!cxt)
+               return 0;
+
+       return fdisk_has_wipe_area(cxt, 0, cxt->total_sectors * cxt->sector_size);
 }
 
 
@@ -484,6 +498,8 @@ static void reset_context(struct fdisk_context *cxt)
        cxt->script = NULL;
 
        cxt->label = NULL;
+
+       fdisk_free_wipe_areas(cxt);
 }
 
 /*
@@ -535,37 +551,6 @@ static int check_collisions(struct fdisk_context *cxt)
 #endif
 }
 
-int fdisk_wipe_collisions(struct fdisk_context *cxt)
-{
-#ifdef HAVE_LIBBLKID
-       blkid_probe pr;
-       int rc;
-
-       assert(cxt);
-       assert(cxt->dev_fd >= 0);
-
-       DBG(CXT, ul_debugobj(cxt, "wipe: initialize libblkid prober"));
-
-       pr = blkid_new_probe();
-       if (!pr)
-               return -ENOMEM;
-       rc = blkid_probe_set_device(pr, cxt->dev_fd, 0, 0);
-       if (rc)
-               return rc;
-
-       blkid_probe_enable_superblocks(pr, 1);
-       blkid_probe_set_superblocks_flags(pr, BLKID_SUBLKS_MAGIC);
-       blkid_probe_enable_partitions(pr, 1);
-       blkid_probe_set_partitions_flags(pr, BLKID_PARTS_MAGIC);
-
-       while (blkid_do_probe(pr) == 0)
-               blkid_do_wipe(pr, FALSE);
-
-       blkid_free_probe(pr);
-#endif
-       return 0;
-}
-
 /**
  * fdisk_assign_device:
  * @cxt: context

diff --git a/libfdisk/src/fdiskP.h b/libfdisk/src/fdiskP.h
index 85c38492a1e3e62c9f76455fd976e13f1fe27a4b..6444c3d3e7bd524b961dc7461111a78599d08bda 100644 (file)
--- a/libfdisk/src/fdiskP.h
+++ b/libfdisk/src/fdiskP.h
@@ -38,6 +38,7 @@
 #define LIBFDISK_DEBUG_PARTTYPE        (1 << 7)
 #define LIBFDISK_DEBUG_TAB     (1 << 8)
 #define LIBFDISK_DEBUG_SCRIPT  (1 << 9)
+#define LIBFDISK_DEBUG_WIPE    (1 << 10)
 #define LIBFDISK_DEBUG_ALL     0xFFFF
 
 UL_DEBUG_DECLARE_MASK(libfdisk);
@@ -121,6 +122,10 @@ struct fdisk_partition {
        char            *attrs;                 /* partition flags/attributes converted to string */
        struct fdisk_parttype   *type;          /* partition type */
 
+       char            *fstype;                /* filesystem type */
+       char            *fsuuid;                /* filesystem uuid  */
+       char            *fslabel;               /* filesystem label */
+
        struct list_head        parts;          /* list of partitions */
 
        /* extra fields for partition_to_string() */
@@ -143,6 +148,7 @@ struct fdisk_partition {
                        partno_follow_default : 1,      /* use default partno */
                        size_explicit : 1,              /* don't align the size */
                        start_follow_default : 1,       /* use default start */
+                       fs_probed : 1,                  /* already probed by blkid */
                        used : 1,                       /* partition already used */
                        wholedisk : 1;                  /* special system partition */
 };
@@ -355,10 +361,10 @@ struct fdisk_context {
                     display_in_cyl_units : 1,  /* for obscure labels */
                     display_details : 1,       /* expert display mode */
                     protect_bootbits : 1,      /* don't zeroize fll irst sector */
-                    wipe_device : 1,           /* wipe device before write */
                     listonly : 1;              /* list partition, nothing else */
 
        char *collision;                        /* name of already existing FS/PT */
+       struct list_head wipes;                 /* list of areas to wipe before write */
 
        int sizeunit;                           /* SIZE fields, FDISK_SIZEUNIT_* */
 
@@ -389,8 +395,6 @@ struct fdisk_context {
        struct fdisk_script     *script;        /* what we want to follow */
 };
 
-int fdisk_wipe_collisions(struct fdisk_context *cxt);
-
 /* context.c */
 extern int __fdisk_switch_label(struct fdisk_context *cxt,
                                    struct fdisk_label *lb);
@@ -455,4 +459,10 @@ extern struct dos_partition *fdisk_dos_get_partition(
                                struct fdisk_context *cxt,
                                size_t i);
 
+/* wipe.c */
+void fdisk_free_wipe_areas(struct fdisk_context *cxt);
+int fdisk_set_wipe_area(struct fdisk_context *cxt, uint64_t start, uint64_t size, int enable);
+int fdisk_do_wipe(struct fdisk_context *cxt);
+int fdisk_has_wipe_area(struct fdisk_context *cxt, uint64_t start, uint64_t size);
+
 #endif /* _LIBFDISK_PRIVATE_H */

diff --git a/libfdisk/src/init.c b/libfdisk/src/init.c
index 61acb0a4f57fbfd88d4db73d0fed81e94274ec99..b4de57cd0a455e61b4aa24cb801bb35947de30e3 100644 (file)
--- a/libfdisk/src/init.c
+++ b/libfdisk/src/init.c
@@ -21,6 +21,7 @@ UL_DEBUG_DEFINE_MASKNAMES(libfdisk) =
        { "parttype",   LIBFDISK_DEBUG_PARTTYPE,"partition type utils" },
        { "script",     LIBFDISK_DEBUG_SCRIPT,  "sfdisk-like scripts" },
        { "tab",        LIBFDISK_DEBUG_TAB,     "table utils"},
+       { "wipe",       LIBFDISK_DEBUG_WIPE,    "wipe area utils" },
        { NULL, 0 }
 };
 

diff --git a/libfdisk/src/label.c b/libfdisk/src/label.c
index f2580cf030c2f7ea24ae03e07f79f9c2ac006796..ee5ee3e4ac60ace4e20279f8934e23e7f63f65e2 100644 (file)
--- a/libfdisk/src/label.c
+++ b/libfdisk/src/label.c
@@ -304,11 +304,7 @@ int fdisk_write_disklabel(struct fdisk_context *cxt)
        if (!cxt->label->op->write)
                return -ENOSYS;
 
-       if (cxt->collision && cxt->wipe_device) {
-               int rc = fdisk_wipe_collisions(cxt);
-               if (rc)
-                       return rc;
-       }
+       fdisk_do_wipe(cxt);
        return cxt->label->op->write(cxt);
 }
 

diff --git a/libfdisk/src/libfdisk.h.in b/libfdisk/src/libfdisk.h.in
index 7bcacd6da8b457fa094db31644ad82f26681c523..6bd3a1e56991b1c71a4052285d8edcc52cfc8bf1 100644 (file)
--- a/libfdisk/src/libfdisk.h.in
+++ b/libfdisk/src/libfdisk.h.in
@@ -285,6 +285,10 @@ enum fdisk_fieldtype {
        FDISK_FIELD_SADDR,              /* Start-C/H/S (MBR) */
        FDISK_FIELD_UUID,               /* partition UUID (GPT) */
 
+       FDISK_FIELD_FSUUID,
+       FDISK_FIELD_FSLABEL,
+       FDISK_FIELD_FSTYPE,
+
        FDISK_NFIELDS           /* must be last */
 };
 
@@ -321,9 +325,10 @@ extern int fdisk_get_partition(struct fdisk_context *cxt, size_t partno, struct
 extern int fdisk_set_partition(struct fdisk_context *cxt, size_t partno, struct fdisk_partition *pa);
 extern int fdisk_add_partition(struct fdisk_context *cxt, struct fdisk_partition *pa, size_t *partno);
 extern int fdisk_delete_partition(struct fdisk_context *cxt, size_t partno);
-
 extern int fdisk_delete_all_partitions(struct fdisk_context *cxt);
 
+extern int fdisk_wipe_partition(struct fdisk_context *cxt, size_t partno, int enable);
+
 extern int fdisk_set_partition_type(struct fdisk_context *cxt, size_t partnum,
                             struct fdisk_parttype *t);
 
@@ -389,6 +394,7 @@ size_t fdisk_partition_get_partno(struct fdisk_partition *pa);
 int fdisk_partition_has_partno(struct fdisk_partition *pa);
 int fdisk_partition_cmp_partno(struct fdisk_partition *a,
                                       struct fdisk_partition *b);
+
 int fdisk_partition_partno_follow_default(struct fdisk_partition *pa, int enable);
 
 extern int fdisk_partition_set_type(struct fdisk_partition *pa, struct fdisk_parttype *type);

diff --git a/libfdisk/src/libfdisk.sym b/libfdisk/src/libfdisk.sym
index 6a412bc20d94ab43a808275c17b39b2369030a91..c5aeac68e00d4806ae69be4cdef0d1e142b77c6b 100644 (file)
--- a/libfdisk/src/libfdisk.sym
+++ b/libfdisk/src/libfdisk.sym
@@ -259,3 +259,7 @@ FDISK_2.28 {
        fdisk_get_collision;
        fdisk_has_wipe;
 } FDISK_2.27;
+
+FDISK_2.29 {
+       fdisk_wipe_partition;
+} FDISK_2.28;

diff --git a/libfdisk/src/partition.c b/libfdisk/src/partition.c
index 5e41eed0dafdd13abba4e52b4762c36ab69d6aa0..4fbd1e4681c3d96ded0c9de036368f769d231451 100644 (file)
--- a/libfdisk/src/partition.c
+++ b/libfdisk/src/partition.c
@@ -2,6 +2,10 @@
 #include "c.h"
 #include "strutils.h"
 
+#ifdef HAVE_LIBBLKID
+# include <blkid.h>
+#endif
+
 #include "fdiskP.h"
 
 /**
@@ -63,6 +67,9 @@ void fdisk_reset_partition(struct fdisk_partition *pa)
        free(pa->name);
        free(pa->uuid);
        free(pa->attrs);
+       free(pa->fstype);
+       free(pa->fsuuid);
+       free(pa->fslabel);
 
        memset(pa, 0, sizeof(*pa));
        pa->refcount = ref;
@@ -85,6 +92,13 @@ static struct fdisk_partition *__copy_partition(struct fdisk_partition *o)
                n->uuid = strdup(o->uuid);
        if (o->attrs)
                n->attrs = strdup(o->attrs);
+       if (o->fstype)
+               n->fstype = strdup(o->fstype);
+       if (o->fsuuid)
+               n->fsuuid = strdup(o->fsuuid);
+       if (o->fslabel)
+               n->fslabel = strdup(o->fslabel);
+
        return n;
 }
 
@@ -127,7 +141,7 @@ void fdisk_unref_partition(struct fdisk_partition *pa)
  * @off: offset in sectors, maximal is UINT64_MAX-1
  *
  * Note that zero is valid offset too. Use fdisk_partition_unset_start() to
- * undefine the offset. 
+ * undefine the offset.
  *
  * Returns: 0 on success, <0 on error.
  */
@@ -138,6 +152,7 @@ int fdisk_partition_set_start(struct fdisk_partition *pa, fdisk_sector_t off)
        if (FDISK_IS_UNDEF(off))
                return -ERANGE;
        pa->start = off;
+       pa->fs_probed = 0;
        return 0;
 }
 
@@ -154,6 +169,7 @@ int fdisk_partition_unset_start(struct fdisk_partition *pa)
        if (!pa)
                return -EINVAL;
        FDISK_INIT_UNDEF(pa->start);
+       pa->fs_probed = 0;
        return 0;
 }
 
@@ -259,6 +275,7 @@ int fdisk_partition_set_size(struct fdisk_partition *pa, fdisk_sector_t sz)
        if (FDISK_IS_UNDEF(sz))
                return -ERANGE;
        pa->size = sz;
+       pa->fs_probed = 0;
        return 0;
 }
 
@@ -275,6 +292,7 @@ int fdisk_partition_unset_size(struct fdisk_partition *pa)
        if (!pa)
                return -EINVAL;
        FDISK_INIT_UNDEF(pa->size);
+       pa->fs_probed = 0;
        return 0;
 }
 
@@ -724,6 +742,60 @@ int fdisk_partition_next_partno(
        return 0;
 }
 
+static int probe_partition_content(struct fdisk_context *cxt, struct fdisk_partition *pa)
+{
+       int rc = 1;     /* nothing */
+
+       DBG(PART, ul_debugobj(pa, "start probe #%zu partition [cxt %p] >>>", pa->partno, cxt));
+
+       /* zeroize the current setting */
+       strdup_to_struct_member(pa, fstype, NULL);
+       strdup_to_struct_member(pa, fsuuid, NULL);
+       strdup_to_struct_member(pa, fslabel, NULL);
+
+       if (!fdisk_partition_has_start(pa) ||
+           !fdisk_partition_has_size(pa))
+               goto done;
+
+#ifdef HAVE_LIBBLKID
+       else {
+               uintmax_t start, size;
+
+               blkid_probe pr = blkid_new_probe();
+               if (!pr)
+                       goto done;
+
+               DBG(PART, ul_debugobj(pa, "blkid prober: %p", pr));
+
+               start = fdisk_partition_get_start(pa) * fdisk_get_sector_size(cxt);
+               size = fdisk_partition_get_size(pa) * fdisk_get_sector_size(cxt);
+
+               if (blkid_probe_set_device(pr, cxt->dev_fd, start, size) == 0
+                   && blkid_do_fullprobe(pr) == 0) {
+
+                       const char *data;
+                       rc = 0;
+
+                       if (!blkid_probe_lookup_value(pr, "TYPE",  &data, NULL))
+                               rc = strdup_to_struct_member(pa, fstype, data);
+
+                       if (!rc && !blkid_probe_lookup_value(pr, "LABEL", &data, NULL))
+                               rc = strdup_to_struct_member(pa, fslabel, data);
+
+                       if (!rc && !blkid_probe_lookup_value(pr, "UUID",  &data, NULL))
+                               rc = strdup_to_struct_member(pa, fsuuid, data);
+               }
+
+               blkid_free_probe(pr);
+               pa->fs_probed = 1;
+       }
+#endif /* HAVE_LIBBLKID */
+
+done:
+       DBG(PART, ul_debugobj(pa, "<<< end probe #%zu partition[cxt %p, rc=%d]", pa->partno, cxt, rc));
+       return rc;
+}
+
 /**
  * fdisk_partition_to_string:
  * @pa: partition
@@ -859,6 +931,18 @@ int fdisk_partition_to_string(struct fdisk_partition *pa,
        case FDISK_FIELD_EADDR:
                p = pa->end_chs && *pa->end_chs? strdup(pa->end_chs) : NULL;
                break;
+       case FDISK_FIELD_FSUUID:
+               if (pa->fs_probed || probe_partition_content(cxt, pa) == 0)
+                       p = pa->fsuuid && *pa->fsuuid ? strdup(pa->fsuuid) : NULL;
+               break;
+       case FDISK_FIELD_FSLABEL:
+               if (pa->fs_probed || probe_partition_content(cxt, pa) == 0)
+                       p = pa->fslabel && *pa->fslabel ? strdup(pa->fslabel) : NULL;
+               break;
+       case FDISK_FIELD_FSTYPE:
+               if (pa->fs_probed || probe_partition_content(cxt, pa) == 0)
+                       p = pa->fstype && *pa->fstype ? strdup(pa->fstype) : NULL;
+               break;
        default:
                return -EINVAL;
        }
@@ -876,6 +960,7 @@ int fdisk_partition_to_string(struct fdisk_partition *pa,
        return rc;
 }
 
+
 /**
  * fdisk_get_partition:
  * @cxt: context
@@ -1140,14 +1225,16 @@ erange:
 int fdisk_set_partition(struct fdisk_context *cxt, size_t partno,
                        struct fdisk_partition *pa)
 {
-       struct fdisk_partition *xpa = pa;
-       int rc;
+       struct fdisk_partition *xpa = pa, *tmp = NULL;
+       int rc, wipe = 0;
 
        if (!cxt || !cxt->label || !pa)
                return -EINVAL;
        if (!cxt->label->op->set_part)
                return -ENOSYS;
 
+       pa->fs_probed = 0;
+
        if (pa->resize || fdisk_partition_has_start(pa) || fdisk_partition_has_size(pa)) {
                xpa = __copy_partition(pa);
                xpa->movestart = 0;
@@ -1166,7 +1253,19 @@ int fdisk_set_partition(struct fdisk_context *cxt, size_t partno,
                    (uintmax_t) fdisk_partition_get_end(xpa),
                    (uintmax_t) fdisk_partition_get_size(xpa)));
 
+       /* disable wipe for old offset/size setting */
+       if (fdisk_get_partition(cxt, partno, &tmp) == 0 && tmp) {
+               wipe = fdisk_set_wipe_area(cxt, fdisk_partition_get_start(tmp),
+                                               fdisk_partition_get_size(tmp), FALSE);
+               fdisk_unref_partition(tmp);
+       }
+
+       /* call label driver */
        rc = cxt->label->op->set_part(cxt, partno, xpa);
+
+       /* enable wipe for new offset/size */
+       if (!rc && wipe)
+               fdisk_wipe_partition(cxt, partno, TRUE);
 done:
        DBG(CXT, ul_debugobj(cxt, "set_partition() rc=%d", rc));
        if (xpa != pa)
@@ -1174,6 +1273,31 @@ done:
        return rc;
 }
 
+/**
+ * fdisk_wipe_partition:
+ * @cxt: fdisk context
+ * @partno: partition number
+ * @enable: 0 or 1
+ *
+ * Enable/disable filesystems/RAIDs wiping in area defined by partition start and size.
+ *
+ * Returns: <0 in case of error, 0 on success
+ */
+int fdisk_wipe_partition(struct fdisk_context *cxt, size_t partno, int enable)
+{
+       struct fdisk_partition *pa = NULL;
+       int rc;
+
+       rc = fdisk_get_partition(cxt, partno, &pa);
+       if (rc)
+               return rc;
+
+       rc = fdisk_set_wipe_area(cxt, fdisk_partition_get_start(pa),
+                                     fdisk_partition_get_size(pa), enable);
+       fdisk_unref_partition(pa);
+       return rc < 0 ? rc : 0;
+}
+
 
 /**
  * fdisk_add_partition:
@@ -1201,7 +1325,8 @@ int fdisk_add_partition(struct fdisk_context *cxt,
        if (fdisk_missing_geometry(cxt))
                return -EINVAL;
 
-       if (pa)
+       if (pa) {
+               pa->fs_probed = 0;
                DBG(CXT, ul_debugobj(cxt, "adding new partition %p (start=%ju, end=%ju, size=%ju, "
                            "defaults(start=%s, end=%s, partno=%s)",
                            pa,
@@ -1211,7 +1336,7 @@ int fdisk_add_partition(struct fdisk_context *cxt,
                            pa->start_follow_default ? "yes" : "no",
                            pa->end_follow_default ? "yes" : "no",
                            pa->partno_follow_default ? "yes" : "no"));
-       else
+       } else
                DBG(CXT, ul_debugobj(cxt, "adding partition"));
 
        rc = cxt->label->op->add_part(cxt, pa, partno);
@@ -1236,6 +1361,8 @@ int fdisk_delete_partition(struct fdisk_context *cxt, size_t partno)
        if (!cxt->label->op->del_part)
                return -ENOSYS;
 
+       fdisk_wipe_partition(cxt, partno, 0);
+
        DBG(CXT, ul_debugobj(cxt, "deleting %s partition number %zd",
                                cxt->label->name, partno));
        return cxt->label->op->del_part(cxt, partno);

diff --git a/libfdisk/src/wipe.c b/libfdisk/src/wipe.c
new file mode 100644 (file)
index 0000000..2c91da5
--- /dev/null
+++ b/libfdisk/src/wipe.c
@@ -0,0 +1,143 @@
+#include "c.h"
+#include "strutils.h"
+
+#ifdef HAVE_LIBBLKID
+# include <blkid.h>
+#endif
+
+#include "fdiskP.h"
+
+struct fdisk_wipe {
+       struct list_head        wipes;
+       uint64_t                start;          /* sectors */
+       uint64_t                size;           /* sectors */
+};
+
+static struct fdisk_wipe *fdisk_get_wipe_area(
+                       struct fdisk_context *cxt,
+                       uint64_t start,
+                       uint64_t size)
+{
+       struct list_head *p;
+
+       if (cxt == NULL || list_empty(&cxt->wipes))
+               return NULL;
+
+       list_for_each(p, &cxt->wipes) {
+               struct fdisk_wipe *wp = list_entry(p, struct fdisk_wipe, wipes);
+               if (wp->start == start && wp->size == size)
+                       return wp;
+       }
+       return NULL;
+}
+
+void fdisk_free_wipe_areas(struct fdisk_context *cxt)
+{
+       while (!list_empty(&cxt->wipes)) {
+               struct fdisk_wipe *wp = list_entry(cxt->wipes.next,
+                                                 struct fdisk_wipe, wipes);
+               DBG(WIPE, ul_debugobj(wp, "free [start=%ju, size=%ju]",
+                               (uintmax_t) wp->start, (uintmax_t) wp->size));
+               list_del(&wp->wipes);
+               free(wp);
+       }
+}
+
+int fdisk_has_wipe_area(struct fdisk_context *cxt,
+                       uint64_t start,
+                       uint64_t size)
+{
+       return fdisk_get_wipe_area(cxt, start, size) != NULL;
+}
+
+/* Add/remove new wiping area
+ *
+ * Returns: <0 on error, or old area setting (1: enabled, 0: disabled)
+ */
+int fdisk_set_wipe_area(struct fdisk_context *cxt,
+                       uint64_t start,
+                       uint64_t size,
+                       int enable)
+{
+       struct fdisk_wipe *wp;
+
+       if (FDISK_IS_UNDEF(start) || FDISK_IS_UNDEF(size))
+               return -EINVAL;
+
+       wp = fdisk_get_wipe_area(cxt, start, size);
+
+       /* disable */
+       if (!enable) {
+               if (wp) {
+                       DBG(WIPE, ul_debugobj(wp, "disable [start=%ju, size=%ju]",
+                                               (uintmax_t) start, (uintmax_t) size));
+                       list_del(&wp->wipes);
+                       free(wp);
+                       return 1;
+               }
+               return 0;
+       }
+
+       /* enable */
+       if (wp)
+               return 1;       /* already enabled */
+
+       wp = calloc(1, sizeof(*wp));
+       if (!wp)
+               return -ENOMEM;
+
+       DBG(WIPE, ul_debugobj(wp, "enable [start=%ju, size=%ju]",
+                               (uintmax_t) start, (uintmax_t) size));
+
+       INIT_LIST_HEAD(&wp->wipes);
+       wp->start = start;
+       wp->size = size;
+       list_add_tail(&wp->wipes, &cxt->wipes);
+
+       return 0;
+}
+
+int fdisk_do_wipe(struct fdisk_context *cxt)
+{
+#ifdef HAVE_LIBBLKID
+       struct list_head *p;
+       blkid_probe pr;
+       int rc;
+
+       assert(cxt);
+       assert(cxt->dev_fd >= 0);
+
+       if (list_empty(&cxt->wipes))
+               return 0;
+
+       pr = blkid_new_probe();
+       if (!pr)
+               return -ENOMEM;
+
+       list_for_each(p, &cxt->wipes) {
+               struct fdisk_wipe *wp = list_entry(p, struct fdisk_wipe, wipes);
+               blkid_loff_t start = (blkid_loff_t) wp->start * cxt->sector_size,
+                            size = (blkid_loff_t) wp->size * cxt->sector_size;
+
+               DBG(WIPE, ul_debugobj(wp, "initialize libblkid prober [start=%ju, size=%ju]",
+                                            (uintmax_t) start, (uintmax_t) size));
+
+               rc = blkid_probe_set_device(pr, cxt->dev_fd, start, size);
+               if (rc)
+                       return rc;
+
+               blkid_probe_enable_superblocks(pr, 1);
+               blkid_probe_set_superblocks_flags(pr, BLKID_SUBLKS_MAGIC);
+               blkid_probe_enable_partitions(pr, 1);
+               blkid_probe_set_partitions_flags(pr, BLKID_PARTS_MAGIC);
+
+               while (blkid_do_probe(pr) == 0) {
+                       DBG(WIPE, ul_debugobj(wp, " wiping..."));
+                       blkid_do_wipe(pr, FALSE);
+               }
+       }
+
+       blkid_free_probe(pr);
+#endif
+       return 0;
+}