Attachment #232119 for bug #320563

Lines 562-569 Link Here

(-)orig/configure (-3 / +3 lines)
562	# Identity of this package.	562	# Identity of this package.
563	PACKAGE_NAME='GNU parted'	563	PACKAGE_NAME='GNU parted'
564	PACKAGE_TARNAME='parted'	564	PACKAGE_TARNAME='parted'
565	PACKAGE_VERSION='2.2'	565	PACKAGE_VERSION='2.2.1'
566	PACKAGE_STRING='GNU parted 2.2'	566	PACKAGE_STRING='GNU parted 2.2.1'
567	PACKAGE_BUGREPORT='bug-parted@gnu.org'	567	PACKAGE_BUGREPORT='bug-parted@gnu.org'
568	PACKAGE_URL='http://www.gnu.org/software/parted/'	568	PACKAGE_URL='http://www.gnu.org/software/parted/'
569		569
Lines 3599-3605 Link Here
3599		3599
3600	# Define the identity of the package.	3600	# Define the identity of the package.
3601	PACKAGE='parted'	3601	PACKAGE='parted'
3602	VERSION='2.2'	3602	VERSION='2.2.1'
3603		3603
3604		3604
3605	cat >>confdefs.h <<_ACEOF	3605	cat >>confdefs.h <<_ACEOF

Lines 39-45 Link Here

(-)orig/include/parted/debug.h (-3 / +3 lines)
39		39
40	#define PED_DEBUG(level, ...) \	40	#define PED_DEBUG(level, ...) \
41	ped_debug ( level, __FILE__, __LINE__, __PRETTY_FUNCTION__, \	41	ped_debug ( level, __FILE__, __LINE__, __PRETTY_FUNCTION__, \
42	__VA_ARGS__ );	42	__VA_ARGS__ )
43		43
44	#define PED_ASSERT(cond, action) \	44	#define PED_ASSERT(cond, action) \
45	do { \	45	do { \
Lines 79-86 Link Here
79		79
80	#else /* !DEBUG */	80	#else /* !DEBUG */
81		81
82	#define PED_ASSERT(cond, action) while (0) {}	82	#define PED_ASSERT(cond, action) do {} while (0)
83	#define PED_DEBUG(level, ...) while (0) {}	83	#define PED_DEBUG(level, ...) do {} while (0)
84		84
85		85
86	#endif /* DEBUG */	86	#endif /* DEBUG */

Lines 46-52 Link Here

(-)orig/include/parted/device.h (-2 / +4 lines)
46	PED_DEVICE_DM = 12,	46	PED_DEVICE_DM = 12,
47	PED_DEVICE_XVD = 13,	47	PED_DEVICE_XVD = 13,
48	PED_DEVICE_SDMMC = 14,	48	PED_DEVICE_SDMMC = 14,
49	PED_DEVICE_VIRTBLK = 15	49	PED_DEVICE_VIRTBLK = 15,
		50	PED_DEVICE_AOE = 16,
		51	PED_DEVICE_MD = 17
50	} PedDeviceType;	52	} PedDeviceType;
51		53
52	typedef struct _PedDevice PedDevice;	54	typedef struct _PedDevice PedDevice;
Lines 144-150 Link Here
144	extern int ped_device_sync_fast (PedDevice* dev);	146	extern int ped_device_sync_fast (PedDevice* dev);
145	extern PedSector ped_device_check (PedDevice* dev, void* buffer,	147	extern PedSector ped_device_check (PedDevice* dev, void* buffer,
146	PedSector start, PedSector count);	148	PedSector start, PedSector count);
147	extern PedConstraint* ped_device_get_constraint (PedDevice* dev);	149	extern PedConstraint* ped_device_get_constraint (const PedDevice* dev);
148		150
149	extern PedConstraint *ped_device_get_minimal_aligned_constraint(	151	extern PedConstraint *ped_device_get_minimal_aligned_constraint(
150	const PedDevice *dev);	152	const PedDevice *dev);

Lines 68-77 Link Here

(-)orig/include/parted/disk.h (-2 / +3 lines)
68	PED_PARTITION_PREP=10,	68	PED_PARTITION_PREP=10,
69	PED_PARTITION_MSFT_RESERVED=11,	69	PED_PARTITION_MSFT_RESERVED=11,
70	PED_PARTITION_BIOS_GRUB=12,	70	PED_PARTITION_BIOS_GRUB=12,
71	PED_PARTITION_APPLE_TV_RECOVERY=13	71	PED_PARTITION_APPLE_TV_RECOVERY=13,
		72	PED_PARTITION_DIAG=14
