Add ped_device_get_minimum_alignment() and ped_device_get_optimum_alignment() functions to libparted.
Note this is a resent of my previous patchset with a number of typos corrected: aligment -> alignment minimal_alignment -> minimum_aligment optimal_alignment -> optimum_aligment
Sorry for the noise. --- include/parted/device.h | 8 ++++++++ include/parted/natmath.h | 1 + libparted/device.c | 43 +++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 52 insertions(+), 0 deletions(-)
diff --git a/include/parted/device.h b/include/parted/device.h index 151305f..5095b18 100644 --- a/include/parted/device.h +++ b/include/parted/device.h @@ -92,6 +92,8 @@ struct _PedDevice { void* arch_specific; };
+#include <parted/natmath.h> + /** * List of functions implementing architecture-specific operations. */ @@ -112,6 +114,9 @@ struct _PedDeviceArchOps { PedSector (*check) (PedDevice* dev, void* buffer, PedSector start, PedSector count); void (*probe_all) (); + /* These functions are optional */ + PedAlignment *(*get_minimum_alignment)(const PedDevice *dev); + PedAlignment *(*get_optimum_alignment)(const PedDevice *dev); };
#include <parted/constraint.h> @@ -141,6 +146,9 @@ extern PedSector ped_device_check (PedDevice* dev, void* buffer, PedSector start, PedSector count); extern PedConstraint* ped_device_get_constraint (PedDevice* dev);
+extern PedAlignment *ped_device_get_minimum_alignment(const PedDevice *dev); +extern PedAlignment *ped_device_get_optimum_alignment(const PedDevice *dev); + /* private stuff ;-) */
extern void _ped_device_probe (const char* path); diff --git a/include/parted/natmath.h b/include/parted/natmath.h index cd7679d..eaa84d1 100644 --- a/include/parted/natmath.h +++ b/include/parted/natmath.h @@ -31,6 +31,7 @@ typedef struct _PedAlignment PedAlignment;
#include <parted/disk.h> #include <parted/device.h> +#include <parted/geom.h>
#define PED_MIN(a, b) ( ((a)<(b)) ? (a) : (b) ) #define PED_MAX(a, b) ( ((a)>(b)) ? (a) : (b) ) diff --git a/libparted/device.c b/libparted/device.c index 294fec4..4fec1a9 100644 --- a/libparted/device.c +++ b/libparted/device.c @@ -444,5 +444,48 @@ ped_device_get_constraint (PedDevice* dev) return c; }
+/** + * Get an alignment that represents minimum hardware requirements on alignment. + * When for example using media that has a physical sector size that is a + * multiple of the logical sector size, it is desirable to have disk accesses + * (and thus partitions) properly aligned. Having partitions not aligned to + * the minimum hardware requirements may lead to a performance penalty. + * + * The returned alignment describes the alignment for the start sector of the + * partition, the end sector should be aligned too, to get the end sector + * alignment decrease the returned alignment's offset by 1. + * + * \return the minimum alignment of partition start sectors, or NULL if this + * information is not available. + */ +PedAlignment* +ped_device_get_minimum_alignment(const PedDevice *dev) +{ + if (ped_architecture->dev_ops->get_minimum_alignment) + return ped_architecture->dev_ops->get_minimum_alignment(dev); + + return NULL; /* ped_alignment_none */ +} + +/** + * Get an alignment that represents the hardware requirements for optimal + * performance. + * + * The returned alignment describes the alignment for the start sector of the + * partition, the end sector should be aligned too, to get the end sector + * alignment decrease the returned alignment's offset by 1. + * + * \return the optimal alignment of partition start sectors, or NULL if this + * information is not available. + */ +PedAlignment* +ped_device_get_optimum_alignment(const PedDevice *dev) +{ + if (ped_architecture->dev_ops->get_optimum_alignment) + return ped_architecture->dev_ops->get_optimum_alignment(dev); + + return NULL; /* ped_alignment_none */ +} + /** @} */
This is a preparation patch for adding get_minimum_alignment and get_optimum_alignment functions to linux's _PedDeviceArchOps. * libparted/arch/linux.h (struct_LinuxSpecific) [probe, topology]: Add members. * libparted/arch/linux.c (linux_new): initialize arch_specific->probe and arch_specific->topology to NULL, (linux_destroy): Free arch_specific->probe. (get_minimum_io_size): Remove function. (get_blkid_topology): New function. (_device_set_sector_size): Call get_blkid_topology() instead of get_minimum_io_size() and retrieve minimum io size from the cached topology. --- libparted/arch/linux.c | 79 +++++++++++++++++++----------------------------- libparted/arch/linux.h | 8 +++++ 2 files changed, 39 insertions(+), 48 deletions(-)
diff --git a/libparted/arch/linux.c b/libparted/arch/linux.c index d084b93..a03c80d 100644 --- a/libparted/arch/linux.c +++ b/libparted/arch/linux.c @@ -52,10 +52,6 @@ # define _(String) (String) #endif /* ENABLE_NLS */
-#if HAVE_BLKID_BLKID_H -# include <blkid/blkid.h> -#endif - #define KERNEL_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))
#ifndef __NR__llseek @@ -598,47 +594,22 @@ _have_kern26 () return have_kern26 = kver >= KERNEL_VERSION (2,6,0) ? 1 : 0; }
-/* Use libblkid to determine the kernel's idea of the - minimum_io_size for the device on which FD is open. - Upon success, store that value in *SZ and return 0. - Otherwise, don't modify *SZ, set errno and return -1. */ -static int -get_minimum_io_size (int fd, unsigned long *sz) -{ - int ret = -1; - #if USE_BLKID - blkid_probe pr = blkid_new_probe (); - if (!pr) - goto free_and_return; - - int saved_errno; - if (blkid_probe_set_device (pr, fd, 0, 0)) { - saved_errno = errno; - blkid_free_probe (pr); - goto free_and_return; - } - - blkid_topology tp = blkid_probe_get_topology (pr); - if (!tp) { - saved_errno = errno; - goto free_and_return; - } - - *sz = blkid_topology_get_minimum_io_size (tp); - ret = 0; - -free_and_return: +static void +get_blkid_topology (LinuxSpecific *arch_specific) +{ + arch_specific->probe = blkid_new_probe (); + if (!arch_specific->probe) + return;
- blkid_free_probe (pr); - if (ret) - errno = saved_errno; -#else - errno = ENOSYS; -#endif + if (blkid_probe_set_device(arch_specific->probe, + arch_specific->fd, 0, 0)) + return;
- return ret; + arch_specific->topology = + blkid_probe_get_topology(arch_specific->probe); } +#endif
static void _device_set_sector_size (PedDevice* dev) @@ -667,19 +638,21 @@ _device_set_sector_size (PedDevice* dev) dev->sector_size = (long long)sector_size; }
- unsigned long min_io_size; - int err = get_minimum_io_size (arch_specific->fd, &min_io_size); - - if (err) { +#if USE_BLKID + get_blkid_topology(arch_specific); + if (!arch_specific->topology) { ped_exception_throw ( PED_EXCEPTION_WARNING, PED_EXCEPTION_OK, _("Could not determine minimum io size for %s: %s.\n" "Using the default size (%lld)."), dev->path, strerror (errno), PED_SECTOR_SIZE_DEFAULT); - min_io_size = PED_SECTOR_SIZE_DEFAULT; + } else { + dev->phys_sector_size = + blkid_topology_get_minimum_io_size( + arch_specific->topology); } - dev->phys_sector_size = min_io_size; +#endif
/* Return PED_SECTOR_SIZE_DEFAULT for DASDs. */ if (dev->type == PED_DEVICE_DASD) { @@ -1274,6 +1247,10 @@ linux_new (const char* path) goto error_free_path; arch_specific = LINUX_SPECIFIC (dev); arch_specific->dmtype = NULL; +#if USE_BLKID + arch_specific->probe = NULL; + arch_specific->topology = NULL; +#endif
dev->open_count = 0; dev->read_only = 0; @@ -1394,7 +1371,13 @@ error: static void linux_destroy (PedDevice* dev) { - void *p = ((LinuxSpecific*)dev->arch_specific)->dmtype; + LinuxSpecific *arch_specific = LINUX_SPECIFIC(dev); + void *p = arch_specific->dmtype; + +#if USE_BLKID + if (arch_specific->probe) + blkid_free_probe(arch_specific->probe); +#endif free (p); free (dev->arch_specific); free (dev->path); diff --git a/libparted/arch/linux.h b/libparted/arch/linux.h index 9c08f40..b3693e9 100644 --- a/libparted/arch/linux.h +++ b/libparted/arch/linux.h @@ -22,6 +22,10 @@ # include <parted/fdasd.h> #endif
+#if HAVE_BLKID_BLKID_H +# include <blkid/blkid.h> +#endif + #define LINUX_SPECIFIC(dev) ((LinuxSpecific*) (dev)->arch_specific)
typedef struct _LinuxSpecific LinuxSpecific; @@ -36,6 +40,10 @@ struct _LinuxSpecific { /* IBM internal dasd structure (i guess ;), required. */ struct fdasd_anchor *anchor; #endif +#if USE_BLKID + blkid_probe probe; + blkid_topology topology; +#endif };
#endif /* PED_ARCH_LINUX_H_INCLUDED */
* libparted/arch/linux.c (get_minimum_alignment): New function. (get_optimum_alignment): New function. --- libparted/arch/linux.c | 34 +++++++++++++++++++++++++++++++++- 1 files changed, 33 insertions(+), 1 deletions(-)
diff --git a/libparted/arch/linux.c b/libparted/arch/linux.c index a03c80d..a87f7e2 100644 --- a/libparted/arch/linux.c +++ b/libparted/arch/linux.c @@ -2523,6 +2523,34 @@ linux_disk_commit (PedDisk* disk) return 1; }
+#if USE_BLKID +PedAlignment* +linux_get_minimum_alignment(const PedDevice *dev) +{ + blkid_topology tp = LINUX_SPECIFIC(dev)->topology; + + if (!tp || blkid_topology_get_minimum_io_size(tp) == 0) + return NULL; /* ped_alignment_none */ + + return ped_alignment_new( + blkid_topology_get_alignment_offset(tp) / dev->sector_size, + blkid_topology_get_minimum_io_size(tp) / dev->sector_size); +} + +PedAlignment* +linux_get_optimum_alignment(const PedDevice *dev) +{ + blkid_topology tp = LINUX_SPECIFIC(dev)->topology; + + if (!tp || blkid_topology_get_optimal_io_size(tp) == 0) + return NULL; /* ped_alignment_none */ + + return ped_alignment_new( + blkid_topology_get_alignment_offset(tp) / dev->sector_size, + blkid_topology_get_optimal_io_size(tp) / dev->sector_size); +} +#endif + static PedDeviceArchOps linux_dev_ops = { _new: linux_new, destroy: linux_destroy, @@ -2536,7 +2564,11 @@ static PedDeviceArchOps linux_dev_ops = { check: linux_check, sync: linux_sync, sync_fast: linux_sync_fast, - probe_all: linux_probe_all + probe_all: linux_probe_all, +#if USE_BLKID + get_minimum_alignment: linux_get_minimum_alignment, + get_optimum_alignment: linux_get_optimum_alignment, +#endif };
PedDiskArchOps linux_disk_ops = {
In libparted-1.9 ped_device_get_constraint() would always return a constraint without any start / end aligning (grain_size == 1). Now that we are starting to support disks with a physical sector size other then 512, the old ped_device_get_constraint() code may actually start returning constrains with alignment info with a grain_size != 1.
Since this is a behavior change and since the old code does not take a possible alignment info into account, this patch removes the aligning code from ped_device_get_constraint(), so that its behavior is unchanged.
This patch also updates the functions doxygen documentation to reflect what it has actually done all these years. --- libparted/device.c | 25 +++++++++++++------------ 1 files changed, 13 insertions(+), 12 deletions(-)
diff --git a/libparted/device.c b/libparted/device.c index 4fec1a9..483011a 100644 --- a/libparted/device.c +++ b/libparted/device.c @@ -416,31 +416,32 @@ ped_device_sync_fast (PedDevice* dev) }
/** - * Get a constraint that represents hardware requirements on alignment and - * geometry. - * This is, for example, important for media that have a physical sector - * size that is a multiple of the logical sector size. + * Get a constraint that represents hardware requirements on geometry. + * This function will return a constraint representing the limits imposed + * by the size of the disk, it will *not* provide any alignment constraints. * - * \warning This function is experimental for physical sector sizes not equal to - * 2^9. + * Alignment constraints may be desirable when using media that have a physical + * sector size that is a multiple of the logical sector size, as in this case + * proper partition alignment can benefit disk performance signigicantly. + * When you want a constraint with alignment info, use + * ped_device_get_minimal_aligned_constraint() or + * ped_device_get_optimal_aligned_constraint(). + * + * \return NULL on error, otherwise a pointer to a dynamically allocated + * constraint. */ PedConstraint* ped_device_get_constraint (PedDevice* dev) { - int multiplier = dev->phys_sector_size / dev->sector_size; - - PedAlignment* start_align = ped_alignment_new (multiplier, multiplier); - PedGeometry *s, *e; PedConstraint* c = ped_constraint_new ( - start_align, ped_alignment_any, + ped_alignment_any, ped_alignment_any, s = ped_geometry_new (dev, 0, dev->length), e = ped_geometry_new (dev, 0, dev->length), 1, dev->length);
free (s); free (e); - free (start_align); return c; }
Add ped_device_get_minimal_aligned_constraint() and ped_device_get_optimal_aligned_constraint() functions to libparted.
These functions can be used to get a device constraint taking alignment into account. --- include/parted/device.h | 5 +++ libparted/device.c | 69 +++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 74 insertions(+), 0 deletions(-)
diff --git a/include/parted/device.h b/include/parted/device.h index 5095b18..3580c2a 100644 --- a/include/parted/device.h +++ b/include/parted/device.h @@ -146,6 +146,11 @@ extern PedSector ped_device_check (PedDevice* dev, void* buffer, PedSector start, PedSector count); extern PedConstraint* ped_device_get_constraint (PedDevice* dev);
+extern PedConstraint *ped_device_get_minimal_aligned_constraint( + const PedDevice *dev); +extern PedConstraint *ped_device_get_optimal_aligned_constraint( + const PedDevice *dev); + extern PedAlignment *ped_device_get_minimum_alignment(const PedDevice *dev); extern PedAlignment *ped_device_get_optimum_alignment(const PedDevice *dev);
diff --git a/libparted/device.c b/libparted/device.c index 483011a..cd10a91 100644 --- a/libparted/device.c +++ b/libparted/device.c @@ -445,6 +445,75 @@ ped_device_get_constraint (PedDevice* dev) return c; }
+static PedConstraint* +_ped_device_get_aligned_constraint(const PedDevice *dev, + PedAlignment* start_align) +{ + PedAlignment *end_align = NULL; + PedGeometry *whole_dev_geom = NULL; + PedConstraint *c = NULL; + + if (start_align) { + end_align = ped_alignment_new(start_align->offset - 1, + start_align->grain_size); + if (!end_align) + goto free_start_align; + } + + whole_dev_geom = ped_geometry_new (dev, 0, dev->length); + + if (start_align) + c = ped_constraint_new (start_align, end_align, + whole_dev_geom, whole_dev_geom, + 1, dev->length); + else + c = ped_constraint_new (ped_alignment_any, ped_alignment_any, + whole_dev_geom, whole_dev_geom, + 1, dev->length); + + free (whole_dev_geom); + free (end_align); +free_start_align: + free (start_align); + return c; +} + +/** + * Get a constraint that represents hardware requirements on geometry and + * alignment. + * + * This function will return a constraint representing the limits imposed + * by the size of the disk and the minimal alignment requirements for proper + * performance of the disk. + * + * \return NULL on error, otherwise a pointer to a dynamically allocated + * constraint. + */ +PedConstraint* +ped_device_get_minimal_aligned_constraint(const PedDevice *dev) +{ + return _ped_device_get_aligned_constraint(dev, + ped_device_get_minimum_alignment(dev)); +} + +/** + * Get a constraint that represents hardware requirements on geometry and + * alignment. + * + * This function will return a constraint representing the limits imposed + * by the size of the disk and the alignment requirements for optimal + * performance of the disk. + * + * \return NULL on error, otherwise a pointer to a dynamically allocated + * constraint. + */ +PedConstraint* +ped_device_get_optimal_aligned_constraint(const PedDevice *dev) +{ + return _ped_device_get_aligned_constraint(dev, + ped_device_get_optimum_alignment(dev)); +} + /** * Get an alignment that represents minimum hardware requirements on alignment. * When for example using media that has a physical sector size that is a
This functions get the alignment needed for partition boundaries on this disk. The returned alignment describes the alignment for the start sector of the partition, for all disklabel types which require alignment, except Sun disklabels, the end sector must be aligned too. To get the end sector alignment decrease the PedAlignment offset by 1. --- include/parted/disk.h | 2 ++ libparted/disk.c | 20 ++++++++++++++++++++ 2 files changed, 22 insertions(+), 0 deletions(-)
diff --git a/include/parted/disk.h b/include/parted/disk.h index 46b5f28..76397a8 100644 --- a/include/parted/disk.h +++ b/include/parted/disk.h @@ -214,6 +214,7 @@ struct _PedDiskOps { int (*get_max_primary_partition_count) (const PedDisk* disk); bool (*get_max_supported_partition_count) (const PedDisk* disk, int* supported); + PedAlignment *(*get_partition_alignment)(const PedDisk *disk); };
struct _PedDiskType { @@ -263,6 +264,7 @@ extern int ped_disk_get_last_partition_num (const PedDisk* disk); extern int ped_disk_get_max_primary_partition_count (const PedDisk* disk); extern bool ped_disk_get_max_supported_partition_count(const PedDisk* disk, int* supported); +extern PedAlignment *ped_disk_get_partition_alignment(const PedDisk *disk);
/** @} */
diff --git a/libparted/disk.c b/libparted/disk.c index f3074a3..60efc54 100644 --- a/libparted/disk.c +++ b/libparted/disk.c @@ -686,6 +686,26 @@ ped_disk_get_max_supported_partition_count(const PedDisk* disk, int* supported) }
/** + * Get the alignment needed for partition boundaries on this disk. + * The returned alignment describes the alignment for the start sector of the + * partition, for all disklabel types which require alignment, except Sun + * disklabels, the end sector must be aligned too. To get the end sector + * alignment decrease the PedAlignment offset by 1. + * + * \return NULL on error, otherwise a pointer to a dynamically allocated + * alignment. + */ +PedAlignment* +ped_disk_get_partition_alignment(const PedDisk *disk) +{ + /* disklabel handlers which don't need alignment don't define this */ + if (!disk->type->ops->get_partition_alignment) + return ped_alignment_duplicate(ped_alignment_any); + + return disk->type->ops->get_partition_alignment(disk); +} + +/** * Get the maximum number of (primary) partitions the disk label supports. * * For example, MacIntosh partition maps can have different sizes,
Implement get_partition_alignment DiskOp for all labels which require an alignment with a grain_size != 1. --- libparted/labels/dasd.c | 12 ++++++++++++ libparted/labels/mac.c | 11 ++++++++++- libparted/labels/pc98.c | 12 +++++++++++- libparted/labels/rdb.c | 12 +++++++++++- libparted/labels/sun.c | 10 ++++++++++ 5 files changed, 54 insertions(+), 3 deletions(-)
diff --git a/libparted/labels/dasd.c b/libparted/labels/dasd.c index 01a2357..93706ea 100644 --- a/libparted/labels/dasd.c +++ b/libparted/labels/dasd.c @@ -99,6 +99,7 @@ static int dasd_partition_align (PedPartition* part, static int dasd_partition_enumerate (PedPartition* part); static int dasd_get_max_primary_partition_count (const PedDisk* disk); static bool dasd_get_max_supported_partition_count (const PedDisk* disk, int *max_n); +static PedAlignment *dasd_get_partition_alignment(const PedDisk *disk);
static PedDisk* dasd_alloc (const PedDevice* dev); static PedDisk* dasd_duplicate (const PedDisk* disk); @@ -131,6 +132,7 @@ static PedDiskOps dasd_disk_ops = { alloc_metadata: dasd_alloc_metadata, get_max_primary_partition_count: dasd_get_max_primary_partition_count, get_max_supported_partition_count: dasd_get_max_supported_partition_count, + get_partition_alignment: dasd_get_partition_alignment,
partition_duplicate: NULL }; @@ -723,6 +725,16 @@ dasd_get_max_supported_partition_count (const PedDisk* disk, int *max_n) return true; }
+static PedAlignment* +dasd_get_partition_alignment(const PedDisk *disk) +{ + DasdDiskSpecific* disk_specific = disk->disk_specific; + PedSector sector_size = + disk_specific->real_sector_size / disk->dev->sector_size; + + return ped_alignment_new(0, disk->dev->hw_geom.sectors * sector_size); +} + static PedConstraint* _primary_constraint (PedDisk* disk) { diff --git a/libparted/labels/mac.c b/libparted/labels/mac.c index c8bf0d2..561ca5f 100644 --- a/libparted/labels/mac.c +++ b/libparted/labels/mac.c @@ -1425,6 +1425,14 @@ mac_partition_get_name (const PedPartition* part) return mac_data->volume_name; }
+static PedAlignment* +mac_get_partition_alignment(const PedDisk *disk) +{ + PedSector sector_size = disk->dev->sector_size / 512; + + return ped_alignment_new(0, sector_size); +} + static PedConstraint* _primary_constraint (PedDisk* disk) { @@ -1659,7 +1667,8 @@ static PedDiskOps mac_disk_ops = { get_max_primary_partition_count: mac_get_max_primary_partition_count, get_max_supported_partition_count: - mac_get_max_supported_partition_count + mac_get_max_supported_partition_count, + get_partition_alignment: mac_get_partition_alignment, };
static PedDiskType mac_disk_type = { diff --git a/libparted/labels/pc98.c b/libparted/labels/pc98.c index 40f74a2..4a8bcd4 100644 --- a/libparted/labels/pc98.c +++ b/libparted/labels/pc98.c @@ -720,6 +720,15 @@ pc98_partition_get_name (const PedPartition* part) return pc98_data->name; }
+static PedAlignment* +pc98_get_partition_alignment(const PedDisk *disk) +{ + PedSector cylinder_size = + disk->dev->hw_geom.sectors * disk->dev->hw_geom.heads; + + return ped_alignment_new(0, cylinder_size); +} + static PedConstraint* _primary_constraint (PedDisk* disk) { @@ -879,7 +888,8 @@ static PedDiskOps pc98_disk_ops = { get_max_primary_partition_count: pc98_get_max_primary_partition_count, get_max_supported_partition_count: - pc98_get_max_supported_partition_count + pc98_get_max_supported_partition_count, + get_partition_alignment: pc98_get_partition_alignment, };
static PedDiskType pc98_disk_type = { diff --git a/libparted/labels/rdb.c b/libparted/labels/rdb.c index 1d21dbd..9460f0c 100644 --- a/libparted/labels/rdb.c +++ b/libparted/labels/rdb.c @@ -1027,6 +1027,15 @@ amiga_partition_get_name (const PedPartition* part) return _amiga_get_bstr(partition->pb_DriveName); }
+static PedAlignment* +amiga_get_partition_alignment(const PedDisk *disk) +{ + PedSector cylinder_size = + disk->dev->hw_geom.sectors * disk->dev->hw_geom.heads; + + return ped_alignment_new(0, cylinder_size); +} + static PedConstraint* _amiga_get_constraint (const PedDisk *disk) { @@ -1175,7 +1184,8 @@ static PedDiskOps amiga_disk_ops = { get_max_primary_partition_count: amiga_get_max_primary_partition_count, get_max_supported_partition_count: - amiga_get_max_supported_partition_count + amiga_get_max_supported_partition_count, + get_partition_alignment: amiga_get_partition_alignment, };
static PedDiskType amiga_disk_type = { diff --git a/libparted/labels/sun.c b/libparted/labels/sun.c index 41f0bae..86e4ef4 100644 --- a/libparted/labels/sun.c +++ b/libparted/labels/sun.c @@ -707,6 +707,15 @@ sun_get_max_primary_partition_count (const PedDisk* disk) return SUN_DISK_MAXPARTITIONS; }
+static PedAlignment* +sun_get_partition_alignment(const PedDisk *disk) +{ + PedSector block = + disk->dev->hw_geom.sectors * disk->dev->hw_geom.heads; + + return ped_alignment_new(0, block); +} + static PedConstraint* _get_strict_constraint (PedDisk* disk) { @@ -904,6 +913,7 @@ static PedDiskOps sun_disk_ops = { sun_get_max_primary_partition_count, get_max_supported_partition_count: sun_get_max_supported_partition_count, + get_partition_alignment: sun_get_partition_alignment,
partition_set_name: NULL, partition_get_name: NULL,
anaconda-devel@lists.fedoraproject.org
-
Hans de Goede