- release 6 (by relup.sh)

[packages/parted.git] / 0035-parted-Display-details-of-partition-alignment-failur.patch

From a7d850a3b39b160dcc23e12491cb2cc7c056cd01 Mon Sep 17 00:00:00 2001
From: "Brian C. Lane" <bcl@redhat.com>
Date: Wed, 28 Oct 2015 11:57:22 -0700
Subject: [PATCH 35/36] parted: Display details of partition alignment failure
 (#726856)

When alignment for a new partition fails it isn't always obvious why it
failed. This adds printing the reason for the failure, in the form of:

start % grain != offset

This modifies align-check in interactive mode to print the alignment the
error details if it isn't aligned. Script mode behavior is unchanged.

Also cleanup pointer usage and handle asprintf failure by using a constant
string in the error report - "unknown (malloc failure)".

(cherry picked from commit 1726dbb4cd2dc4b19fe8d3c4b94e172fc0bd2c7c)
---
 parted/parted.c | 64 +++++++++++++++++++++++++++++++++++++++++++++------------
 1 file changed, 51 insertions(+), 13 deletions(-)

diff --git a/parted/parted.c b/parted/parted.c
index 18b778c..06f9971 100644
--- a/parted/parted.c
+++ b/parted/parted.c
@@ -183,7 +183,8 @@ static TimerContext timer_context;
 static int _print_list ();
 static void _done (PedDevice* dev, PedDisk *diskp);
 static bool partition_align_check (PedDisk const *disk,
-                        PedPartition const *part, enum AlignmentType a_type);
+                        PedPartition const *part, enum AlignmentType a_type,
+                        char **align_err);
 
 static void
 _timer_handler (PedTimer* timer, void* context)
@@ -783,21 +784,27 @@ do_mkpart (PedDevice** dev, PedDisk** diskp)
                         }
                 }
 
+                char *align_err = NULL;
                 if ((alignment == ALIGNMENT_OPTIMAL &&
-                     !partition_align_check(disk, part, PA_OPTIMUM)) ||
+                     !partition_align_check(disk, part, PA_OPTIMUM, &align_err)) ||
                     (alignment == ALIGNMENT_MINIMAL &&
-                     !partition_align_check(disk, part, PA_MINIMUM))) {
+                     !partition_align_check(disk, part, PA_MINIMUM, &align_err))) {
                         if (ped_exception_throw(
                                 PED_EXCEPTION_WARNING,
                                 (opt_script_mode
                                  ? PED_EXCEPTION_OK
                                  : PED_EXCEPTION_IGNORE_CANCEL),
                                 _("The resulting partition is not properly "
-                                  "aligned for best performance.")) ==
+                                  "aligned for best performance: %s"),
+                                align_err ? align_err : _("unknown (malloc failed)")) ==
                             PED_EXCEPTION_CANCEL) {
+                                if (align_err)
+                                    free(align_err);
                                 /* undo partition addition */
                                 goto error_remove_part;
                         }
+                    if (align_err)
+                        free(align_err);
                 }
         } else {
                 ped_exception_leave_all();
@@ -1629,10 +1636,18 @@ do_select (PedDevice** dev, PedDisk** diskp)
    offset and alignment requirements.  Also return true if there is
    insufficient kernel support to determine DISK's alignment requirements.
    Otherwise, return false.  A_TYPE selects whether to check for minimal
-   or optimal alignment requirements.  */
+   or optimal alignment requirements.
+
+   If align_err is not NULL a string describing why the check failed
+   will be allocated and returned. It is up to the caller to free this.
+   Pass NULL if no error description is needed.
+
+   If allocating the error string fails *align_err will be set to NULL, the
+   caller should always check for this.
+*/
 static bool
 partition_align_check (PedDisk const *disk, PedPartition const *part,
-		       enum AlignmentType a_type)
+		       enum AlignmentType a_type, char **align_err)
 {
   PED_ASSERT (part->disk == disk);
   PedDevice const *dev = disk->dev;
@@ -1641,10 +1656,20 @@ partition_align_check (PedDisk const *disk, PedPartition const *part,
 		      ? ped_device_get_minimum_alignment (dev)
 		      : ped_device_get_optimum_alignment (dev));
   if (pa == NULL)
-    return true;
+      return true;
 
   PED_ASSERT (pa->grain_size != 0);
   bool ok = (part->geom.start % pa->grain_size == pa->offset);
+
+  /* If it isn't aligned and the caller wants an explanation,
+     show them the math.  */
+  if (!ok && align_err) {
+      if (asprintf(align_err,
+                   "%llds %% %llds != %llds",
+                   part->geom.start, pa->grain_size, pa->offset) < 0) {
+          *align_err = NULL;
+      }
+  }
   free (pa);
   return ok;
 }
@@ -1665,12 +1690,25 @@ do_align_check (PedDevice **dev, PedDisk** diskp)
   if (!command_line_get_partition (_("Partition number?"), *diskp, &part))
     goto error;
 
-  bool aligned = partition_align_check (*diskp, part, align_type);
-  if (!opt_script_mode)
-    printf(aligned ? _("%d aligned\n") : _("%d not aligned\n"), part->num);
-
-  if (opt_script_mode)
-    return aligned ? 1 : 0;
+  char *align_err = NULL;
+  bool aligned = partition_align_check (*diskp, part, align_type, &align_err);
+
+  /* Don't print the error in script mode */
+  if (opt_script_mode) {
+      if (align_err)
+          free(align_err);
+      return aligned ? 1 : 0;
+  }
+
+  if (aligned)
+      printf(_("%d aligned\n"), part->num);
+  else
+      printf(_("%d not aligned: %s\n"),
+             part->num,
+             align_err ? align_err : _("unknown (malloc failed)"));
+
+  if (align_err)
+      free(align_err);
 
   /* Always return 1 in interactive mode, to be consistent
      with the other modes.  */
-- 
2.5.5