72	};	73	};
73	#define PED_PARTITION_FIRST_FLAG PED_PARTITION_BOOT	74	#define PED_PARTITION_FIRST_FLAG PED_PARTITION_BOOT
74	#define PED_PARTITION_LAST_FLAG PED_PARTITION_APPLE_TV_RECOVERY	75	#define PED_PARTITION_LAST_FLAG PED_PARTITION_DIAG
75		76
76	enum _PedDiskTypeFeature {	77	enum _PedDiskTypeFeature {
77	PED_DISK_TYPE_EXTENDED=1, /*< supports extended partitions /	78	PED_DISK_TYPE_EXTENDED=1, /*< supports extended partitions /





#include <config.h>
#include <arch/linux.h>
#include <linux/blkpg.h>
#include <parted/parted.h>
#include <parted/debug.h>
#if defined __s390__ || defined __s390x__

#define UBD_MAJOR               98
#define DASD_MAJOR              94
#define VIODASD_MAJOR           112
#define AOE_MAJOR               152
#define SX8_MAJOR1              160
#define SX8_MAJOR2              161
#define XVD_MAJOR               202
#define SDMMC_MAJOR             179
#define LOOP_MAJOR              7
#define MD_MAJOR                9

#define SCSI_BLK_MAJOR(M) (                                             \
                (M) == SCSI_DISK0_MAJOR                                 \

                dev->type = PED_DEVICE_DAC960;
        } else if (dev_major == ATARAID_MAJOR && (dev_minor % 0x10 == 0)) {
                dev->type = PED_DEVICE_ATARAID;
        } else if (dev_major == AOE_MAJOR && (dev_minor % 0x10 == 0)) {
                dev->type = PED_DEVICE_AOE;
        } else if (dev_major == DASD_MAJOR && (dev_minor % 0x4 == 0)) {
                dev->type = PED_DEVICE_DASD;
        } else if (dev_major == VIODASD_MAJOR && (dev_minor % 0x8 == 0)) {

                dev->type = PED_DEVICE_VIRTBLK;
        } else if (dev_major == LOOP_MAJOR) {
                dev->type = PED_DEVICE_FILE;
        } else if (dev_major == MD_MAJOR) {
                dev->type = PED_DEVICE_MD;
        } else {
                dev->type = PED_DEVICE_UNKNOWN;
        }

                dev->sector_size = PED_SECTOR_SIZE_DEFAULT;
        }
#endif

        if (dev->sector_size != PED_SECTOR_SIZE_DEFAULT) {
                ped_exception_throw (
                        PED_EXCEPTION_WARNING,
                        PED_EXCEPTION_OK,
                        _("Device %s has a logical sector size of %lld.  Not "
                          "all parts of GNU Parted support this at the moment, "
                          "and the working code is HIGHLY EXPERIMENTAL.\n"),
                        dev->path, dev->sector_size);
        }
}

static int

                        goto error_free_arch_specific;
                break;

        case PED_DEVICE_AOE:
                if (!init_generic (dev, _("ATA over Ethernet Device")))
                    goto error_free_arch_specific;
                break;

#if defined __s390__ || defined __s390x__
        case PED_DEVICE_DASD:
                if (!init_dasd (dev, _("IBM S390 DASD drive")))

                        goto error_free_arch_specific;
                break;

        case PED_DEVICE_MD:
                if (!init_generic(dev, _("Linux Software RAID Array")))
                        goto error_free_arch_specific;
                break;

        default:
                ped_exception_throw (PED_EXCEPTION_NO_FEATURE,
                                PED_EXCEPTION_CANCEL,

        return 0;
}

static int
_blkpg_part_command (PedDevice* dev, struct blkpg_partition* part, int op)
{
        LinuxSpecific*          arch_specific = LINUX_SPECIFIC (dev);
        struct blkpg_ioctl_arg  ioctl_arg;

        ioctl_arg.op = op;
        ioctl_arg.flags = 0;
        ioctl_arg.datalen = sizeof (struct blkpg_partition);
        ioctl_arg.data = (void*) part;

        return ioctl (arch_specific->fd, BLKPG, &ioctl_arg) == 0;
}

static int
_blkpg_add_partition (PedDisk* disk, const PedPartition *part)
{
        struct blkpg_partition  linux_part;
        const char*             vol_name;
        char*                   dev_name;

        PED_ASSERT(disk != NULL, return 0);
        PED_ASSERT(disk->dev->sector_size % PED_SECTOR_SIZE_DEFAULT == 0,
                   return 0);

        if (!_has_partitions (disk))
                return 0;

        if (ped_disk_type_check_feature (disk->type,
                                         PED_DISK_TYPE_PARTITION_NAME))
                vol_name = ped_partition_get_name (part);
        else
                vol_name = NULL;

        dev_name = _device_get_part_path (disk->dev, part->num);
        if (!dev_name)
                return 0;

        memset (&linux_part, 0, sizeof (linux_part));
        linux_part.start = part->geom.start * disk->dev->sector_size;
        /* see fs/partitions/msdos.c:msdos_partition(): "leave room for LILO" */
        if (part->type & PED_PARTITION_EXTENDED)
                linux_part.length = part->geom.length == 1 ? 512 : 1024;
        else
                linux_part.length = part->geom.length * disk->dev->sector_size;
        linux_part.pno = part->num;
        strncpy (linux_part.devname, dev_name, BLKPG_DEVNAMELTH);
        if (vol_name)
                strncpy (linux_part.volname, vol_name, BLKPG_VOLNAMELTH);

        free (dev_name);

        if (!_blkpg_part_command (disk->dev, &linux_part,
                                  BLKPG_ADD_PARTITION)) {
                return ped_exception_throw (
                        PED_EXCEPTION_ERROR,
                        PED_EXCEPTION_IGNORE_CANCEL,
                        _("Error informing the kernel about modifications to "
                          "partition %s -- %s.  This means Linux won't know "
                          "about any changes you made to %s until you reboot "
                          "-- so you shouldn't mount it or use it in any way "
                          "before rebooting."),
                        linux_part.devname,
                        strerror (errno),
                        linux_part.devname)
                                == PED_EXCEPTION_IGNORE;
        }

        return 1;
}

static int
_blkpg_remove_partition (PedDisk* disk, int n)
{
        struct blkpg_partition  linux_part;

        if (!_has_partitions (disk))
                return 0;

        memset (&linux_part, 0, sizeof (linux_part));
        linux_part.pno = n;
        return _blkpg_part_command (disk->dev, &linux_part,
                                    BLKPG_DEL_PARTITION);
}

/*
 * 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
 * value.
 */
static unsigned int
_device_get_partition_range(PedDevice* dev)
{
        int         range, r;
        char        path[128];
        FILE*       fp;
        bool        ok;

        r = snprintf(path, sizeof(path), "/sys/block/%s/range",
                     last_component(dev->path));
        if (r < 0 || r >= sizeof(path))
                return MAX_NUM_PARTS;

        fp = fopen(path, "r");
        if (!fp)
                return MAX_NUM_PARTS;

        ok = fscanf(fp, "%d", &range) == 1;
        fclose(fp);

        /* (range <= 0) is none sense.*/
        return ok && range > 0 ? range : MAX_NUM_PARTS;
}

/*
 * Sync the partition table in two step process:
 * 1. Remove all of the partitions from the kernel's tables, but do not attempt
 *    removal of any partition for which the corresponding ioctl call fails.
 * 2. Add all the partitions that we hold in disk, throwing a warning
 *    if we cannot because step 1 failed to remove it and it is not being
 *    added back with the same start and length.
 *
 * To achieve this two step process we must calculate the minimum number of
 * maximum possible partitions between what linux supports and what the label
 * type supports. EX:
 *
 * number=MIN(max_parts_supported_in_linux,max_parts_supported_in_msdos_tables)
 */
static int
_disk_sync_part_table (PedDisk* disk)
{
        PED_ASSERT(disk != NULL, return 0);
        PED_ASSERT(disk->dev != NULL, return 0);
        int lpn;

        /* lpn = largest partition number. */
        if (ped_disk_get_max_supported_partition_count(disk, &lpn))
                lpn = PED_MIN(lpn, _device_get_partition_range(disk->dev));
        else
                lpn = _device_get_partition_range(disk->dev);

        /* Its not possible to support largest_partnum < 0.
         * largest_partnum == 0 would mean does not support partitions.
         * */
        if (lpn < 0)
                return 0;
        int ret = 0;
        int *ok = calloc (lpn, sizeof *ok);
        if (!ok)
                return 0;
        int *errnums = ped_malloc(sizeof(int) * lpn);
        if (!errnums)
                goto cleanup;

        /* Attempt to remove each and every partition, retrying for
           up to max_sleep_seconds upon any failure due to EBUSY. */
        unsigned int sleep_microseconds = 10000;
        unsigned int max_sleep_seconds = 1;
        unsigned int n_sleep = (max_sleep_seconds
                                * 1000000 / sleep_microseconds);
        int i;
        for (i = 0; i < n_sleep; i++) {
	    if (i)
		usleep (sleep_microseconds);
            bool busy = false;
            int j;
            for (j = 0; j < lpn; j++) {
                if (!ok[j]) {
                    ok[j] = _blkpg_remove_partition (disk, j + 1);
                    errnums[j] = errno;
                    if (!ok[j] && errnums[j] == EBUSY)
                        busy = true;
                }
            }
            if (!busy)
                break;
        }

        for (i = 1; i <= lpn; i++) {
                const 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;
                                /* 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);
                                        goto cleanup;
                                }
                                free (dev_name);
                                length /= disk->dev->sector_size;
                                close (fd);
                                if (geom.start == part->geom.start
				    && length == part->geom.length)
                                        ok[i - 1] = 1;
                                /* If the new partition is unchanged and the
				   existing one was not removed because it was
				   in use, then reset the error flag and do not
				   try to add it since it is already there.  */
                                continue;
                        }

                        /* add the (possibly modified or new) partition */
                        if (!_blkpg_add_partition (disk, part)) {
                                ped_exception_throw (
                                        PED_EXCEPTION_ERROR,
                                        PED_EXCEPTION_RETRY_CANCEL,
                                        _("Failed to add partition %d (%s)"),
                                        i, strerror (errno));
                                goto cleanup;
                        }
                }
        }

        char *bad_part_list = NULL;
        /* now warn about any errors */
        for (i = 1; i <= lpn; i++) {
		if (ok[i - 1] || errnums[i - 1] == ENXIO)
			continue;
		if (bad_part_list == NULL) {
			  bad_part_list = malloc (lpn * 5);
			  if (!bad_part_list)
				  goto cleanup;
			  bad_part_list[0] = 0;
		}
		sprintf (bad_part_list + strlen (bad_part_list), "%d, ", i);
	}
        if (bad_part_list == NULL)
		ret = 1;
	else {
                bad_part_list[strlen (bad_part_list) - 2] = 0;
                if (ped_exception_throw (
                        PED_EXCEPTION_ERROR,
                        PED_EXCEPTION_IGNORE_CANCEL,
                        _("Partition(s) %s on %s have been written, but we have "
			  "been unable to inform the kernel of the change, "
			  "probably because it/they are in use.  As a result, "
                          "the old partition(s) will remain in use.  You "
                          "should reboot now before making further changes."),
                        bad_part_list, disk->dev->path) == PED_EXCEPTION_IGNORE)
                        ret = 1;
		free (bad_part_list);
        }
 cleanup:
        free (errnums);
        free (ok);
        return ret;
}

#ifdef ENABLE_DEVICE_MAPPER
static int
_dm_remove_map_name(char *name)

        rc = dm_task_run(task);
        dm_task_update_nodes();
        dm_task_destroy(task);
        if (!rc)
                return 1;

        return 0;

                return 0;

        dm_task_set_name(task, name);
        if (!dm_task_run(task))
        if (rc < 0) {
                rc = 0;
                goto err;
        }
        rc = 0;

        memset(info, '\0', sizeof *info);
        dm_task_get_info(task, info);

        if (!deps)
                goto err;

        rc = 0;
        for (i = 0; i < deps->count; i++) {
                unsigned int ma = major(deps->device[i]),
                             mi = minor(deps->device[i]);

                                      arch_specific->minor, 0))
                goto err;

        if (!dm_task_run(task))
        if (rc < 0)
                goto err;

        memset(info, '\0', sizeof *info);

static int
_dm_add_partition (PedDisk* disk, PedPartition* part)
{
        int             rc;
        char*           vol_name = NULL;
        const char*     dev_name = NULL;
        char*           params = NULL;

                                      arch_specific->minor, 0))
                goto err;

        if (!dm_task_run(task))
        if (rc < 0)
                goto err;

        dev_name = dm_task_get_name (task);

        dm_task_set_name (task, vol_name);
        dm_task_add_target (task, 0, part->geom.length,
                "linear", params);
        if (dm_task_run (task)) {
        if (rc >= 0) {
                //printf("0 %ld linear %s\n", part->geom.length, params);
                dm_task_update_nodes();
                dm_task_destroy(task);

#endif

static int
_have_blkpg ()
{
        static int have_blkpg = -1;
        int kver;

        sync();
        while (ioctl (arch_specific->fd, BLKRRPART)) {
                retry_count--;
                sync();
                if (retry_count == 3)
                        sleep(1); /* Pause to allow system to settle */

        if (have_blkpg != -1)
                return have_blkpg;
                                PED_EXCEPTION_WARNING,
                                PED_EXCEPTION_IGNORE,
                        _("WARNING: the kernel failed to re-read the partition "
                          "table on %s (%s).  As a result, it may not "
                          "reflect all of your changes until after reboot."),
                                dev->path, strerror (errno));
                        return 0;
                }
        }

        kver = _get_linux_version();
        return have_blkpg = kver >= KERNEL_VERSION (2,4,0) ? 1 : 0;
}

/* Return nonzero upon success, 0 if something fails.  */
static int
linux_disk_commit (PedDisk* disk)
{
        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) {
                /* The ioctl() command BLKPG_ADD_PARTITION does not notify
                 * the devfs system; consequently, /proc/partitions will not
                 * be up to date, and the proper links in /dev are not
                 * created.  Therefore, if using DevFS, we must get the kernel
                 * to re-read and grok the partition table.
                 */
                /* Work around kernel dasd problem so we really do BLKRRPART */
		int ok = 1;
		if (disk->dev->type != PED_DEVICE_DASD && _have_blkpg ()) {
			if (!_disk_sync_part_table (disk))
			  ok = 0;
		}

                return ok;
        }

        return 1;
}

#if USE_BLKID
static PedAlignment*
linux_get_minimum_alignment(const PedDevice *dev)
{
        blkid_topology tp = LINUX_SPECIFIC(dev)->topology;

                blkid_topology_get_minimum_io_size(tp) / dev->sector_size);
}

