Upmerge 01.03.2024

boot/boot_serial/src/boot_serial.c

@@ -294,10 +294,12 @@ bs_list(char *buf, int len)
                 if (FIH_EQ(fih_rc, FIH_BOOT_HOOK_REGULAR))
                 {
 #if defined(MCUBOOT_ENC_IMAGES)
+#if !defined(MCUBOOT_SINGLE_APPLICATION_SLOT)
                     if (IS_ENCRYPTED(&hdr) && MUST_DECRYPT(fap, image_index, &hdr)) {
                         FIH_CALL(boot_image_validate_encrypted, fih_rc, fap,
                                  &hdr, tmpbuf, sizeof(tmpbuf));
                     } else {
+#endif
                         if (IS_ENCRYPTED(&hdr)) {
                             /*
                              * There is an image present which has an encrypted flag set but is
@@ -310,7 +312,7 @@ bs_list(char *buf, int len)
 
                         FIH_CALL(bootutil_img_validate, fih_rc, NULL, 0, &hdr,
                                  fap, tmpbuf, sizeof(tmpbuf), NULL, 0, NULL);
-#if defined(MCUBOOT_ENC_IMAGES)
+#if defined(MCUBOOT_ENC_IMAGES) && !defined(MCUBOOT_SINGLE_APPLICATION_SLOT)
                     }
 #endif
                 }

boot/bootutil/include/bootutil/boot_status.h

@@ -122,7 +122,8 @@ enum mcuboot_mode {
     MCUBOOT_MODE_SWAP_USING_MOVE,
     MCUBOOT_MODE_DIRECT_XIP,
     MCUBOOT_MODE_DIRECT_XIP_WITH_REVERT,
-    MCUBOOT_MODE_RAM_LOAD
+    MCUBOOT_MODE_RAM_LOAD,
+    MCUBOOT_MODE_FIRMWARE_LOADER
 };
 
 enum mcuboot_signature_type {

boot/bootutil/src/boot_record.c

@@ -250,6 +250,8 @@ int boot_save_shared_data(const struct image_header *hdr, const struct flash_are
 #endif
 #elif defined(MCUBOOT_RAM_LOAD)
     uint8_t mode = MCUBOOT_MODE_RAM_LOAD;
+#elif defined(MCUBOOT_FIRMWARE_LOADER)
+    uint8_t mode = MCUBOOT_MODE_FIRMWARE_LOADER;
 #else
 #error "Unknown mcuboot operating mode"
 #endif

boot/bootutil/src/bootutil_misc.c

@@ -333,7 +333,8 @@ boot_write_enc_key(const struct flash_area *fap, uint8_t slot,
 
 uint32_t bootutil_max_image_size(const struct flash_area *fap)
 {
-#if defined(MCUBOOT_SWAP_USING_SCRATCH) || defined(MCUBOOT_SINGLE_APPLICATION_SLOT)
+#if defined(MCUBOOT_SWAP_USING_SCRATCH) || defined(MCUBOOT_SINGLE_APPLICATION_SLOT) || \
+    defined(MCUBOOT_FIRMWARE_LOADER)
     return boot_status_off(fap);
 #elif defined(MCUBOOT_SWAP_USING_MOVE)
     struct flash_sector sector;

boot/bootutil/src/bootutil_priv.h

@@ -57,15 +57,17 @@ struct flash_area;
 #if (defined(MCUBOOT_OVERWRITE_ONLY) + \
      defined(MCUBOOT_SWAP_USING_MOVE) + \
      defined(MCUBOOT_DIRECT_XIP) + \
-     defined(MCUBOOT_RAM_LOAD)) > 1
-#error "Please enable only one of MCUBOOT_OVERWRITE_ONLY, MCUBOOT_SWAP_USING_MOVE, MCUBOOT_DIRECT_XIP or MCUBOOT_RAM_LOAD"
+     defined(MCUBOOT_RAM_LOAD) + \
+     defined(MCUBOOT_FIRMWARE_LOADER)) > 1
+#error "Please enable only one of MCUBOOT_OVERWRITE_ONLY, MCUBOOT_SWAP_USING_MOVE, MCUBOOT_DIRECT_XIP, MCUBOOT_RAM_LOAD or MCUBOOT_FIRMWARE_LOADER"
 #endif
 
 #if !defined(MCUBOOT_OVERWRITE_ONLY) && \
     !defined(MCUBOOT_SWAP_USING_MOVE) && \
     !defined(MCUBOOT_DIRECT_XIP) && \
     !defined(MCUBOOT_RAM_LOAD) && \
-    !defined(MCUBOOT_SINGLE_APPLICATION_SLOT)
+    !defined(MCUBOOT_SINGLE_APPLICATION_SLOT) && \
+    !defined(MCUBOOT_FIRMWARE_LOADER)
 #define MCUBOOT_SWAP_USING_SCRATCH 1
 #endif
 

boot/bootutil/src/loader.c

@@ -488,6 +488,10 @@ boot_write_status(const struct boot_loader_state *state, struct boot_status *bs)
     memset(buf, erased_val, BOOT_MAX_ALIGN);
     buf[0] = bs->state;
 
+    BOOT_LOG_DBG("writing swap status; fa_id=%d off=0x%lx (0x%lx)",
+                 flash_area_get_id(fap), (unsigned long)off,
+                 (unsigned long)flash_area_get_off(fap) + off);
+
     rc = flash_area_write(fap, off, buf, align);
     if (rc != 0) {
         rc = BOOT_EFLASH;

boot/bootutil/src/swap_move.c

@@ -234,6 +234,28 @@ boot_status_internal_off(const struct boot_status *bs, int elem_sz)
     return off;
 }
 
+static int app_max_sectors(struct boot_loader_state *state)
+{
+    uint32_t sz = 0;
+    uint32_t sector_sz;
+    uint32_t trailer_sz;
+    uint32_t first_trailer_idx;
+
+    sector_sz = boot_img_sector_size(state, BOOT_PRIMARY_SLOT, 0);
+    trailer_sz = boot_trailer_sz(BOOT_WRITE_SZ(state));
+    first_trailer_idx = boot_img_num_sectors(state, BOOT_PRIMARY_SLOT) - 1;
+
+    while (1) {
+        sz += sector_sz;
+        if  (sz >= trailer_sz) {
+            break;
+        }
+        first_trailer_idx--;
+    }
+
+    return first_trailer_idx;
+}
+
 int
 boot_slots_compatible(struct boot_loader_state *state)
 {
@@ -254,20 +276,31 @@ boot_slots_compatible(struct boot_loader_state *state)
     size_t sector_sz_pri = 0;
     size_t sector_sz_sec = 0;
     size_t i;
+    size_t num_usable_sectors_pri;
 
     num_sectors_pri = boot_img_num_sectors(state, BOOT_PRIMARY_SLOT);
     num_sectors_sec = boot_img_num_sectors(state, BOOT_SECONDARY_SLOT);
+    num_usable_sectors_pri = app_max_sectors(state);
+
     if ((num_sectors_pri != num_sectors_sec) &&
-            (num_sectors_pri != (num_sectors_sec + 1))) {
+            (num_sectors_pri != (num_sectors_sec + 1)) &&
+            (num_usable_sectors_pri != (num_sectors_sec + 1))) {
         BOOT_LOG_WRN("Cannot upgrade: not a compatible amount of sectors");
+        BOOT_LOG_DBG("slot0 sectors: %d, slot1 sectors: %d, usable slot0 sectors: %d",
+                     (int)num_sectors_pri, (int)num_sectors_sec,
+                     (int)(num_usable_sectors_pri - 1));
         return 0;
-    }
-
-    if (num_sectors_pri > BOOT_MAX_IMG_SECTORS) {
+    } else if (num_sectors_pri > BOOT_MAX_IMG_SECTORS) {
         BOOT_LOG_WRN("Cannot upgrade: more sectors than allowed");
         return 0;
     }
 
+    if (num_usable_sectors_pri != (num_sectors_sec + 1)) {
+        BOOT_LOG_DBG("Non-optimal sector distribution, slot0 has %d usable sectors (%d assigned) "
+                     "but slot1 has %d assigned", (int)(num_usable_sectors_pri - 1),
+                     (int)num_sectors_pri, (int)num_sectors_sec);
+    }
+
     for (i = 0; i < num_sectors_sec; i++) {
         sector_sz_pri = boot_img_sector_size(state, BOOT_PRIMARY_SLOT, i);
         sector_sz_sec = boot_img_sector_size(state, BOOT_SECONDARY_SLOT, i);
@@ -557,24 +590,11 @@ swap_run(struct boot_loader_state *state, struct boot_status *bs,
 
 int app_max_size(struct boot_loader_state *state)
 {
-    uint32_t sz = 0;
     uint32_t sector_sz;
-    uint32_t trailer_sz;
-    uint32_t first_trailer_idx;
 
     sector_sz = boot_img_sector_size(state, BOOT_PRIMARY_SLOT, 0);
-    trailer_sz = boot_trailer_sz(BOOT_WRITE_SZ(state));
-    first_trailer_idx = boot_img_num_sectors(state, BOOT_PRIMARY_SLOT) - 1;
-
-    while (1) {
-        sz += sector_sz;
-        if  (sz >= trailer_sz) {
-            break;
-        }
-        first_trailer_idx--;
-    }
 
-    return (first_trailer_idx * sector_sz);
+    return (app_max_sectors(state) * sector_sz);
 }
 
 #endif

boot/zcbor/include/zcbor_print.h

@@ -73,25 +73,25 @@ do { \
 #endif
 
 __attribute__((used))
-static void zcbor_print_compare_lines(const uint8_t *str1, const uint8_t *str2, uint32_t size)
+static void zcbor_print_compare_lines(const uint8_t *str1, const uint8_t *str2, size_t size)
 {
-	for (uint32_t j = 0; j < size; j++) {
+	for (size_t j = 0; j < size; j++) {
 		zcbor_do_print("%x ", str1[j]);
 	}
 	zcbor_do_print("\r\n");
-	for (uint32_t j = 0; j < size; j++) {
+	for (size_t j = 0; j < size; j++) {
 		zcbor_do_print("%x ", str2[j]);
 	}
 	zcbor_do_print("\r\n");
-	for (uint32_t j = 0; j < size; j++) {
+	for (size_t j = 0; j < size; j++) {
 		zcbor_do_print("%x ", str1[j] != str2[j]);
 	}
 	zcbor_do_print("\r\n");
 	zcbor_do_print("\r\n");
 }
 
 __attribute__((used))
-static void zcbor_print_compare_strings(const uint8_t *str1, const uint8_t *str2, uint32_t size)
+static void zcbor_print_compare_strings(const uint8_t *str1, const uint8_t *str2, size_t size)
 {
 	const size_t col_width = 16;
 
@@ -104,7 +104,7 @@ static void zcbor_print_compare_strings(const uint8_t *str1, const uint8_t *str2
 }
 
 __attribute__((used))
-static void zcbor_print_compare_strings_diff(const uint8_t *str1, const uint8_t *str2, uint32_t size)
+static void zcbor_print_compare_strings_diff(const uint8_t *str1, const uint8_t *str2, size_t size)
 {
 	const size_t col_width = 16;
 	bool printed = false;

boot/zcbor/src/zcbor_common.c

@@ -355,23 +355,30 @@ float zcbor_float16_to_32(uint16_t input)
 				: (expo + (F32_BIAS - F16_BIAS));
 		uint32_t value32 = (sign << F32_SIGN_OFFS) | (new_expo << F32_EXPO_OFFS)
 			| (mantissa << (F32_EXPO_OFFS - F16_EXPO_OFFS));
-		return *(float *)&value32;
+		float result;
+
+		memcpy(&result, &value32, sizeof(result));
+		return result;
 	}
 }
 
 
 uint16_t zcbor_float32_to_16(float input)
 {
-	uint32_t value32 = *(uint32_t *)&input;
+	uint32_t value32;
+
+	memcpy(&value32, &input, sizeof(value32));
 
 	uint32_t sign = value32 >> F32_SIGN_OFFS;
 	uint32_t expo = (value32 >> F32_EXPO_OFFS) & F32_EXPO_MSK;
 	uint32_t mantissa = value32 & F32_MANTISSA_MSK;
 
 	uint16_t value16 = (uint16_t)(sign << F16_SIGN_OFFS);
 
+	uint32_t abs_value32 = value32 & ~(1 << F32_SIGN_OFFS);
 	float abs_input;
-	*(uint32_t *)&abs_input = value32 & ~(1 << F32_SIGN_OFFS);
+
+	memcpy(&abs_input, &abs_value32, sizeof(abs_input));
 
 	if (abs_input <= (F16_MIN / 2)) {
 		/* 0 or too small for float16. Round down to 0. value16 is already correct. */