Merge lp:~psusi/ubuntu/precise/parted/fixloop into lp:ubuntu/precise/parted

[Phillip Susi]

Fixes partitionable loop devices, and support for > 16 partitions, and skips probing floppy drives.

[Luke Yelavich (themuso)]

Looks ok to me, but I'd rather get COlin's opinion on whether this is ok to merge.

[Phillip Susi (psusi)]

Hold off on this for a second, I think I found a problem with non 512 byte sector devices, need to correct.

review: Needs Fixing

[Phillip Susi (psusi)]

Nevermind, I didn't backport that part of the patch to Ubuntu, so this should be fine.

review: Needs Resubmitting

[lp:~psusi/ubuntu/precise/parted/fixloop]

103. By Phillip Susi on 2012-01-13

* Add 16-dos-partitions.patch: Fix parted to correctly handle
  more than 16 partitions on dos partition tables.
* Add dm-part-sync.patch: Backport fix to allow modifying partitions
  on dmraid disks while other partitions are in use.
* Replace dmraid.patch: Reimplemented and forwarded upstream,
  allows dmraid raid10 disks to show up (LP: #311179)
* Replace loop-partitions.patch: this patch used to make sure that
  we don't try to partition loop devices. Now it backports a few
  upstream changes to allow partitioning loop devices since that is
  supported on Linux since 3.0. It includes a change that also fixes
  support for > 16 partitions.
* Add skip-floppy.patch: don't probe floppy drives. (LP: #910379)

[Colin Watson (cjwatson)]

Scary complex, but I don't see any obvious problems, and we have time to fix things, so I'm going to go ahead. Thanks!

We'll probably need to test Wubi with this, but I'm sure that will happen anyway ...

review: Approve

=== modified file 'debian/changelog'
--- debian/changelog	2011-10-18 12:13:42 +0000
+++ debian/changelog	2012-01-13 19:53:24 +0000
@@ -1,3 +1,20 @@
+parted (2.3-8ubuntu2) precise; urgency=low
+
+  * Add 16-dos-partitions.patch: Fix parted to correctly handle
+    more than 16 partitions on dos partition tables.
+  * Add dm-part-sync.patch: Backport fix to allow modifying partitions
+    on dmraid disks while other partitions are in use.
+  * Replace dmraid.patch: Reimplemented and forwarded upstream,
+    allows dmraid raid10 disks to show up (LP: #311179)
+  * Replace loop-partitions.patch: this patch used to make sure that
+    we don't try to partition loop devices.  Now it backports a few
+    upstream changes to allow partitioning loop devices since that is
+    supported on Linux since 3.0.  It includes a change that also fixes
+    support for > 16 partitions.
+  * Add skip-floppy.patch: don't probe floppy drives. (LP: #910379)
+
+ -- Phillip Susi <[e-mail]>  Sat, 03 Dec 2011 09:50:05 -0500
+
 parted (2.3-8ubuntu1) precise; urgency=low
 
   * Resynchronise with Debian.  Remaining changes:

=== added file 'debian/patches/16-dos-partitions.patch'
--- debian/patches/16-dos-partitions.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/16-dos-partitions.patch	2012-01-13 19:53:24 +0000
@@ -0,0 +1,55 @@
+From: Phillip Susi <[e-mail]>
+Subject: Fix > 16 dos partitions
+Description: The msdos partition table claimed a maximum partition
+ count of 16 but would allow you to go beyond that.  This resulted
+ in the kernel not being informed of those partitions.  Corrected
+ to enforce the limit and raise the limit to 64 partitions.
+Forwarded: Yes
+
+--- a/libparted/labels/dos.c
++++ b/libparted/labels/dos.c
+@@ -104,7 +104,7 @@ static const char MBR_BOOT_CODE[] = {
+  * (i.e. 1022 is sometimes used to indicate "use LBA").
+  */
+ #define MAX_CHS_CYLINDER	1021
+-#define MAX_TOTAL_PART		16
++#define MAX_TOTAL_PART		64
+ 
+ typedef struct _DosRawPartition		DosRawPartition;
+ typedef struct _DosRawTable		DosRawTable;
+@@ -2332,17 +2332,23 @@ next_primary (const PedDisk* disk)
+ 		if (!ped_disk_get_partition (disk, i))
+ 			return i;
+ 	}
+-	return 0;
++	return -1;
+ }
+ 
+ static int
+ next_logical (const PedDisk* disk)
+ {
+ 	int	i;
+-	for (i=5; 1; i++) {
++	for (i=5; i<=MAX_TOTAL_PART; i++) {
+ 		if (!ped_disk_get_partition (disk, i))
+ 			return i;
+ 	}
++	ped_exception_throw (
++		PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
++		_("Can not create any more partitions"),
++		disk->dev->path);
++	return -1;
++
+ }
+ 
+ static int
+@@ -2361,7 +2367,8 @@ msdos_partition_enumerate (PedPartition*
+ 		part->num = next_logical (part->disk);
+ 	else
+ 		part->num = next_primary (part->disk);
+-
++	if (part->num == -1)
++		return 0;
+ 	return 1;
+ }
+ 

=== added file 'debian/patches/dm-part-sync.patch'
--- debian/patches/dm-part-sync.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/dm-part-sync.patch	2012-01-13 19:53:24 +0000
@@ -0,0 +1,268 @@
+From: Phillip Susi <[e-mail]>
+Subject: refactor device-mapper partition sync code
+Forwarded: Yes
+Description: The device-mapper partition sync code was still using the remove
+ all partitions, then add new partitions method.  Refactor to use the same
+ algorithm as regular disks: try to remove all, and ignore any that could not
+ be removed but have not changed.
+Index: b/libparted/arch/linux.c
+===================================================================
+--- a/libparted/arch/linux.c
++++ b/libparted/arch/linux.c
+@@ -270,6 +270,16 @@
+ static int _partition_is_mounted_by_path (const char* path);
+ static int
+ _dm_is_part (const char *path);
++static int
++_dm_add_partition (PedDisk* disk, const PedPartition* part);
++static int
++_dm_remove_partition(PedDisk* disk, int partno);
++static bool
++_dm_get_partition_start_and_length(PedPartition const *part,
++                                   unsigned long long *start,
++                                   unsigned long long *length);
++static int
++_is_dmraid_device (char* devpath);
+ 
+ 
+ static int
+@@ -2579,6 +2589,23 @@
+         PED_ASSERT(disk->dev != NULL, return 0);
+         int lpn;
+ 
++        int (*add_partition)(PedDisk* disk, const PedPartition *part);
++        int (*remove_partition)(PedDisk* disk, int partno);
++        bool (*get_partition_start_and_length)(PedPartition const *part,
++                                               unsigned long long *start,
++                                               unsigned long long *length);
++
++
++        if (disk->dev->type == PED_DEVICE_DM) {
++                add_partition = _dm_add_partition;
++                remove_partition = _dm_remove_partition;
++                get_partition_start_and_length = _dm_get_partition_start_and_length;
++        } else {
++                add_partition = _blkpg_add_partition;
++                remove_partition = _blkpg_remove_partition;
++                get_partition_start_and_length = _kernel_get_partition_start_and_length;
++        }
++
+         /* lpn = largest partition number. */
+         if (ped_disk_get_max_supported_partition_count(disk, &lpn))
+                 lpn = PED_MIN(lpn, _device_get_partition_range(disk->dev));
+@@ -2612,7 +2639,7 @@
+             int j;
+             for (j = 0; j < lpn; j++) {
+                 if (!ok[j]) {
+-                    ok[j] = _blkpg_remove_partition (disk, j + 1);
++                    ok[j] = remove_partition (disk, j + 1);
+                     errnums[j] = errno;
+                     if (!ok[j] && errnums[j] == EBUSY)
+                         busy = true;
+@@ -2629,8 +2656,8 @@
+                                 unsigned long long length;
+                                 unsigned long long start;
+                                 /* get start and length of existing partition */
+-                                if (!_kernel_get_partition_start_and_length(part,
+-                                                                &start, &length))
++                                if (!get_partition_start_and_length(part,
++                                                                    &start, &length))
+                                         goto cleanup;
+                                 if (start == part->geom.start
+ 				    && length == part->geom.length)
+@@ -2643,7 +2670,7 @@
+                         }
+ 
+                         /* add the (possibly modified or new) partition */
+-                        if (!_blkpg_add_partition (disk, part)) {
++                        if (!add_partition (disk, part)) {
+                                 ped_exception_throw (
+                                         PED_EXCEPTION_ERROR,
+                                         PED_EXCEPTION_RETRY_CANCEL,
+@@ -2691,24 +2718,34 @@
+ 
+ #ifdef ENABLE_DEVICE_MAPPER
+ static int
+-_dm_remove_map_name(char *name)
++_dm_remove_partition(PedDisk* disk, int partno)
+ {
+         struct dm_task  *task = NULL;
+         int             rc;
++        char            *part_name = _device_get_part_path (disk->dev, partno);
+ 
++        int fd = open (part_name, O_RDONLY | O_EXCL);
++        if (fd == -1) {
++                if (errno == ENOENT)
++                        errno = ENXIO; /* nothing to remove, device already doesn't exist */
++                free (part_name);
++                return 0;
++        }
++        close (fd);
+         task = dm_task_create(DM_DEVICE_REMOVE);
+-        if (!task)
+-                return 1;
+-
+-        dm_task_set_name (task, name);
+-
++        if (!task) {
++                free (part_name);
++                return 0;
++        }
++        dm_task_set_name (task, part_name);
+         rc = dm_task_run(task);
+         dm_task_update_nodes();
+         dm_task_destroy(task);
++        free (part_name);
+         if (!rc)
+-                return 1;
++                return 0;
+ 
+-        return 0;
++        return 1;
+ }
+ 
+ /* We consider a dm device that is a linear mapping with a  *
+@@ -2762,65 +2799,38 @@
+         return rc;
+ }
+ 
+-static int
+-_dm_remove_parts (PedDevice* dev)
++static bool
++_dm_get_partition_start_and_length(PedPartition const *part,
++                                   unsigned long long *start,
++                                   unsigned long long *length)
+ {
+-        struct dm_task*         task = NULL;
+-        struct dm_info*         info = alloca(sizeof *info);
+-        struct dm_names*        names = NULL;
+-        unsigned int            next = 0;
+-        int                     rc;
+-        LinuxSpecific*          arch_specific = LINUX_SPECIFIC (dev);
+-
+-        task = dm_task_create(DM_DEVICE_LIST);
+-        if (!task)
+-                goto err;
+-
+-        if (!dm_task_set_major_minor (task, arch_specific->major,
+-                                      arch_specific->minor, 0))
+-                goto err;
++        struct dm_task* task = NULL;
++        int             rc = 0;
++        char *target_type = NULL;
++        char *params;
++        char *path;
++        int major, minor;
+ 
++        if (!(task = dm_task_create(DM_DEVICE_TABLE)))
++                return 0;
++        path = _device_get_part_path (part->disk->dev, part->num);
++        PED_ASSERT(path, return false);
++        dm_task_set_name(task, path);
+         if (!dm_task_run(task))
+                 goto err;
+-
+-        memset(info, '\0', sizeof *info);
+-        dm_task_get_info(task, info);
+-        if (!info->exists)
+-                goto err;
+-
+-        names = dm_task_get_names(task);
+-        if (!names)
++        dm_get_next_target(task, NULL, (uint64_t *)start, (uint64_t *)length, &target_type, &params);
++        if (sscanf (params, "%d:%d %Ld", &major, &minor, start) != 3)
+                 goto err;
+-
+-        rc = 0;
+-        do {
+-                names = (void *) ((char *) names + next);
+-
+-                if (_dm_is_part(info, names->name))
+-                        rc += _dm_remove_map_name(names->name);
+-
+-                next = names->next;
+-        } while (next);
+-
+-        dm_task_update_nodes();
+-        dm_task_destroy(task);
+-        task = NULL;
+-
+-        if (!rc)
+-                return 1;
++        rc = 1;
+ err:
+-        if (task)
+-                dm_task_destroy(task);
+-        ped_exception_throw (PED_EXCEPTION_WARNING, PED_EXCEPTION_IGNORE,
+-                _("parted was unable to re-read the partition "
+-                  "table on %s (%s).  This means Linux won't know "
+-                  "anything about the modifications you made. "),
+-                dev->path, strerror (errno));
+-        return 0;
++        free (path);
++        dm_task_destroy(task);
++        return rc;
+ }
+ 
++
+ static int
+-_dm_add_partition (PedDisk* disk, PedPartition* part)
++_dm_add_partition (PedDisk* disk, const PedPartition* part)
+ {
+         char*           vol_name = NULL;
+         const char*     dev_name = NULL;
+@@ -2873,7 +2883,7 @@
+                 free(vol_name);
+                 return 1;
+         } else {
+-                _dm_remove_map_name(vol_name);
++                _dm_remove_partition (disk, part->num);
+         }
+ err:
+         dm_task_update_nodes();
+@@ -2883,34 +2893,6 @@
+         free (vol_name);
+         return 0;
+ }
+-
+-static int
+-_dm_reread_part_table (PedDisk* disk)
+-{
+-        int largest_partnum = ped_disk_get_last_partition_num (disk);
+-        if (largest_partnum <= 0)
+-          return 1;
+-
+-        int     rc = 1;
+-        int     last = PED_MIN (largest_partnum, 16);
+-        int     i;
+-
+-        sync();
+-        if (!_dm_remove_parts(disk->dev))
+-                rc = 0;
+-
+-        for (i = 1; i <= last; i++) {
+-                PedPartition*      part;
+-
+-                part = ped_disk_get_partition (disk, i);
+-                if (!part)
+-                        continue;
+-
+-                if (!_dm_add_partition (disk, part))
+-                        rc = 0;
+-        }
+-        return rc;
+-}
+ #endif
+ 
+ static int
+@@ -2933,10 +2915,6 @@
+         if (!_has_partitions (disk))
+                 return 1;
+ 
+-#ifdef ENABLE_DEVICE_MAPPER
+-        if (disk->dev->type == PED_DEVICE_DM)
+-                return _dm_reread_part_table (disk);
+-#endif
+         if (disk->dev->type != PED_DEVICE_FILE) {
+ 
+ 		/* We now require BLKPG support.  If this assertion fails,

=== modified file 'debian/patches/dmraid.patch'
--- debian/patches/dmraid.patch	2011-09-06 16:42:40 +0000
+++ debian/patches/dmraid.patch	2012-01-13 19:53:24 +0000
@@ -1,76 +1,36 @@
-From: Luke Yelavich <[e-mail]>
-Forwarded: no
-Description: DM-RAID handling
- Ensure that device-mapper devices for DM-RAID arrays do not have extra
- nodes created needlessly, and make sure that partition nodes for DM-RAID
- devices are not probed.
+From: Phillip Susi <[e-mail]>
+Subject: Hide non dmraid whole disk dm devices
+Description: Don't probe dm devices unless they are dmraid whole
+ disk devices, not partitions.  Also set UUID of newly created
+ dmraid partition devices.
+Forwarded: yes
 
 Index: b/libparted/arch/linux.c
 ===================================================================
 --- a/libparted/arch/linux.c
 +++ b/libparted/arch/linux.c
-@@ -269,6 +269,10 @@
+@@ -268,6 +268,9 @@
  
  static char* _device_get_part_path (PedDevice* dev, int num);
  static int _partition_is_mounted_by_path (const char* path);
-+#ifdef ENABLE_DEVICE_MAPPER
-+static int _is_dmraid_device (char* devpath);
-+static int _is_dmraid_major (char* devpath);
-+#endif
++static int
++_dm_is_part (const char *path);
++
  
  static int
  _read_fd (int fd, char **buf)
-@@ -486,8 +490,16 @@
+@@ -485,13 +488,52 @@
                 if (stat (buf, &st) != 0)
                         continue;
  
 -               if (_is_dm_major(major(st.st_rdev)))
--                       _ped_device_probe (buf);
-+               if (_is_dm_major(major(st.st_rdev))) {
-+                       if (_is_dmraid_device (buf)) {
-+                               if (_is_dmraid_major (buf)) {
-+                                       _ped_device_probe (buf);
-+                               }
-+                       } else {
-+                               _ped_device_probe (buf);
-+                       }
-+               }
-+
++               if (_is_dm_major(major(st.st_rdev)) && _is_dmraid_device (buf)
++                   && !_dm_is_part(buf))
+                        _ped_device_probe (buf);
         }
         closedir (mapper_dir);
  
-@@ -2697,6 +2709,8 @@
-         char*           vol_name = NULL;
-         const char*     dev_name = NULL;
-         char*           params = NULL;
-+        char*           dm_uuid = NULL;
-+        int             uuid_len;
-         LinuxSpecific*  arch_specific = LINUX_SPECIFIC (disk->dev);
- 
-         if (!_has_partitions(disk))
-@@ -2737,12 +2751,19 @@
-         dm_task_set_name (task, vol_name);
-         dm_task_add_target (task, 0, part->geom.length,
-                 "linear", params);
-+        if (_is_dmraid_device (disk->dev->path)) {
-+                uuid_len = (strlen (vol_name) + 8);
-+                dm_uuid = (char*) ped_malloc (uuid_len);
-+                snprintf (dm_uuid, uuid_len, "DMRAID-%s", vol_name);
-+                dm_task_set_uuid (task, dm_uuid);
-+        }
-         if (dm_task_run (task)) {
-                 //printf("0 %ld linear %s\n", part->geom.length, params);
-                 dm_task_update_nodes();
-                 dm_task_destroy(task);
-                 free(params);
-                 free(vol_name);
-+                free(dm_uuid);
-                 return 1;
-         } else {
-                 _dm_remove_map_name(vol_name);
-@@ -2783,6 +2804,81 @@
-         }
-         return rc;
+        return 1;
  }
 +
 +/* Checks whether the given device-mapper device is part of a dmraid array,
@@ -110,43 +70,64 @@
 +        dm_task_destroy (task);
 +        return rc;
 +}
-+
-+/* Checks whether the given dmraid device node is a partition node, or the
-+ * master node. This is done by checking the /sys/block directory for the node
-+ * in question, to determine whether it is a slave of another device-mapper
-+ * device. The node should be confirmed as a dmraid device by calling
-+ * _is_dmraid_device first.
-+ */
-+static int
-+_is_dmraid_major (char* devpath)
-+{
-+        DIR*            sysfs_dir;
-+        struct dirent*  dent;
-+        char            dmraid_devpath [32];
-+        struct stat     st;
-+
-+        if (stat (devpath, &st) != 0)
-+                return 0;
-+
-+        snprintf (dmraid_devpath, 32, "/sys/block/dm-%d/slaves", minor (st.st_rdev));
-+
-+        sysfs_dir = opendir (dmraid_devpath);
-+        if (!sysfs_dir)
-+               return 0;
-+
-+        while ((dent = readdir (sysfs_dir))) {
-+                if (strcmp (dent->d_name, ".")  == 0 ||
-+                    strcmp (dent->d_name, "..") == 0)
-+                       continue;
-+
-+                if (strncmp (dent->d_name, "dm-", 3) == 0)
-+                        return 0;
-+        }
-+        closedir (sysfs_dir);
-+
-+        return 1;
-+}
-+
  #endif
  
  static int
+@@ -2669,20 +2711,26 @@
+         return 0;
+ }
+ 
++/* We consider a dm device that is a linear mapping with a  *
++ * single target that also is a dm device to be a partition */
++
+ static int
+-_dm_is_part (struct dm_info *this, char *name)
++_dm_is_part (const char *path)
+ {
+         struct dm_task* task = NULL;
+         struct dm_info* info = alloca(sizeof *info);
+         struct dm_deps* deps = NULL;
+         int             rc = 0;
+         unsigned int    i;
++        char *target_type = NULL;
++        uint64_t start, length;
++        char *params;
+ 
+         task = dm_task_create(DM_DEVICE_DEPS);
+         if (!task)
+                 return 0;
+ 
+-        dm_task_set_name(task, name);
++        dm_task_set_name(task, path);
+         if (!dm_task_run(task))
+                 goto err;
+ 
+@@ -2695,14 +2743,20 @@
+         if (!deps)
+                 goto err;
+ 
+-        for (i = 0; i < deps->count; i++) {
+-                unsigned int ma = major(deps->device[i]),
+-                             mi = minor(deps->device[i]);
+-
+-                if (ma == this->major && mi == this->minor)
+-                        rc = 1;
+-        }
+-
++        if (deps->count != 1)
++                goto err;
++        if (!_is_dm_major(major(deps->device[0])))
++                goto err;
++        dm_task_destroy(task);
++        if (!(task = dm_task_create(DM_DEVICE_TABLE)))
++                return 0;
++        dm_task_set_name(task, path);
++        if (!dm_task_run(task))
++                goto err;
++        dm_get_next_target(task, NULL, &start, &length, &target_type, &params);
++        if (strcmp (target_type, "linear"))
++                goto err;
++        rc = 1;
+ err:
+         dm_task_destroy(task);
+         return rc;

=== modified file 'debian/patches/loop-partitions.patch'
--- debian/patches/loop-partitions.patch	2011-06-16 06:31:51 +0000
+++ debian/patches/loop-partitions.patch	2012-01-13 19:53:24 +0000
@@ -1,21 +1,207 @@
-From: Colin Watson <[e-mail]>
+From: Phillip Susi <[e-mail]>
 Forwarded: no
-Last-Update: 2010-02-22
-Description: Loop device naming
- Loop devices can only have one partition, so don't generate device names
- such as "/dev/loop0p1".
+Subject: Backport some changes to allow use of partitionable loop devices
+Description: Upstream has switched to using the newer sysfs attribute
+ "ext_range" instead of "range" to read the maximum supported partitions
+ of a device.  This allows loop devices to be partitioned even without
+ using the kernel max_part argument, as well as support for more than
+ 16 partitions.  Also added new PED_DEVICE_LOOP device type instead of
+ pretending loop devices are files.
 
 Index: b/libparted/arch/linux.c
 ===================================================================
 --- a/libparted/arch/linux.c
 +++ b/libparted/arch/linux.c
-@@ -2200,6 +2200,9 @@
-                 /* replace /disc with /path%d */
-                 strcpy (result, dev->path);
-                 snprintf (result + path_len - 5, 16, "/part%d", num);
-+        } else if (!strncmp (dev->path, "/dev/loop", 9)) {
-+                /* Loop devices can only have one partition. */
-+                strcpy (result, dev->path);
-         } else if (dev->type == PED_DEVICE_DAC960
-                         || dev->type == PED_DEVICE_CPQARRAY
-                         || dev->type == PED_DEVICE_ATARAID
+@@ -575,7 +575,7 @@
+         } else if (_is_virtblk_major(dev_major)) {
+                 dev->type = PED_DEVICE_VIRTBLK;
+         } else if (dev_major == LOOP_MAJOR) {
+-                dev->type = PED_DEVICE_FILE;
++                dev->type = PED_DEVICE_LOOP;
+         } else if (dev_major == MD_MAJOR) {
+                 dev->type = PED_DEVICE_MD;
+         } else {
+@@ -1400,6 +1400,11 @@
+                         goto error_free_arch_specific;
+                 break;
+ 
++        case PED_DEVICE_LOOP:
++                if (!init_generic (dev, _("Loopback device")))
++                        goto error_free_arch_specific;
++                break;
++
+         default:
+                 ped_exception_throw (PED_EXCEPTION_NO_FEATURE,
+                                 PED_EXCEPTION_CANCEL,
+@@ -2393,6 +2398,95 @@
+                                     BLKPG_DEL_PARTITION);
+ }
+ 
++/* Read the unsigned long long from /sys/block/DEV_BASE/PART_BASE/ENTRY
++   and set *VAL to that value, where DEV_BASE is the last component of path to
++   block device corresponding to PART and PART_BASE is the sysfs name of PART.
++   Upon success, return true. Otherwise, return false. */
++static bool
++_sysfs_ull_entry_from_part(PedPartition const* part, const char *entry,
++                           unsigned long long *val)
++{
++        char path[128];
++        char *part_name = linux_partition_get_path(part);
++        if (!part_name)
++                return false;
++
++        int r = snprintf(path, sizeof(path), "/sys/block/%s/%s/%s",
++                last_component(part->disk->dev->path),
++                last_component(part_name), entry);
++        free(part_name);
++        if (r < 0 || r >= sizeof(path))
++                return false;
++
++        FILE *fp = fopen(path, "r");
++        if (!fp)
++                return false;
++
++        bool ok = fscanf(fp, "%llu", val) == 1;
++        fclose(fp);
++
++        return ok;
++}
++
++
++/* Get the starting sector and length of a partition PART within a block device
++   Use blkpg if available, then check sysfs and then use HDIO_GETGEO and
++   BLKGETSIZE64 ioctls as fallback.  Upon success, return true.  Otherwise,
++   return false. */
++static bool
++_kernel_get_partition_start_and_length(PedPartition const *part,
++                                       unsigned long long *start,
++                                       unsigned long long *length)
++{
++        PED_ASSERT(part, return false);
++        PED_ASSERT(start, return false);
++        PED_ASSERT(length, return false);
++
++        char *dev_name = linux_partition_get_path (part);
++        if (!dev_name)
++                return false;
++
++        int ok = _sysfs_ull_entry_from_part (part, "start", start);
++        if (!ok) {
++                struct hd_geometry geom;
++                int dev_fd = open (dev_name, O_RDONLY);
++                if (dev_fd != -1 && ioctl (dev_fd, HDIO_GETGEO, &geom)) {
++                        *start = geom.start;
++                        ok = true;
++                } else {
++                        if (dev_fd != -1)
++                                close(dev_fd);
++                        free (dev_name);
++                        return false;
++                }
++        }
++        *start = (*start * 512) / part->disk->dev->sector_size;
++        ok = _sysfs_ull_entry_from_part (part, "size", length);
++
++        int fd;
++        if (!ok) {
++                fd = open (dev_name, O_RDONLY);
++                if (fd != -1 && ioctl (fd, BLKGETSIZE64, length))
++                        ok = true;
++        } else {
++                fd = -1;
++                *length *= 512;
++        }
++        *length /= part->disk->dev->sector_size;
++        if (fd != -1)
++                close (fd);
++
++        if (!ok)
++                ped_exception_throw (
++                        PED_EXCEPTION_BUG,
++                        PED_EXCEPTION_CANCEL,
++                        _("Unable to determine the start and length of %s."),
++                        dev_name);
++        free (dev_name);
++        return ok;
++}
++
++
+ /*
+  * The number of partitions that a device can have depends on the kernel.
+  * If we don't find this value in /sys/block/DEV/range, we will use our own
+@@ -2406,7 +2500,7 @@
+         FILE*       fp;
+         bool        ok;
+ 
+-        r = snprintf(path, sizeof(path), "/sys/block/%s/range",
++        r = snprintf(path, sizeof(path), "/sys/block/%s/ext_range",
+                      last_component(dev->path));
+         if (r < 0 || r >= sizeof(path))
+                 return MAX_NUM_PARTS;
+@@ -2487,33 +2581,16 @@
+         }
+ 
+         for (i = 1; i <= lpn; i++) {
+-                const PedPartition *part = ped_disk_get_partition (disk, i);
++                PedPartition *part = ped_disk_get_partition (disk, i);
+                 if (part) {
+                         if (!ok[i - 1] && errnums[i - 1] == EBUSY) {
+-                                struct hd_geometry geom;
+-                                unsigned long long length = 0;
++                                unsigned long long length;
++                                unsigned long long start;
+                                 /* get start and length of existing partition */
+-                                char *dev_name = _device_get_part_path (disk->dev, i);
+-                                if (!dev_name)
+-                                        goto cleanup;
+-                                int fd = open (dev_name, O_RDONLY);
+-                                if (fd == -1
+-				    || ioctl (fd, HDIO_GETGEO, &geom)
+-				    || ioctl (fd, BLKGETSIZE64, &length)) {
+-                                        ped_exception_throw (
+-                                                             PED_EXCEPTION_BUG,
+-                                                             PED_EXCEPTION_CANCEL,
+-			    _("Unable to determine the size and length of %s."),
+-                                                             dev_name);
+-                                        if (fd != -1)
+-                                                close (fd);
+-                                        free (dev_name);
++                                if (!_kernel_get_partition_start_and_length(part,
++                                                                &start, &length))
+                                         goto cleanup;
+-                                }
+-                                free (dev_name);
+-                                length /= disk->dev->sector_size;
+-                                close (fd);
+-                                if (geom.start == part->geom.start
++                                if (start == part->geom.start
+ 				    && length == part->geom.length)
+                                         ok[i - 1] = 1;
+                                 /* If the new partition is unchanged and the
+Index: b/include/parted/device.h
+===================================================================
+--- a/include/parted/device.h
++++ b/include/parted/device.h
+@@ -48,7 +48,8 @@
+         PED_DEVICE_SDMMC        = 14,
+         PED_DEVICE_VIRTBLK      = 15,
+         PED_DEVICE_AOE          = 16,
+-        PED_DEVICE_MD           = 17
++        PED_DEVICE_MD           = 17,
++        PED_DEVICE_LOOP         = 18
+ } PedDeviceType;
+ 
+ typedef struct _PedDevice PedDevice;
+Index: b/parted/parted.c
+===================================================================
+--- a/parted/parted.c
++++ b/parted/parted.c
+@@ -1398,7 +1398,7 @@
+                                          "cpqarray", "file", "ataraid", "i2o",
+                                          "ubd", "dasd", "viodasd", "sx8", "dm",
+                                          "xvd", "sd/mmc", "virtblk", "aoe",
+-                                         "md"};
++                                         "md", "loop"};
+         char*           peek_word;
+         char*           start;
+         char*           end;

=== modified file 'debian/patches/series'
--- debian/patches/series	2011-10-18 12:10:46 +0000
+++ debian/patches/series	2012-01-13 19:53:24 +0000
@@ -23,12 +23,15 @@
 tiny-disk-constraint.patch
 dasd-sync.patch
 linux-two-component.patch
+skip-floppy.patch
 
 # Ubuntu additions
 gptsync.patch
 loop-partitions.patch
+dmraid.patch
+dm-part-sync.patch
 udevadm-settle.patch
-dmraid.patch
 
 # Symbols for this ABI (amd64 as reference)
 update-abi-symbols.patch
+16-dos-partitions.patch

=== added file 'debian/patches/skip-floppy.patch'
--- debian/patches/skip-floppy.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/skip-floppy.patch	2012-01-13 19:53:24 +0000
@@ -0,0 +1,17 @@
+From: Phillip Susi <[e-mail]>
+Forwarded: yes
+Subject: Skip floppies when probing all devices
+Description: Floppies can't be partitioned anyhow, and some people
+ have misconfigured bios that thinks there is a floppy when there
+ actually isn't, and trying to scan it causes hanging.
+
+--- a/libparted/arch/linux.c
++++ b/libparted/arch/linux.c
+@@ -2094,6 +2094,7 @@
+ 		{ "dm-",	sizeof ("dm-") - 1	},
+ 		{ "loop",	sizeof ("loop") - 1	},
+ 		{ "ram",	sizeof ("ram") - 1	},
++		{ "fd",		sizeof ("fd") - 1	},
+ 		{ 0, 0 },
+ 	};
+ 

=== modified file 'debian/patches/udevadm-settle.patch'
--- debian/patches/udevadm-settle.patch	2011-06-16 06:31:51 +0000
+++ debian/patches/udevadm-settle.patch	2012-01-13 19:53:24 +0000
@@ -19,7 +19,7 @@
  #include <ctype.h>
  #include <errno.h>
  #include <fcntl.h>
-@@ -2797,16 +2798,60 @@
+@@ -2908,13 +2909,55 @@
          return have_blkpg = kver >= KERNEL_VERSION (2,4,0) ? 1 : 0;
  }
  
@@ -72,17 +72,10 @@
 +                /* ignore failures */
 +        }
 +
- #ifdef ENABLE_DEVICE_MAPPER
--        if (disk->dev->type == PED_DEVICE_DM)
--                return _dm_reread_part_table (disk);
-+        if (disk->dev->type == PED_DEVICE_DM) {
-+                ret = _dm_reread_part_table (disk);
-+                goto out;
-+        }
- #endif
          if (disk->dev->type != PED_DEVICE_FILE) {
  
-@@ -2817,10 +2862,20 @@
+ 		/* We now require BLKPG support.  If this assertion fails,
+@@ -2924,10 +2967,20 @@
  		assert (_have_blkpg ());
  
  		if (!_disk_sync_part_table (disk))