static PedAlignment*
linux_get_optimum_alignment(const PedDevice *dev)
{
        blkid_topology tp = LINUX_SPECIFIC(dev)->topology;

Lines 73-78 Link Here

(-)orig/libparted/device.c (-3 / +15 lines)
73	if (walk == dev) break;	73	if (walk == dev) break;
74	}	74	}
75		75
		76	/* This function may be called twice for the same device if a
		77	libparted user explictly removes the device from the cache using
		78	ped_device_cache_remove(), we get called and it then becomes the
		79	user's responsibility to free the PedDevice by calling
		80	ped_device_destroy().
		81	ped_device_destroy() will then call us a second time, so if the
		82	device is not found in the list do nothing. */
		83	if (walk == NULL)
		84	return;
		85
76	if (last)	86	if (last)
77	last->next = dev->next;	87	last->next = dev->next;
78	else	88	else
Lines 139-148 Link Here
139	ped_device_get (const char* path)	149	ped_device_get (const char* path)
140	{	150	{
141	PedDevice* walk;	151	PedDevice* walk;
142	char* normal_path;	152	char* normal_path = NULL;
143		153
144	PED_ASSERT (path != NULL, return NULL);	154	PED_ASSERT (path != NULL, return NULL);
145	normal_path = canonicalize_file_name (path);	155	/* Don't canonicalize /dev/mapper paths, see tests/symlink.c */
		156	if (strncmp (path, "/dev/mapper/", 12))
		157	normal_path = canonicalize_file_name (path);
146	if (!normal_path)	158	if (!normal_path)
147	/* Well, maybe it is just that the file does not exist.	159	/* Well, maybe it is just that the file does not exist.
148	* Try it anyway. */	160	* Try it anyway. */
Lines 401-407 Link Here
401	* constraint.	413	* constraint.
402	*/	414	*/
403	PedConstraint*	415	PedConstraint*
404	ped_device_get_constraint (PedDevice* dev)	416	ped_device_get_constraint (const PedDevice* dev)
405	{	417	{
406	PedGeometry s, e;	418	PedGeometry s, e;
407	PedConstraint* c = ped_constraint_new (	419	PedConstraint* c = ped_constraint_new (

Lines 2442-2447 Link Here

(-)orig/libparted/disk.c (+2 lines)
2442	return N_("msftres");	2442	return N_("msftres");
2443	case PED_PARTITION_APPLE_TV_RECOVERY:	2443	case PED_PARTITION_APPLE_TV_RECOVERY:
2444	return N_("atvrecv");	2444	return N_("atvrecv");
		2445	case PED_PARTITION_DIAG:
		2446	return N_("diag");
2445		2447
2446	default:	2448	default:
2447	ped_exception_throw (	2449	ped_exception_throw (




#define EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER	0x0001
#define EXT2_FEATURE_RO_COMPAT_LARGE_FILE	0x0002
#define EXT4_FEATURE_RO_COMPAT_HUGE_FILE	0x0008
#define EXT4_FEATURE_RO_COMPAT_GDT_CSUM		0x0010
#define EXT4_FEATURE_RO_COMPAT_DIR_NLINK	0x0020

#define EXT2_FEATURE_INCOMPAT_FILETYPE		0x0002
#define EXT3_FEATURE_INCOMPAT_RECOVER		0x0004
#define EXT4_FEATURE_INCOMPAT_EXTENTS		0x0040
#define EXT4_FEATURE_INCOMPAT_64BIT		0x0080
#define EXT4_FEATURE_INCOMPAT_FLEX_BG		0x0200

/*
 * Special inodes numbers

Lines 55-65 Link Here

(-)orig/libparted/fs/ext2/interface.c (-1 / +5 lines)
55	is_ext4 = ((EXT2_SUPER_FEATURE_RO_COMPAT (*sb)	55	is_ext4 = ((EXT2_SUPER_FEATURE_RO_COMPAT (*sb)
56	& EXT4_FEATURE_RO_COMPAT_HUGE_FILE)	56	& EXT4_FEATURE_RO_COMPAT_HUGE_FILE)
57	\|\| (EXT2_SUPER_FEATURE_RO_COMPAT (*sb)	57	\|\| (EXT2_SUPER_FEATURE_RO_COMPAT (*sb)
		58	& EXT4_FEATURE_RO_COMPAT_GDT_CSUM)
		59	\|\| (EXT2_SUPER_FEATURE_RO_COMPAT (*sb)
58	& EXT4_FEATURE_RO_COMPAT_DIR_NLINK)	60	& EXT4_FEATURE_RO_COMPAT_DIR_NLINK)
59	\|\| (EXT2_SUPER_FEATURE_INCOMPAT (*sb)	61	\|\| (EXT2_SUPER_FEATURE_INCOMPAT (*sb)
60	& EXT4_FEATURE_INCOMPAT_EXTENTS)	62	& EXT4_FEATURE_INCOMPAT_EXTENTS)
61	\|\| (EXT2_SUPER_FEATURE_INCOMPAT (*sb)	63	\|\| (EXT2_SUPER_FEATURE_INCOMPAT (*sb)
62	& EXT4_FEATURE_INCOMPAT_64BIT));	64	& EXT4_FEATURE_INCOMPAT_64BIT)
		65	\|\| (EXT2_SUPER_FEATURE_INCOMPAT (*sb)
		66	& EXT4_FEATURE_INCOMPAT_FLEX_BG));
63	if (is_ext4)	67	if (is_ext4)
64	is_ext3 = 0;	68	is_ext3 = 0;
65	}	69	}

Lines 82-88 Link Here

(-)orig/libparted/fs/ext2/parted_io.c (-3 / +5 lines)
82	{	82	{
83	struct my_cookie *monster = cookie;	83	struct my_cookie *monster = cookie;
84		84
85	return ped_geometry_read(monster->geom, ptr, block << (monster->logsize - 9), num << (monster->logsize - 9));	85	return ped_geometry_read(monster->geom, ptr,
		86	(PedSector) block << (monster->logsize - 9),
		87	(PedSector) num << (monster->logsize - 9));
86	}	88	}
87		89
88	static int do_set_blocksize(void *cookie, int logsize)	90	static int do_set_blocksize(void *cookie, int logsize)
Lines 98-105 Link Here
98	struct my_cookie *monster = cookie;	100	struct my_cookie *monster = cookie;
99		101
100	return ped_geometry_write(monster->geom, ptr,	102	return ped_geometry_write(monster->geom, ptr,
101	block << (monster->logsize - 9),	103	(PedSector) block << (monster->logsize - 9),
102	num << (monster->logsize - 9));	104	(PedSector) num << (monster->logsize - 9));
103	}	105	}
104		106
105		107

Lines 81-86 Link Here

(-)orig/libparted/labels/dos.c (-26 / +67 lines)
81	#define PARTITION_FAT16_LBA_H (PARTITION_FAT16_LBA \| PART_FLAG_HIDDEN)	81	#define PARTITION_FAT16_LBA_H (PARTITION_FAT16_LBA \| PART_FLAG_HIDDEN)
82		82
83	#define PARTITION_COMPAQ_DIAG 0x12	83	#define PARTITION_COMPAQ_DIAG 0x12
		84	#define PARTITION_MSFT_RECOVERY 0x27
84	#define PARTITION_LDM 0x42	85	#define PARTITION_LDM 0x42
85	#define PARTITION_LINUX_SWAP 0x82	86	#define PARTITION_LINUX_SWAP 0x82
86	#define PARTITION_LINUX 0x83	87	#define PARTITION_LINUX 0x83
Lines 157-162 Link Here
157	int lba;	158	int lba;
158	int palo;	159	int palo;
159	int prep;	160	int prep;
		161	int diag;
160	OrigState* orig; /* used for CHS stuff */	162	OrigState* orig; /* used for CHS stuff */
161	} DosPartitionData;	163	} DosPartitionData;
162		164
Lines 828-833 Link Here
828	dos_data = part->disk_specific;	830	dos_data = part->disk_specific;
829	dos_data->system = raw_part->type;	831	dos_data->system = raw_part->type;
830	dos_data->boot = raw_part->boot_ind != 0;	832	dos_data->boot = raw_part->boot_ind != 0;
		833	dos_data->diag = raw_part->type == PARTITION_COMPAQ_DIAG \|\|
		834	raw_part->type == PARTITION_MSFT_RECOVERY \|\|
		835	raw_part->type == PARTITION_DELL_DIAG;
831	dos_data->hidden = raw_part_is_hidden (raw_part);	836	dos_data->hidden = raw_part_is_hidden (raw_part);
832	dos_data->raid = raw_part->type == PARTITION_LINUX_RAID;	837	dos_data->raid = raw_part->type == PARTITION_LINUX_RAID;
833	dos_data->lvm = raw_part->type == PARTITION_LINUX_LVM_OLD	838	dos_data->lvm = raw_part->type == PARTITION_LINUX_LVM_OLD
Lines 1231-1236 Link Here
1231	dos_data->system = PARTITION_LINUX;	1236	dos_data->system = PARTITION_LINUX;
1232	dos_data->hidden = 0;	1237	dos_data->hidden = 0;
1233	dos_data->boot = 0;	1238	dos_data->boot = 0;
		1239	dos_data->diag = 0;
1234	dos_data->raid = 0;	1240	dos_data->raid = 0;
1235	dos_data->lvm = 0;	1241	dos_data->lvm = 0;
1236	dos_data->lba = 0;	1242	dos_data->lba = 0;
Lines 1264-1269 Link Here
1264	new_dos_data = (DosPartitionData*) new_part->disk_specific;	1270	new_dos_data = (DosPartitionData*) new_part->disk_specific;
1265	new_dos_data->system = old_dos_data->system;	1271	new_dos_data->system = old_dos_data->system;
1266	new_dos_data->boot = old_dos_data->boot;	1272	new_dos_data->boot = old_dos_data->boot;
		1273	new_dos_data->diag = old_dos_data->diag;
1267	new_dos_data->hidden = old_dos_data->hidden;	1274	new_dos_data->hidden = old_dos_data->hidden;
1268	new_dos_data->raid = old_dos_data->raid;	1275	new_dos_data->raid = old_dos_data->raid;
1269	new_dos_data->lvm = old_dos_data->lvm;	1276	new_dos_data->lvm = old_dos_data->lvm;
Lines 1313-1318 Link Here
1313	dos_data->hidden = 0;	1320	dos_data->hidden = 0;
1314		1321
1315	if (part->type & PED_PARTITION_EXTENDED) {	1322	if (part->type & PED_PARTITION_EXTENDED) {
		1323	dos_data->diag = 0;
1316	dos_data->raid = 0;	1324	dos_data->raid = 0;
1317	dos_data->lvm = 0;	1325	dos_data->lvm = 0;
1318	dos_data->palo = 0;	1326	dos_data->palo = 0;
Lines 1324-1329 Link Here
1324	return 1;	1332	return 1;
1325	}	1333	}
1326		1334
		1335	if (dos_data->diag) {
		1336	/* Don't change the system if it already is a diag type,
		1337	otherwise use Compaq as almost all vendors use that. */
		1338	if (dos_data->system != PARTITION_COMPAQ_DIAG &&
		1339	dos_data->system != PARTITION_MSFT_RECOVERY &&
		1340	dos_data->system != PARTITION_DELL_DIAG)
		1341	dos_data->system = PARTITION_COMPAQ_DIAG;
		1342	return 1;
		1343	}
1327	if (dos_data->lvm) {	1344	if (dos_data->lvm) {
1328	dos_data->system = PARTITION_LINUX_LVM;	1345	dos_data->system = PARTITION_LINUX_LVM;
1329	return 1;	1346	return 1;
Lines 1368-1373 Link Here
1368	return 1;	1385	return 1;
1369	}	1386	}
1370		1387
		1388	static void
		1389	clear_flags (DosPartitionData *dos_data)
		1390	{
		1391	dos_data->diag = 0;
		1392	dos_data->hidden = 0;
		1393	dos_data->lvm = 0;
		1394	dos_data->palo = 0;
		1395	dos_data->prep = 0;
		1396	dos_data->raid = 0;
		1397	}
		1398
1371	static int	1399	static int
1372	msdos_partition_set_flag (PedPartition* part,	1400	msdos_partition_set_flag (PedPartition* part,
1373	PedPartitionFlag flag, int state)	1401	PedPartitionFlag flag, int state)
Lines 1409-1431 Link Here
1409	}	1437	}
1410	return 1;	1438	return 1;
1411		1439
		1440	case PED_PARTITION_DIAG:
		1441	if (state)
		1442	clear_flags (dos_data);
		1443	dos_data->diag = state;
		1444	return ped_partition_set_system (part, part->fs_type);
		1445
1412	case PED_PARTITION_RAID:	1446	case PED_PARTITION_RAID:
1413	if (state) {	1447	if (state)
1414	dos_data->hidden = 0;	1448	clear_flags (dos_data);
1415	dos_data->lvm = 0;
1416	dos_data->palo = 0;
1417	dos_data->prep = 0;
1418	}
1419	dos_data->raid = state;	1449	dos_data->raid = state;
1420	return ped_partition_set_system (part, part->fs_type);	1450	return ped_partition_set_system (part, part->fs_type);
1421		1451
1422	case PED_PARTITION_LVM:	1452	case PED_PARTITION_LVM:
1423	if (state) {	1453	if (state)
1424	dos_data->hidden = 0;	1454	clear_flags (dos_data);
1425	dos_data->raid = 0;
1426	dos_data->palo = 0;
1427	dos_data->prep = 0;
1428	}
1429	dos_data->lvm = state;	1455	dos_data->lvm = state;
1430	return ped_partition_set_system (part, part->fs_type);	1456	return ped_partition_set_system (part, part->fs_type);
1431		1457
Lines 1434-1453 Link Here
1434	return ped_partition_set_system (part, part->fs_type);	1460	return ped_partition_set_system (part, part->fs_type);
1435		1461
1436	case PED_PARTITION_PALO:	1462	case PED_PARTITION_PALO:
1437	if (state) {	1463	if (state)
1438	dos_data->hidden = 0;	1464	clear_flags (dos_data);
1439	dos_data->raid = 0;
1440	dos_data->lvm = 0;
1441	}
1442	dos_data->palo = state;	1465	dos_data->palo = state;
1443	return ped_partition_set_system (part, part->fs_type);	1466	return ped_partition_set_system (part, part->fs_type);
1444		1467
1445	case PED_PARTITION_PREP:	1468	case PED_PARTITION_PREP:
1446	if (state) {	1469	if (state)
1447	dos_data->hidden = 0;	1470	clear_flags (dos_data);
1448	dos_data->raid = 0;
1449	dos_data->lvm = 0;
1450	}
1451	dos_data->prep = state;	1471	dos_data->prep = state;
1452	return ped_partition_set_system (part, part->fs_type);	1472	return ped_partition_set_system (part, part->fs_type);
1453		1473
Lines 1467-1477 Link Here
1467	dos_data = part->disk_specific;	1487	dos_data = part->disk_specific;
1468	switch (flag) {	1488	switch (flag) {
1469	case PED_PARTITION_HIDDEN:	1489	case PED_PARTITION_HIDDEN:
1470	return dos_data->hidden;	1490	if (part->type == PED_PARTITION_EXTENDED)
		1491	return 0;
		1492	else
		1493	return dos_data->hidden;
1471		1494
1472	case PED_PARTITION_BOOT:	1495	case PED_PARTITION_BOOT:
1473	return dos_data->boot;	1496	return dos_data->boot;
1474		1497
		1498	case PED_PARTITION_DIAG:
		1499	return dos_data->diag;
		1500
1475	case PED_PARTITION_RAID:	1501	case PED_PARTITION_RAID:
1476	return dos_data->raid;	1502	return dos_data->raid;
1477		1503
Lines 1498-1509 Link Here
1498	{	1524	{
1499	switch (flag) {	1525	switch (flag) {
1500	case PED_PARTITION_HIDDEN:	1526	case PED_PARTITION_HIDDEN:
		1527	if (part->type == PED_PARTITION_EXTENDED)
		1528	return 0;
		1529	else
		1530	return 1;
		1531
1501	case PED_PARTITION_BOOT:	1532	case PED_PARTITION_BOOT:
1502	case PED_PARTITION_RAID:	1533	case PED_PARTITION_RAID:
1503	case PED_PARTITION_LVM:	1534	case PED_PARTITION_LVM:
1504	case PED_PARTITION_LBA:	1535	case PED_PARTITION_LBA:
1505	case PED_PARTITION_PALO:	1536	case PED_PARTITION_PALO:
1506	case PED_PARTITION_PREP:	1537	case PED_PARTITION_PREP:
		1538	case PED_PARTITION_DIAG:
1507	return 1;	1539	return 1;
1508		1540
1509	default:	1541	default:
Lines 1606-1613 Link Here
1606	dev->length - min_geom->end))	1638	dev->length - min_geom->end))
1607	return NULL;	1639	return NULL;
1608	} else {	1640	} else {
1609	if (!ped_geometry_init (&start_geom, dev, cylinder_size,	1641	/* Do not assume that length is larger than 1 cylinder's
1610	dev->length - cylinder_size))	1642	worth of sectors. This is useful when testing with
		1643	a memory-mapped "disk" (a la scsi_debug) that is say,
		1644	2048 sectors long. */
		1645	if (cylinder_size < dev->length
		1646	&& !ped_geometry_init (&start_geom, dev, cylinder_size,
		1647	dev->length - cylinder_size))
1611	return NULL;	1648	return NULL;
1612	if (!ped_geometry_init (&end_geom, dev, 0, dev->length))	1649	if (!ped_geometry_init (&end_geom, dev, 0, dev->length))
1613	return NULL;	1650	return NULL;
Lines 1739-1745 Link Here
1739	min_geom = ped_geometry_duplicate (&walk->geom);	1776	min_geom = ped_geometry_duplicate (&walk->geom);
1740	if (!min_geom)	1777	if (!min_geom)
1741	return NULL;	1778	return NULL;
1742	ped_geometry_set_start (min_geom, walk->geom.start - 1 * head_size);	1779	/* We must always allow at least two sectors at the start, to leave
		1780	* room for LILO. See linux/fs/partitions/msdos.c.
		1781	*/
		1782	ped_geometry_set_start (min_geom,
		1783	walk->geom.start - PED_MAX (1 * head_size, 2));
1743		1784
1744	for (walk = ext_part->part_list; walk; walk = walk->next) {	1785	for (walk = ext_part->part_list; walk; walk = walk->next) {
1745	if (!ped_partition_is_active (walk) \|\| walk->num == 5)	1786	if (!ped_partition_is_active (walk) \|\| walk->num == 5)

Lines 103-108 Link Here

(-)orig/libparted/labels/gpt.c (-2 / +37 lines)
103	((efi_guid_t) { PED_CPU_TO_LE32 (0xE3C9E316), PED_CPU_TO_LE16 (0x0B5C), \	103	((efi_guid_t) { PED_CPU_TO_LE32 (0xE3C9E316), PED_CPU_TO_LE16 (0x0B5C), \
104	PED_CPU_TO_LE16 (0x4DB8), 0x81, 0x7D, \	104	PED_CPU_TO_LE16 (0x4DB8), 0x81, 0x7D, \
105	{ 0xF9, 0x2D, 0xF0, 0x02, 0x15, 0xAE }})	105	{ 0xF9, 0x2D, 0xF0, 0x02, 0x15, 0xAE }})
		106	#define PARTITION_MSFT_RECOVERY \
		107	((efi_guid_t) { PED_CPU_TO_LE32 (0xDE94BBA4), PED_CPU_TO_LE16 (0x06D1), \
		108	PED_CPU_TO_LE16 (0x4D40), 0xA1, 0x6A, \
		109	{ 0xBF, 0xD5, 0x01, 0x79, 0xD6, 0xAC }})
106	#define PARTITION_BASIC_DATA_GUID \	110	#define PARTITION_BASIC_DATA_GUID \
107	((efi_guid_t) { PED_CPU_TO_LE32 (0xEBD0A0A2), PED_CPU_TO_LE16 (0xB9E5), \	111	((efi_guid_t) { PED_CPU_TO_LE32 (0xEBD0A0A2), PED_CPU_TO_LE16 (0xB9E5), \
108	PED_CPU_TO_LE16 (0x4433), 0x87, 0xC0, \	112	PED_CPU_TO_LE16 (0x4433), 0x87, 0xC0, \
Lines 269-274 Link Here
269	int hidden;	273	int hidden;
270	int msftres;	274	int msftres;
271	int atvrecv;	275	int atvrecv;
		276	int msftrecv;
272	} GPTPartitionData;	277	} GPTPartitionData;
273		278
274	static PedDiskType gpt_disk_type;	279	static PedDiskType gpt_disk_type;
Lines 773-778 Link Here
773	gpt_part_data->lvm = gpt_part_data->raid	778	gpt_part_data->lvm = gpt_part_data->raid
774	= gpt_part_data->boot = gpt_part_data->hp_service	779	= gpt_part_data->boot = gpt_part_data->hp_service
775	= gpt_part_data->hidden = gpt_part_data->msftres	780	= gpt_part_data->hidden = gpt_part_data->msftres
		781	= gpt_part_data->msftrecv
776	= gpt_part_data->bios_grub = gpt_part_data->atvrecv = 0;	782	= gpt_part_data->bios_grub = gpt_part_data->atvrecv = 0;
777		783
778	if (pte->Attributes.RequiredToFunction & 0x1)	784	if (pte->Attributes.RequiredToFunction & 0x1)
Lines 790-795 Link Here
790	gpt_part_data->hp_service = 1;	796	gpt_part_data->hp_service = 1;
791	else if (!guid_cmp (gpt_part_data->type, PARTITION_MSFT_RESERVED_GUID))	797	else if (!guid_cmp (gpt_part_data->type, PARTITION_MSFT_RESERVED_GUID))
792	gpt_part_data->msftres = 1;	798	gpt_part_data->msftres = 1;
		799	else if (!guid_cmp (gpt_part_data->type, PARTITION_MSFT_RECOVERY))
		800	gpt_part_data->msftrecv = 1;
793	else if (!guid_cmp (gpt_part_data->type, PARTITION_APPLE_TV_RECOVERY_GUID))	801	else if (!guid_cmp (gpt_part_data->type, PARTITION_APPLE_TV_RECOVERY_GUID))
794	gpt_part_data->atvrecv = 1;	802	gpt_part_data->atvrecv = 1;
795		803
Lines 1291-1296 Link Here
1291	gpt_part_data->hp_service = 0;	1299	gpt_part_data->hp_service = 0;
1292	gpt_part_data->hidden = 0;	1300	gpt_part_data->hidden = 0;
1293	gpt_part_data->msftres = 0;	1301	gpt_part_data->msftres = 0;
		1302	gpt_part_data->msftrecv = 0;
1294	gpt_part_data->atvrecv = 0;	1303	gpt_part_data->atvrecv = 0;
1295	uuid_generate ((unsigned char *) &gpt_part_data->uuid);	1304	uuid_generate ((unsigned char *) &gpt_part_data->uuid);
1296	swap_uuid_and_efi_guid ((unsigned char *) (&gpt_part_data->uuid));	1305	swap_uuid_and_efi_guid ((unsigned char *) (&gpt_part_data->uuid));
Lines 1387-1392 Link Here
1387	gpt_part_data->type = PARTITION_MSFT_RESERVED_GUID;	1396	gpt_part_data->type = PARTITION_MSFT_RESERVED_GUID;
1388	return 1;	1397	return 1;
1389	}	1398	}
		1399	if (gpt_part_data->msftrecv)
		1400	{
		1401	gpt_part_data->type = PARTITION_MSFT_RECOVERY;
		1402	return 1;
		1403	}
1390	if (gpt_part_data->atvrecv)	1404	if (gpt_part_data->atvrecv)
1391	{	1405	{
1392	gpt_part_data->type = PARTITION_APPLE_TV_RECOVERY_GUID;	1406	gpt_part_data->type = PARTITION_APPLE_TV_RECOVERY_GUID;
Lines 1491-1496 Link Here
1491	= gpt_part_data->bios_grub	1505	= gpt_part_data->bios_grub
1492	= gpt_part_data->hp_service	1506	= gpt_part_data->hp_service
1493	= gpt_part_data->msftres	1507	= gpt_part_data->msftres
		1508	= gpt_part_data->msftrecv
1494	= gpt_part_data->atvrecv = 0;	1509	= gpt_part_data->atvrecv = 0;
1495	return gpt_partition_set_system (part, part->fs_type);	1510	return gpt_partition_set_system (part, part->fs_type);
1496	case PED_PARTITION_BIOS_GRUB:	1511	case PED_PARTITION_BIOS_GRUB:
Lines 1501-1506 Link Here
1501	= gpt_part_data->boot	1516	= gpt_part_data->boot
1502	= gpt_part_data->hp_service	1517	= gpt_part_data->hp_service
1503	= gpt_part_data->msftres	1518	= gpt_part_data->msftres
		1519	= gpt_part_data->msftrecv
1504	= gpt_part_data->atvrecv = 0;	1520	= gpt_part_data->atvrecv = 0;
1505	return gpt_partition_set_system (part, part->fs_type);	1521	return gpt_partition_set_system (part, part->fs_type);
1506	case PED_PARTITION_RAID:	1522	case PED_PARTITION_RAID:
Lines 1511-1516 Link Here
1511	= gpt_part_data->bios_grub	1527	= gpt_part_data->bios_grub
1512	= gpt_part_data->hp_service	1528	= gpt_part_data->hp_service
1513	= gpt_part_data->msftres	1529	= gpt_part_data->msftres
		1530	= gpt_part_data->msftrecv
1514	= gpt_part_data->atvrecv = 0;	1531	= gpt_part_data->atvrecv = 0;
1515	return gpt_partition_set_system (part, part->fs_type);	1532	return gpt_partition_set_system (part, part->fs_type);
1516	case PED_PARTITION_LVM:	1533	case PED_PARTITION_LVM:
Lines 1521-1526 Link Here
1521	= gpt_part_data->bios_grub	1538	= gpt_part_data->bios_grub
1522	= gpt_part_data->hp_service	1539	= gpt_part_data->hp_service
1523	= gpt_part_data->msftres	1540	= gpt_part_data->msftres
		1541	= gpt_part_data->msftrecv
1524	= gpt_part_data->atvrecv = 0;	1542	= gpt_part_data->atvrecv = 0;
1525	return gpt_partition_set_system (part, part->fs_type);	1543	return gpt_partition_set_system (part, part->fs_type);
1526	case PED_PARTITION_HPSERVICE:	1544	case PED_PARTITION_HPSERVICE:
Lines 1531-1536 Link Here
1531	= gpt_part_data->lvm	1549	= gpt_part_data->lvm
1532	= gpt_part_data->bios_grub	1550	= gpt_part_data->bios_grub
1533	= gpt_part_data->msftres	1551	= gpt_part_data->msftres
		1552	= gpt_part_data->msftrecv
1534	= gpt_part_data->atvrecv = 0;	1553	= gpt_part_data->atvrecv = 0;
1535	return gpt_partition_set_system (part, part->fs_type);	1554	return gpt_partition_set_system (part, part->fs_type);
1536	case PED_PARTITION_MSFT_RESERVED:	1555	case PED_PARTITION_MSFT_RESERVED:
Lines 1541-1546 Link Here
1541	= gpt_part_data->lvm	1560	= gpt_part_data->lvm
1542	= gpt_part_data->bios_grub	1561	= gpt_part_data->bios_grub
1543	= gpt_part_data->hp_service	1562	= gpt_part_data->hp_service
		1563	= gpt_part_data->msftrecv
		1564	= gpt_part_data->atvrecv = 0;
		1565	return gpt_partition_set_system (part, part->fs_type);
		1566	case PED_PARTITION_DIAG:
		1567	gpt_part_data->msftrecv = state;
		1568	if (state)
		1569	gpt_part_data->boot
		1570	= gpt_part_data->raid
		1571	= gpt_part_data->lvm
		1572	= gpt_part_data->bios_grub
		1573	= gpt_part_data->hp_service
		1574	= gpt_part_data->msftres
1544	= gpt_part_data->atvrecv = 0;	1575	= gpt_part_data->atvrecv = 0;
1545	return gpt_partition_set_system (part, part->fs_type);	1576	return gpt_partition_set_system (part, part->fs_type);
1546	case PED_PARTITION_APPLE_TV_RECOVERY:	1577	case PED_PARTITION_APPLE_TV_RECOVERY:
Lines 1551-1557 Link Here
1551	= gpt_part_data->lvm	1582	= gpt_part_data->lvm
1552	= gpt_part_data->bios_grub	1583	= gpt_part_data->bios_grub
1553	= gpt_part_data->hp_service	1584	= gpt_part_data->hp_service
1554	= gpt_part_data->msftres = 0;	1585	= gpt_part_data->msftres
		1586	= gpt_part_data->msftrecv = 0;
1555	return gpt_partition_set_system (part, part->fs_type);	1587	return gpt_partition_set_system (part, part->fs_type);
1556	case PED_PARTITION_HIDDEN:	1588	case PED_PARTITION_HIDDEN:
1557	gpt_part_data->hidden = state;	1589	gpt_part_data->hidden = state;
Lines 1586-1592 Link Here
1586	return gpt_part_data->hp_service;	1618	return gpt_part_data->hp_service;
1587	case PED_PARTITION_MSFT_RESERVED:	1619	case PED_PARTITION_MSFT_RESERVED:
1588	return gpt_part_data->msftres;	1620	return gpt_part_data->msftres;
1589	case PED_PARTITION_APPLE_TV_RECOVERY:	1621	case PED_PARTITION_DIAG:
		1622	return gpt_part_data->msftrecv;
		1623	case PED_PARTITION_APPLE_TV_RECOVERY:
1590	return gpt_part_data->atvrecv;	1624	return gpt_part_data->atvrecv;
1591	case PED_PARTITION_HIDDEN:	1625	case PED_PARTITION_HIDDEN:
1592	return gpt_part_data->hidden;	1626	return gpt_part_data->hidden;
Lines 1611-1616 Link Here
1611	case PED_PARTITION_BIOS_GRUB:	1645	case PED_PARTITION_BIOS_GRUB:
1612	case PED_PARTITION_HPSERVICE:	1646	case PED_PARTITION_HPSERVICE:
1613	case PED_PARTITION_MSFT_RESERVED:	1647	case PED_PARTITION_MSFT_RESERVED:
		1648	case PED_PARTITION_DIAG:
1614	case PED_PARTITION_APPLE_TV_RECOVERY:	1649	case PED_PARTITION_APPLE_TV_RECOVERY:
1615	case PED_PARTITION_HIDDEN:	1650	case PED_PARTITION_HIDDEN:
1616	return 1;	1651	return 1;

Lines 127-133 Link Here

(-)orig/libparted/labels/pt-tools.c (-2 / +2 lines)
127	" of %jd"),	127	" of %jd"),
128	part->geom.length,	128	part->geom.length,
129	pt_type,	129	pt_type,
130	UINT32_MAX);	130	pt_lim->max_length);
131	return 0;	131	return 0;
132	}	132	}
133		133
Lines 140-146 Link Here
140	" of %jd"),	140	" of %jd"),
141	part->geom.start,	141	part->geom.start,
142	pt_type,	142	pt_type,
143	UINT32_MAX);	143	pt_lim->max_start_sector);
144	return 0;	144	return 0;
145	}	145	}
146		146

