disk: align footer

Some partitioning tools (`systemd-repart`) round down the usable end of
the disk to the grain boundary (made configurable in the previous
commit). This ensures that the *end* of the last partition on disk is
grain aligned.

`images` instead grows the last partition to take up all remaining size
on the disk. When the footer is not aligned to sector size that means
that the last partitions gets slightly larger than one would expect it
to be.

To figure out the size for the last partition we subtract the raw
non-aligned header size (16,896 bytes) from the total disk size and then
grow the last partition to that. This means that the last partition
gains 3,584 bytes (with a 4096 byte grain size).

Aligning the footer size to the grain size has the end result that the
last partition becomes exactly the requested size.

This new behavior is gated behind an `AlignFooter` flag in the partition
table as it's new behavior and it would change all pre-existing
partition tables.

Signed-off-by: Simon de Vlieger <cmdr@supakeen.com>

Author: supakeen

pkg/disk/partition_table.go

@@ -34,6 +34,9 @@ type PartitionTable struct {
 	ExtraPadding uint64 `json:"extra_padding,omitempty" yaml:"extra_padding,omitempty"`
 	// Starting offset of the first partition in the table (in bytes)
 	StartOffset Offset `json:"start_offset,omitempty" yaml:"start_offset,omitempty"`
+	// Align the GPT footer to the grain size, ensuring the last partition's
+	// size is also grain-aligned. Matches systemd-repart behavior.
+	AlignFooter bool `json:"align_footer,omitempty" yaml:"align_footer,omitempty"`
 
 	// Dictates if certain bits and bobs are required or not; uses the default
 	// policy if not set.
@@ -225,6 +228,7 @@ func (pt *PartitionTable) Clone() Entity {
 		GrainSize:    pt.GrainSize,
 		ExtraPadding: pt.ExtraPadding,
 		StartOffset:  pt.StartOffset,
+		AlignFooter:  pt.AlignFooter,
 		Policy:       pt.Policy,
 	}
 
@@ -516,6 +520,9 @@ func (pt *PartitionTable) relayout(size datasizes.Size) uint64 {
 	// The GPT header is also at the end of the partition table
 	if pt.Type == PT_GPT {
 		footer = header
+		if pt.AlignFooter {
+			footer = pt.AlignUp(footer)
+		}
 	}
 
 	start := pt.AlignUp(header + pt.StartOffset).Uint64()

pkg/disk/partition_table_internal_test.go

@@ -787,6 +787,55 @@ func TestRelayout(t *testing.T) {
 				},
 			},
 		},
+		"gpt-4k-grain-align-footer": {
+			pt: &PartitionTable{
+				Type:        PT_GPT,
+				Size:        200*MiB + 2*GiB,
+				GrainSize:   4096,
+				AlignFooter: true,
+				Partitions: []Partition{
+					{
+						Size: 200 * MiB,
+						Type: EFISystemPartitionGUID,
+						Payload: &Filesystem{
+							Type:       "vfat",
+							Mountpoint: "/boot/efi",
+						},
+					},
+					{
+						Size: 2 * GiB,
+						Payload: &Filesystem{
+							Mountpoint: "/",
+						},
+					},
+				},
+			},
+			size: 200*MiB + 2*GiB,
+			expected: &PartitionTable{
+				Type:        PT_GPT,
+				Size:        200*MiB + 2*GiB + 10*4096, // header (5*4096) + footer (5*4096)
+				GrainSize:   4096,
+				AlignFooter: true,
+				Partitions: []Partition{
+					{
+						Start: 5 * 4096, // header (16896) aligned up to 4096 grain
+						Size:  200 * MiB,
+						Type:  EFISystemPartitionGUID,
+						Payload: &Filesystem{
+							Type:       "vfat",
+							Mountpoint: "/boot/efi",
+						},
+					},
+					{
+						Start: 5*4096 + 200*MiB,
+						Size:  2 * GiB, // exactly 2 GiB: footer is grain-aligned so root stays aligned
+						Payload: &Filesystem{
+							Mountpoint: "/",
+						},
+					},
+				},
+			},
+		},
 	}
 
 	for name := range testCases {