install: allow to use last block for embedding

Devices such as ODROIDs have binaries which use every single block for embedding. Do not raise an error when binaries are touching, but not overlapping, each other when embedding these binaries during installation.

Example:

• Binary size: 15360 bytes
• Block size: 512 bytes
• Start current binary block: 1
• Start next binary block: 31

==> 30 blocks x 512 bytes = 15360 bytes

I tested this change on ODROIDs and they just boot fine, moreover, the official ODROID flashing script also allow this.

pmb/install/_install.py

@@ -425,44 +425,27 @@ def print_firewall_info(args):
     logging.info("For more information: https://postmarketos.org/firewall")
 
 
-def embed_firmware(args, suffix):
+def generate_binary_list(args, suffix, step):
     """
-    This method will embed firmware, located at /usr/share, that are specified
-    by the "sd_embed_firmware" deviceinfo parameter into the SD card image
-    (e.g. u-boot). Binaries that would overwrite the first partition are not
-    accepted, and if multiple binaries are specified then they will be checked
-    for collisions with each other.
+    Perform three checks prior to writing binaries to disk: 1) that binaries
+    exist, 2) that binaries do not extend into the first partition, 3) that
+    binaries do not overlap each other.
 
     :param suffix: of the chroot, which holds the firmware files (either the
                    f"rootfs_{args.device}", or f"installer_{args.device}")
+    :param step: partition step size in bytes
     """
-    if not args.deviceinfo["sd_embed_firmware"]:
-        return
-
-    step = 1024
-    if args.deviceinfo["sd_embed_firmware_step_size"]:
-        try:
-            step = int(args.deviceinfo["sd_embed_firmware_step_size"])
-        except ValueError:
-            raise RuntimeError("Value for "
-                               "deviceinfo_sd_embed_firmware_step_size "
-                               "is not valid: {}".format(step))
-
-    device_rootfs = mount_device_rootfs(args, suffix)
-    binaries = args.deviceinfo["sd_embed_firmware"].split(",")
-
-    # Perform three checks prior to writing binaries to disk: 1) that binaries
-    # exist, 2) that binaries do not extend into the first partition, 3) that
-    # binaries do not overlap each other
     binary_ranges = {}
     binary_list = []
+    binaries = args.deviceinfo["sd_embed_firmware"].split(",")
+
     for binary_offset in binaries:
         binary, offset = binary_offset.split(':')
         try:
             offset = int(offset)
         except ValueError:
             raise RuntimeError("Value for firmware binary offset is "
-                               "not valid: {}".format(offset))
+                               f"not valid: {offset}")
         binary_path = os.path.join(args.work, f"chroot_{suffix}", "usr/share",
                                    binary)
         if not os.path.exists(binary_path):
@@ -476,20 +459,49 @@ def embed_firmware(args, suffix):
         binary_size = os.path.getsize(binary_path)
         if binary_size > max_size:
             raise RuntimeError("The firmware is too big to embed in the "
-                               "disk image {}B > {}B".format(binary_size,
-                                                             max_size))
+                               f"disk image {binary_size}B > {max_size}B")
         # Insure that the firmware does not conflict with any other firmware
         # that will be embedded
         binary_start = offset * step
         binary_end = binary_start + binary_size
         for start, end in binary_ranges.items():
-            if ((binary_start >= start and binary_start <= end) or
-                    (binary_end >= start and binary_end <= end)):
+            if ((binary_start >= start and binary_start < end) or
+                    (binary_end > start and binary_end <= end)):
                 raise RuntimeError("The firmware overlaps with at least one "
-                                   "other firmware image: {}".format(binary))
+                                   f"other firmware image: {binary}")
+
         binary_ranges[binary_start] = binary_end
         binary_list.append((binary, offset))
 
+    return binary_list
+
+
+def embed_firmware(args, suffix):
+    """
+    This method will embed firmware, located at /usr/share, that are specified
+    by the "sd_embed_firmware" deviceinfo parameter into the SD card image
+    (e.g. u-boot). Binaries that would overwrite the first partition are not
+    accepted, and if multiple binaries are specified then they will be checked
+    for collisions with each other.
+
+    :param suffix: of the chroot, which holds the firmware files (either the
+                   f"rootfs_{args.device}", or f"installer_{args.device}")
+    """
+    if not args.deviceinfo["sd_embed_firmware"]:
+        return
+
+    step = 1024
+    if args.deviceinfo["sd_embed_firmware_step_size"]:
+        try:
+            step = int(args.deviceinfo["sd_embed_firmware_step_size"])
+        except ValueError:
+            raise RuntimeError("Value for "
+                               "deviceinfo_sd_embed_firmware_step_size "
+                               "is not valid: {}".format(step))
+
+    device_rootfs = mount_device_rootfs(args, suffix)
+    binary_list = generate_binary_list(args, suffix, step)
+
     # Write binaries to disk
     for binary, offset in binary_list:
         binary_file = os.path.join("/usr/share", binary)