Lines 1396-1402 Link Here

(-)orig/parted/parted.c (-1 / +2 lines)
1396	const char *const transport[] = {"unknown", "scsi", "ide", "dac960",	1396	const char *const transport[] = {"unknown", "scsi", "ide", "dac960",
1397	"cpqarray", "file", "ataraid", "i2o",	1397	"cpqarray", "file", "ataraid", "i2o",
1398	"ubd", "dasd", "viodasd", "sx8", "dm",	1398	"ubd", "dasd", "viodasd", "sx8", "dm",
1399	"xvd", "sd/mmc", "virtblk"};	1399	"xvd", "sd/mmc", "virtblk", "aoe",
		1400	"md"};
1400	char* peek_word;	1401	char* peek_word;
1401	char* start;	1402	char* start;
1402	char* end;	1403	char* end;

Lines 1517-1522 Link Here

(-)orig/parted/ui.c (+1 lines)
1517	fputs (_("COMMANDs:"), stdout);	1517	fputs (_("COMMANDs:"), stdout);
1518	putchar ('\n');	1518	putchar ('\n');
1519	print_commands_help ();	1519	print_commands_help ();
		1520	printf (_("\nReport bugs to %s\n"), PACKAGE_BUGREPORT);
1520	exit (EXIT_SUCCESS);	1521	exit (EXIT_SUCCESS);
1521	}	1522	}
1522		1523

Return to bug 320563

Lines 19-25 Link Here

(-)orig/libparted/arch/linux.c (-52 / +310 lines)
19		19
20	#include <config.h>	20	#include <config.h>
21	#include <arch/linux.h>	21	#include <arch/linux.h>
22		22	#include <linux/blkpg.h>
23	#include <parted/parted.h>	23	#include <parted/parted.h>
24	#include <parted/debug.h>	24	#include <parted/debug.h>
25	#if defined __s390__ \|\| defined __s390x__	25	#if defined __s390__ \|\| defined __s390x__
Lines 249-259 Link Here
249	#define UBD_MAJOR 98	249	#define UBD_MAJOR 98
250	#define DASD_MAJOR 94	250	#define DASD_MAJOR 94
251	#define VIODASD_MAJOR 112	251	#define VIODASD_MAJOR 112
		252	#define AOE_MAJOR 152
252	#define SX8_MAJOR1 160	253	#define SX8_MAJOR1 160
253	#define SX8_MAJOR2 161	254	#define SX8_MAJOR2 161
254	#define XVD_MAJOR 202	255	#define XVD_MAJOR 202
255	#define SDMMC_MAJOR 179	256	#define SDMMC_MAJOR 179
256	#define LOOP_MAJOR 7	257	#define LOOP_MAJOR 7
		258	#define MD_MAJOR 9
257		259
258	#define SCSI_BLK_MAJOR(M) ( \	260	#define SCSI_BLK_MAJOR(M) ( \
259	(M) == SCSI_DISK0_MAJOR \	261	(M) == SCSI_DISK0_MAJOR \
Lines 540-545 Link Here
540	dev->type = PED_DEVICE_DAC960;	542	dev->type = PED_DEVICE_DAC960;
541	} else if (dev_major == ATARAID_MAJOR && (dev_minor % 0x10 == 0)) {	543	} else if (dev_major == ATARAID_MAJOR && (dev_minor % 0x10 == 0)) {
542	dev->type = PED_DEVICE_ATARAID;	544	dev->type = PED_DEVICE_ATARAID;
		545	} else if (dev_major == AOE_MAJOR && (dev_minor % 0x10 == 0)) {
		546	dev->type = PED_DEVICE_AOE;
543	} else if (dev_major == DASD_MAJOR && (dev_minor % 0x4 == 0)) {	547	} else if (dev_major == DASD_MAJOR && (dev_minor % 0x4 == 0)) {
544	dev->type = PED_DEVICE_DASD;	548	dev->type = PED_DEVICE_DASD;
545	} else if (dev_major == VIODASD_MAJOR && (dev_minor % 0x8 == 0)) {	549	} else if (dev_major == VIODASD_MAJOR && (dev_minor % 0x8 == 0)) {
Lines 571-576 Link Here
571	dev->type = PED_DEVICE_VIRTBLK;	575	dev->type = PED_DEVICE_VIRTBLK;
572	} else if (dev_major == LOOP_MAJOR) {	576	} else if (dev_major == LOOP_MAJOR) {
573	dev->type = PED_DEVICE_FILE;	577	dev->type = PED_DEVICE_FILE;
		578	} else if (dev_major == MD_MAJOR) {
		579	dev->type = PED_DEVICE_MD;
574	} else {	580	} else {
575	dev->type = PED_DEVICE_UNKNOWN;	581	dev->type = PED_DEVICE_UNKNOWN;
576	}	582	}
Lines 684-699 Link Here
684	dev->sector_size = PED_SECTOR_SIZE_DEFAULT;	690	dev->sector_size = PED_SECTOR_SIZE_DEFAULT;
685	}	691	}
686	#endif	692	#endif
687
688	if (dev->sector_size != PED_SECTOR_SIZE_DEFAULT) {
689	ped_exception_throw (
690	PED_EXCEPTION_WARNING,
691	PED_EXCEPTION_OK,
692	_("Device %s has a logical sector size of %lld. Not "
693	"all parts of GNU Parted support this at the moment, "
694	"and the working code is HIGHLY EXPERIMENTAL.\n"),
695	dev->path, dev->sector_size);
696	}
697	}	693	}
698		694
699	static int	695	static int
Lines 1313-1318 Link Here
1313	goto error_free_arch_specific;	1309	goto error_free_arch_specific;
1314	break;	1310	break;
1315		1311
		1312	case PED_DEVICE_AOE:
		1313	if (!init_generic (dev, _("ATA over Ethernet Device")))
		1314	goto error_free_arch_specific;
		1315	break;
		1316
1316	#if defined __s390__ \|\| defined __s390x__	1317	#if defined __s390__ \|\| defined __s390x__
1317	case PED_DEVICE_DASD:	1318	case PED_DEVICE_DASD:
1318	if (!init_dasd (dev, _("IBM S390 DASD drive")))	1319	if (!init_dasd (dev, _("IBM S390 DASD drive")))
Lines 1383-1388 Link Here
1383	goto error_free_arch_specific;	1384	goto error_free_arch_specific;
1384	break;	1385	break;
1385		1386
		1387	case PED_DEVICE_MD:
		1388	if (!init_generic(dev, _("Linux Software RAID Array")))
		1389	goto error_free_arch_specific;
		1390	break;
		1391
1386	default:	1392	default:
1387	ped_exception_throw (PED_EXCEPTION_NO_FEATURE,	1393	ped_exception_throw (PED_EXCEPTION_NO_FEATURE,
1388	PED_EXCEPTION_CANCEL,	1394	PED_EXCEPTION_CANCEL,
Lines 2299-2304 Link Here
2299	return 0;	2305	return 0;
2300	}	2306	}
2301		2307
		2308	static int
		2309	_blkpg_part_command (PedDevice* dev, struct blkpg_partition* part, int op)
		2310	{
		2311	LinuxSpecific* arch_specific = LINUX_SPECIFIC (dev);
		2312	struct blkpg_ioctl_arg ioctl_arg;
		2313
		2314	ioctl_arg.op = op;
		2315	ioctl_arg.flags = 0;
		2316	ioctl_arg.datalen = sizeof (struct blkpg_partition);
		2317	ioctl_arg.data = (void*) part;
		2318
		2319	return ioctl (arch_specific->fd, BLKPG, &ioctl_arg) == 0;
		2320	}
		2321
		2322	static int
		2323	_blkpg_add_partition (PedDisk* disk, const PedPartition *part)
		2324	{
		2325	struct blkpg_partition linux_part;
		2326	const char* vol_name;
		2327	char* dev_name;
		2328
		2329	PED_ASSERT(disk != NULL, return 0);
		2330	PED_ASSERT(disk->dev->sector_size % PED_SECTOR_SIZE_DEFAULT == 0,
		2331	return 0);
		2332
		2333	if (!_has_partitions (disk))
		2334	return 0;
		2335
		2336	if (ped_disk_type_check_feature (disk->type,
		2337	PED_DISK_TYPE_PARTITION_NAME))
		2338	vol_name = ped_partition_get_name (part);
		2339	else
		2340	vol_name = NULL;
		2341
		2342	dev_name = _device_get_part_path (disk->dev, part->num);
		2343	if (!dev_name)
		2344	return 0;
		2345
		2346	memset (&linux_part, 0, sizeof (linux_part));
		2347	linux_part.start = part->geom.start * disk->dev->sector_size;
		2348	/* see fs/partitions/msdos.c:msdos_partition(): "leave room for LILO" */
		2349	if (part->type & PED_PARTITION_EXTENDED)
		2350	linux_part.length = part->geom.length == 1 ? 512 : 1024;
		2351	else
		2352	linux_part.length = part->geom.length * disk->dev->sector_size;
		2353	linux_part.pno = part->num;
		2354	strncpy (linux_part.devname, dev_name, BLKPG_DEVNAMELTH);
		2355	if (vol_name)
		2356	strncpy (linux_part.volname, vol_name, BLKPG_VOLNAMELTH);
		2357
		2358	free (dev_name);
		2359
		2360	if (!_blkpg_part_command (disk->dev, &linux_part,
		2361	BLKPG_ADD_PARTITION)) {
		2362	return ped_exception_throw (
		2363	PED_EXCEPTION_ERROR,
		2364	PED_EXCEPTION_IGNORE_CANCEL,
		2365	_("Error informing the kernel about modifications to "
		2366	"partition %s -- %s. This means Linux won't know "
		2367	"about any changes you made to %s until you reboot "
		2368	"-- so you shouldn't mount it or use it in any way "
		2369	"before rebooting."),
		2370	linux_part.devname,
		2371	strerror (errno),
2372	linux_part.devname)
2373	== PED_EXCEPTION_IGNORE;
2374	}
2375
2376	return 1;
2377	}
2378
2379	static int
2380	_blkpg_remove_partition (PedDisk* disk, int n)
2381	{
2382	struct blkpg_partition linux_part;
2383
2384	if (!_has_partitions (disk))
2385	return 0;
2386
2387	memset (&linux_part, 0, sizeof (linux_part));
2388	linux_part.pno = n;
2389	return _blkpg_part_command (disk->dev, &linux_part,
2390	BLKPG_DEL_PARTITION);
2391	}
2392
2393	/*
2394	* The number of partitions that a device can have depends on the kernel.
2395	* If we don't find this value in /sys/block/DEV/range, we will use our own
2396	* value.
2397	*/
2398	static unsigned int
2399	_device_get_partition_range(PedDevice* dev)
2400	{
2401	int range, r;
2402	char path[128];
2403	FILE* fp;
2404	bool ok;
2405
2406	r = snprintf(path, sizeof(path), "/sys/block/%s/range",
2407	last_component(dev->path));
2408	if (r < 0 \|\| r >= sizeof(path))
2409	return MAX_NUM_PARTS;
2410
2411	fp = fopen(path, "r");
2412	if (!fp)
2413	return MAX_NUM_PARTS;
2414
2415	ok = fscanf(fp, "%d", &range) == 1;
2416	fclose(fp);
2417
2418	/* (range <= 0) is none sense.*/
2419	return ok && range > 0 ? range : MAX_NUM_PARTS;
2420	}
2421
2422	/*
2423	* Sync the partition table in two step process:
2424	* 1. Remove all of the partitions from the kernel's tables, but do not attempt
2425	* removal of any partition for which the corresponding ioctl call fails.
2426	* 2. Add all the partitions that we hold in disk, throwing a warning
2427	* if we cannot because step 1 failed to remove it and it is not being
2428	* added back with the same start and length.
2429	*
2430	* To achieve this two step process we must calculate the minimum number of
2431	* maximum possible partitions between what linux supports and what the label
2432	* type supports. EX:
2433	*
2434	* number=MIN(max_parts_supported_in_linux,max_parts_supported_in_msdos_tables)
2435	*/
2436	static int
2437	_disk_sync_part_table (PedDisk* disk)
2438	{
2439	PED_ASSERT(disk != NULL, return 0);
2440	PED_ASSERT(disk->dev != NULL, return 0);
2441	int lpn;
2442
2443	/* lpn = largest partition number. */
2444	if (ped_disk_get_max_supported_partition_count(disk, &lpn))
2445	lpn = PED_MIN(lpn, _device_get_partition_range(disk->dev));
2446	else
2447	lpn = _device_get_partition_range(disk->dev);
2448
2449	/* Its not possible to support largest_partnum < 0.
2450	* largest_partnum == 0 would mean does not support partitions.
2451	* */
2452	if (lpn < 0)
2453	return 0;
2454	int ret = 0;
2455	int ok = calloc (lpn, sizeof ok);
2456	if (!ok)
2457	return 0;
2458	int errnums = ped_malloc(sizeof(int) lpn);
2459	if (!errnums)
2460	goto cleanup;
2461
2462	/* Attempt to remove each and every partition, retrying for
2463	up to max_sleep_seconds upon any failure due to EBUSY. */
2464	unsigned int sleep_microseconds = 10000;
2465	unsigned int max_sleep_seconds = 1;
2466	unsigned int n_sleep = (max_sleep_seconds
2467	* 1000000 / sleep_microseconds);
2468	int i;
2469	for (i = 0; i < n_sleep; i++) {
2470	if (i)
2471	usleep (sleep_microseconds);
2472	bool busy = false;
2473	int j;
2474	for (j = 0; j < lpn; j++) {
2475	if (!ok[j]) {
2476	ok[j] = _blkpg_remove_partition (disk, j + 1);
2477	errnums[j] = errno;
2478	if (!ok[j] && errnums[j] == EBUSY)
2479	busy = true;
2480	}
2481	}
2482	if (!busy)
2483	break;
2484	}
2485
2486	for (i = 1; i <= lpn; i++) {
2487	const PedPartition *part = ped_disk_get_partition (disk, i);
2488	if (part) {
2489	if (!ok[i - 1] && errnums[i - 1] == EBUSY) {
2490	struct hd_geometry geom;
2491	unsigned long long length = 0;
2492	/* get start and length of existing partition */
2493	char *dev_name = _device_get_part_path (disk->dev, i);
2494	if (!dev_name)
2495	goto cleanup;
2496	int fd = open (dev_name, O_RDONLY);
2497	if (fd == -1
2498	\|\| ioctl (fd, HDIO_GETGEO, &geom)
2499	\|\| ioctl (fd, BLKGETSIZE64, &length)) {
2500	ped_exception_throw (
2501	PED_EXCEPTION_BUG,
2502	PED_EXCEPTION_CANCEL,
2503	_("Unable to determine the size and length of %s."),
2504	dev_name);
2505	if (fd != -1)
2506	close (fd);
2507	free (dev_name);
2508	goto cleanup;
2509	}
2510	free (dev_name);
2511	length /= disk->dev->sector_size;
2512	close (fd);
2513	if (geom.start == part->geom.start
2514	&& length == part->geom.length)
2515	ok[i - 1] = 1;
2516	/* If the new partition is unchanged and the
2517	existing one was not removed because it was
2518	in use, then reset the error flag and do not
2519	try to add it since it is already there. */
2520	continue;
2521	}
2522
2523	/* add the (possibly modified or new) partition */
2524	if (!_blkpg_add_partition (disk, part)) {
2525	ped_exception_throw (
2526	PED_EXCEPTION_ERROR,
2527	PED_EXCEPTION_RETRY_CANCEL,
2528	_("Failed to add partition %d (%s)"),
2529	i, strerror (errno));
2530	goto cleanup;
2531	}
2532	}
2533	}
2534
2535	char *bad_part_list = NULL;
2536	/* now warn about any errors */
2537	for (i = 1; i <= lpn; i++) {
2538	if (ok[i - 1] \|\| errnums[i - 1] == ENXIO)
2539	continue;
2540	if (bad_part_list == NULL) {
2541	bad_part_list = malloc (lpn * 5);
2542	if (!bad_part_list)
2543	goto cleanup;
2544	bad_part_list[0] = 0;
2545	}
2546	sprintf (bad_part_list + strlen (bad_part_list), "%d, ", i);
2547	}
2548	if (bad_part_list == NULL)
2549	ret = 1;
2550	else {
2551	bad_part_list[strlen (bad_part_list) - 2] = 0;
2552	if (ped_exception_throw (
2553	PED_EXCEPTION_ERROR,
2554	PED_EXCEPTION_IGNORE_CANCEL,
2555	_("Partition(s) %s on %s have been written, but we have "
2556	"been unable to inform the kernel of the change, "
2557	"probably because it/they are in use. As a result, "
2558	"the old partition(s) will remain in use. You "
2559	"should reboot now before making further changes."),
2560	bad_part_list, disk->dev->path) == PED_EXCEPTION_IGNORE)
2561	ret = 1;
2562	free (bad_part_list);
2563	}
2564	cleanup:
2565	free (errnums);
2566	free (ok);
2567	return ret;
2568	}
2569
2302	#ifdef ENABLE_DEVICE_MAPPER	2570	#ifdef ENABLE_DEVICE_MAPPER
2303	static int	2571	static int
2304	_dm_remove_map_name(char *name)	2572	_dm_remove_map_name(char *name)
Lines 2315-2321 Link Here
2315	rc = dm_task_run(task);	2583	rc = dm_task_run(task);
2316	dm_task_update_nodes();	2584	dm_task_update_nodes();
2317	dm_task_destroy(task);	2585	dm_task_destroy(task);
2318	if (rc < 0)	2586	if (!rc)
2319	return 1;	2587	return 1;
2320		2588
2321	return 0;	2589	return 0;
Lines 2335-2346 Link Here
2335	return 0;	2603	return 0;
2336		2604
2337	dm_task_set_name(task, name);	2605	dm_task_set_name(task, name);
2338	rc = dm_task_run(task);	2606	if (!dm_task_run(task))
2339	if (rc < 0) {
2340	rc = 0;
2341	goto err;	2607	goto err;
2342	}
2343	rc = 0;
2344		2608
2345	memset(info, '\0', sizeof *info);	2609	memset(info, '\0', sizeof *info);
2346	dm_task_get_info(task, info);	2610	dm_task_get_info(task, info);
Lines 2351-2357 Link Here
2351	if (!deps)	2615	if (!deps)
2352	goto err;	2616	goto err;
2353		2617
2354	rc = 0;
2355	for (i = 0; i < deps->count; i++) {	2618	for (i = 0; i < deps->count; i++) {
2356	unsigned int ma = major(deps->device[i]),	2619	unsigned int ma = major(deps->device[i]),
2357	mi = minor(deps->device[i]);	2620	mi = minor(deps->device[i]);
Lines 2383-2390 Link Here
2383	arch_specific->minor, 0))	2646	arch_specific->minor, 0))
2384	goto err;	2647	goto err;
2385		2648
2386	rc = dm_task_run(task);	2649	if (!dm_task_run(task))
2387	if (rc < 0)
2388	goto err;	2650	goto err;
2389		2651
2390	memset(info, '\0', sizeof *info);	2652	memset(info, '\0', sizeof *info);
Lines 2426-2432 Link Here
2426	static int	2688	static int
2427	_dm_add_partition (PedDisk* disk, PedPartition* part)	2689	_dm_add_partition (PedDisk* disk, PedPartition* part)
2428	{	2690	{
2429	int rc;
2430	char* vol_name = NULL;	2691	char* vol_name = NULL;
2431	const char* dev_name = NULL;	2692	const char* dev_name = NULL;
2432	char* params = NULL;	2693	char* params = NULL;
Lines 2444-2451 Link Here
2444	arch_specific->minor, 0))	2705	arch_specific->minor, 0))
2445	goto err;	2706	goto err;
2446		2707
2447	rc = dm_task_run(task);	2708	if (!dm_task_run(task))
2448	if (rc < 0)
2449	goto err;	2709	goto err;
2450		2710
2451	dev_name = dm_task_get_name (task);	2711	dev_name = dm_task_get_name (task);
Lines 2468-2475 Link Here
2468	dm_task_set_name (task, vol_name);	2728	dm_task_set_name (task, vol_name);
2469	dm_task_add_target (task, 0, part->geom.length,	2729	dm_task_add_target (task, 0, part->geom.length,
2470	"linear", params);	2730	"linear", params);
2471	rc = dm_task_run (task);	2731	if (dm_task_run (task)) {
2472	if (rc >= 0) {
2473	//printf("0 %ld linear %s\n", part->geom.length, params);	2732	//printf("0 %ld linear %s\n", part->geom.length, params);
2474	dm_task_update_nodes();	2733	dm_task_update_nodes();
2475	dm_task_destroy(task);	2734	dm_task_destroy(task);
Lines 2518-2569 Link Here
2518	#endif	2777	#endif
2519		2778
2520	static int	2779	static int
2521	_kernel_reread_part_table (PedDevice* dev)	2780	_have_blkpg ()
2522	{	2781	{
2523	LinuxSpecific* arch_specific = LINUX_SPECIFIC (dev);	2782	static int have_blkpg = -1;
2524	int retry_count = 9;	2783	int kver;
2525
2526	sync();
2527	while (ioctl (arch_specific->fd, BLKRRPART)) {
2528	retry_count--;
2529	sync();
2530	if (retry_count == 3)
2531	sleep(1); /* Pause to allow system to settle */
2532		2784
2533	if (!retry_count) {	2785	if (have_blkpg != -1)
2534	ped_exception_throw (	2786	return have_blkpg;
2535	PED_EXCEPTION_WARNING,
2536	PED_EXCEPTION_IGNORE,
2537	_("WARNING: the kernel failed to re-read the partition "
2538	"table on %s (%s). As a result, it may not "
2539	"reflect all of your changes until after reboot."),
2540	dev->path, strerror (errno));
2541	return 0;
2542	}
2543	}
2544		2787
2545	return 1;	2788	kver = _get_linux_version();
		2789	return have_blkpg = kver >= KERNEL_VERSION (2,4,0) ? 1 : 0;
2546	}	2790	}
2547		2791
		2792	/* Return nonzero upon success, 0 if something fails. */
2548	static int	2793	static int
2549	linux_disk_commit (PedDisk* disk)	2794	linux_disk_commit (PedDisk* disk)
2550	{	2795	{
2551	if (!_has_partitions (disk))	2796	if (!_has_partitions (disk))
2552	return 1;	2797	return 1;
2553		2798
2554	#ifdef ENABLE_DEVICE_MAPPER	2799	#ifdef ENABLE_DEVICE_MAPPER
2555	if (disk->dev->type == PED_DEVICE_DM)	2800	if (disk->dev->type == PED_DEVICE_DM)
2556	return _dm_reread_part_table (disk);	2801	return _dm_reread_part_table (disk);
2557	#endif	2802	#endif
2558	if (disk->dev->type != PED_DEVICE_FILE) {	2803	if (disk->dev->type != PED_DEVICE_FILE) {
2559	return _kernel_reread_part_table (disk->dev);	2804	/* The ioctl() command BLKPG_ADD_PARTITION does not notify
		2805	* the devfs system; consequently, /proc/partitions will not
		2806	* be up to date, and the proper links in /dev are not
		2807	* created. Therefore, if using DevFS, we must get the kernel
		2808	* to re-read and grok the partition table.
		2809	*/
		2810	/* Work around kernel dasd problem so we really do BLKRRPART */
		2811	int ok = 1;
		2812	if (disk->dev->type != PED_DEVICE_DASD && _have_blkpg ()) {
		2813	if (!_disk_sync_part_table (disk))
		2814	ok = 0;
		2815	}
		2816
		2817	return ok;
2560	}	2818	}
2561		2819
2562	return 1;	2820	return 1;
2563	}	2821	}
2564		2822
2565	#if USE_BLKID	2823	#if USE_BLKID
2566	PedAlignment*	2824	static PedAlignment*
2567	linux_get_minimum_alignment(const PedDevice *dev)	2825	linux_get_minimum_alignment(const PedDevice *dev)
2568	{	2826	{
2569	blkid_topology tp = LINUX_SPECIFIC(dev)->topology;	2827	blkid_topology tp = LINUX_SPECIFIC(dev)->topology;
Lines 2581-2587 Link Here
2581	blkid_topology_get_minimum_io_size(tp) / dev->sector_size);	2839	blkid_topology_get_minimum_io_size(tp) / dev->sector_size);
2582	}	2840	}
2583		2841
2584	PedAlignment*	2842	static PedAlignment*
2585	linux_get_optimum_alignment(const PedDevice *dev)	2843	linux_get_optimum_alignment(const PedDevice *dev)
2586	{	2844	{
2587	blkid_topology tp = LINUX_SPECIFIC(dev)->topology;	2845	blkid_topology tp = LINUX_SPECIFIC(dev)->topology;

Lines 57-68 Link Here

(-)orig/libparted/fs/ext2/ext2_fs.h (+2 lines)
57	#define EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER 0x0001	57	#define EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER 0x0001
58	#define EXT2_FEATURE_RO_COMPAT_LARGE_FILE 0x0002	58	#define EXT2_FEATURE_RO_COMPAT_LARGE_FILE 0x0002
59	#define EXT4_FEATURE_RO_COMPAT_HUGE_FILE 0x0008	59	#define EXT4_FEATURE_RO_COMPAT_HUGE_FILE 0x0008
		60	#define EXT4_FEATURE_RO_COMPAT_GDT_CSUM 0x0010
60	#define EXT4_FEATURE_RO_COMPAT_DIR_NLINK 0x0020	61	#define EXT4_FEATURE_RO_COMPAT_DIR_NLINK 0x0020
61		62
62	#define EXT2_FEATURE_INCOMPAT_FILETYPE 0x0002	63	#define EXT2_FEATURE_INCOMPAT_FILETYPE 0x0002
63	#define EXT3_FEATURE_INCOMPAT_RECOVER 0x0004	64	#define EXT3_FEATURE_INCOMPAT_RECOVER 0x0004
64	#define EXT4_FEATURE_INCOMPAT_EXTENTS 0x0040	65	#define EXT4_FEATURE_INCOMPAT_EXTENTS 0x0040
65	#define EXT4_FEATURE_INCOMPAT_64BIT 0x0080	66	#define EXT4_FEATURE_INCOMPAT_64BIT 0x0080
		67	#define EXT4_FEATURE_INCOMPAT_FLEX_BG 0x0200
66		68
67	/*	69	/*
68	* Special inodes numbers	70	* Special inodes numbers