feat: Add explicit MBR partition set and MBR gaps removing functions

To be squashed

Author: adokitkat

esp_ext_part_tables/include/esp_ext_part_tables.h

@@ -35,7 +35,7 @@ typedef enum {
 } esp_ext_part_align_t;
 
 typedef enum {
-    ESP_EXT_PART_TYPE_UNKNOWN = 0,
+    ESP_EXT_PART_TYPE_NONE = 0x00,
     ESP_EXT_PART_TYPE_FAT_ANY, /*!< FAT partition (any type) */
     ESP_EXT_PART_TYPE_FAT12,
     ESP_EXT_PART_TYPE_FAT16, /*!< FAT16 with LBA addressing */

esp_ext_part_tables/include/esp_mbr.h

@@ -117,16 +117,54 @@ esp_err_t esp_mbr_parse(void* mbr_buf,
  * @param[in]  extra_args  Optional extra arguments for generation (can be NULL for defaults).
  *
  * @return
- *     - ESP_OK:              Generation was successful.
- *     - ESP_ERR_INVALID_ARG: Invalid arguments were provided.
+ *     - ESP_OK:                Generation was successful.
+ *     - ESP_ERR_INVALID_ARG:   Invalid arguments were provided.
  *     - ESP_ERR_INVALID_STATE: Error filling partition entry.
  *     - ESP_ERR_NOT_SUPPORTED: Partition address or size (sector count) exceeds 32-bit limit of MBR.
- *     - Other error codes from `esp_ext_part_list_insert` or related routines.
+ *     - Other error codes from `esp_ext_part_list_signature_get` or `esp_mbr_partition_set`.
  */
 esp_err_t esp_mbr_generate(mbr_t* mbr,
                            esp_ext_part_list_t* part_list,
                            esp_mbr_generate_extra_args_t* extra_args);
 
+/**
+ * @brief Sets a partition entry in the MBR (Master Boot Record).
+ *
+ * This function updates the specified partition entry in the provided MBR structure
+ * with the information from the given partition list item. Additional arguments for
+ * partition generation must be supplied via the extra_args parameter.
+ * 
+ * @note This function is not thread-safe.
+ *
+ * @warning If the partition entry is empty (i.e., `item->info.type` is `ESP_EXT_PART_TYPE_NONE`), it will be cleared in the MBR.
+ *          If there is an empty gap between partition entries, partition entries after the gap will most likely be ignored when the MBR is parsed (MBR does not allow gaps in the partition table).
+ *          To avoid this, you can use `esp_mbr_remove_gaps_between_partiton_entries()` function to remove gaps in the MBR partition table.
+ * 
+ * @param[in,out] mbr               Pointer to the MBR structure to be updated.
+ * @param[in]     partition_index   Index of the partition entry to set (0-3).
+ * @param[in]     item              Pointer to the partition list item structure containing partition information.
+ * @param[in]     extra_args        Extra arguments for partiton entry setting (required).
+ *
+ * @return
+ *     - ESP_OK:                Success.
+ *     - ESP_ERR_INVALID_ARG:   Invalid arguments were provided.
+ *     - ESP_ERR_INVALID_STATE: Error filling partition entry.
+ *     - ESP_ERR_NOT_SUPPORTED: Partition address or size (sector count) exceeds 32-bit limit of MBR.
+ */
+esp_err_t esp_mbr_partition_set(mbr_t* mbr, uint8_t partition_index, esp_ext_part_list_item_t* item, esp_mbr_generate_extra_args_t* extra_args);
+
+/**
+ * @brief Removes gaps in the MBR partition table by shifting partitions to left.
+ * 
+ * @note This function is not thread-safe.
+ * 
+ * @param[in,out] mbr Pointer to the MBR structure to be updated.
+ * @return
+ *     - ESP_OK: Success. 
+ *     - ESP_ERR_INVALID_ARG: Invalid pointer to MBR structure.
+ */
+esp_err_t esp_mbr_remove_gaps_between_partiton_entries(mbr_t* mbr);
+
 #ifdef __cplusplus
 }
 #endif

esp_ext_part_tables/src/esp_mbr.c

@@ -117,7 +117,7 @@ static uint8_t ext_part_type_known_to_mbr_type(esp_ext_part_type_known_t type)
 static bool default_known_supported_partition_types(uint8_t type, esp_ext_part_type_known_t* out_type_parsed)
 {
     bool supported = true;
-    esp_ext_part_type_known_t parsed_type = ESP_EXT_PART_TYPE_UNKNOWN;
+    esp_ext_part_type_known_t parsed_type = ESP_EXT_PART_TYPE_NONE;
     switch (type) {
     // Supported types:
     case 0x01: // FAT12
@@ -162,9 +162,9 @@ static bool default_known_supported_partition_types(uint8_t type, esp_ext_part_t
     return supported;
 }
 
-bool esp_mbr_default_supported_partition_types(uint8_t type, esp_ext_part_type_known_t* out_type_parsed)
+static bool esp_mbr_default_supported_partition_types(uint8_t type, esp_ext_part_type_known_t* out_type_parsed)
 {
-    esp_ext_part_type_known_t parsed_type = ESP_EXT_PART_TYPE_UNKNOWN;
+    esp_ext_part_type_known_t parsed_type = ESP_EXT_PART_TYPE_NONE;
     bool is_supported = default_known_supported_partition_types(type, &parsed_type);
 
     if (out_type_parsed != NULL) {
@@ -234,7 +234,7 @@ esp_err_t esp_mbr_parse(void* mbr_buf,
         }
 
         // If the partition entry is not supported, skip it as well
-        esp_ext_part_type_known_t parsed_type = ESP_EXT_PART_TYPE_UNKNOWN;
+        esp_ext_part_type_known_t parsed_type = ESP_EXT_PART_TYPE_NONE;
         bool is_supported = esp_mbr_default_supported_partition_types(partition->type, &parsed_type);
         if (!is_supported) {
             continue;
@@ -303,13 +303,53 @@ static bool mbr_partition_fill(mbr_partition_t* partition, esp_ext_part_list_ite
     return true; // OK
 }
 
+esp_err_t esp_mbr_partition_set(mbr_t* mbr, uint8_t partition_index, esp_ext_part_list_item_t* item, esp_mbr_generate_extra_args_t* extra_args)
+{
+    if (mbr == NULL || partition_index >= 4 || item == NULL || extra_args == NULL) {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    mbr_partition_t* partition = &mbr->partition_table[partition_index];
+
+    // Check if the partition entry is empty and if so, skip it
+    if (item->info.type == ESP_EXT_PART_TYPE_NONE) {
+        memset(partition, 0, sizeof(mbr_partition_t));
+        return ESP_OK; // No partition to set
+    }
+
+    // Check if we have enough space in the MBR partition table
+    uint64_t first_sector_address = esp_ext_part_bytes_to_sector_count(item->info.address, extra_args->sector_size);
+    uint64_t sector_count = esp_ext_part_bytes_to_sector_count(item->info.size, extra_args->sector_size);
+    if (first_sector_address > UINT32_MAX || sector_count > UINT32_MAX) {
+        ESP_LOGE(TAG, "Partition address or size exceeds 32-bit limit of MBR");
+        return ESP_ERR_NOT_SUPPORTED; // Address or size too large for MBR
+    }
+
+    // Set the partition info
+    if (item->info.flags & ESP_EXT_PART_FLAG_ACTIVE) {
+        partition->status = MBR_PARTITION_STATUS_ACTIVE;
+    }
+    partition->lba_start = esp_mbr_lba_align((uint32_t) first_sector_address, extra_args->sector_size, extra_args->alignment);
+    partition->sector_count = (uint32_t) sector_count;
+    partition->type = ext_part_type_known_to_mbr_type(item->info.type);
+
+
+    if (mbr_partition_fill(partition, item) == false) {
+        return ESP_ERR_INVALID_STATE; // Error filling partition
+    }
+
+    return ESP_OK;
+}
+
+
 esp_err_t esp_mbr_generate(mbr_t* mbr,
                            esp_ext_part_list_t* part_list,
                            esp_mbr_generate_extra_args_t* extra_args)
 {
     if (mbr == NULL || part_list == NULL) {
         return ESP_ERR_INVALID_ARG;
     }
+    esp_err_t err = ESP_OK;
 
     // Set default arguments for MBR generation
     esp_mbr_generate_extra_args_t args = {
@@ -332,7 +372,7 @@ esp_err_t esp_mbr_generate(mbr_t* mbr,
     mbr->boot_signature = MBR_SIGNATURE;
     if (args.keep_signature) {
         // Use the disk signature from the partition list
-        esp_err_t err = esp_ext_part_list_signature_get(part_list, &mbr->disk_signature);
+        err = esp_ext_part_list_signature_get(part_list, &mbr->disk_signature);
         if (err != ESP_OK) {
             ESP_LOGE(TAG, "Failed to get disk signature from partition list");
             return err;
@@ -345,33 +385,41 @@ esp_err_t esp_mbr_generate(mbr_t* mbr,
         mbr->copy_protected = MBR_COPY_PROTECTED;
     }
 
-    mbr_partition_t* partition = NULL;
     esp_ext_part_list_item_t *it = NULL;
     int i = 0;
-    uint64_t first_sector_address, sector_count;
     SLIST_FOREACH(it, &part_list->head, next) {
-        // Check if we have enough space in the MBR partition table
-        first_sector_address = esp_ext_part_bytes_to_sector_count(it->info.address, args.sector_size);
-        sector_count = esp_ext_part_bytes_to_sector_count(it->info.size, args.sector_size);
-        if (first_sector_address > UINT32_MAX || sector_count > UINT32_MAX) {
-            ESP_LOGE(TAG, "Partition address or size exceeds 32-bit limit of MBR");
-            return ESP_ERR_NOT_SUPPORTED; // Address or size too large for MBR
+        err = esp_mbr_partition_set(mbr, i, it, &args);
+        if (err != ESP_OK) {
+            ESP_LOGE(TAG, "Failed to set partition %d: %s", i, esp_err_to_name(err));
+            return err; // Error setting partition
         }
-
-        partition = (mbr_partition_t*) &mbr->partition_table[i];
         i += 1;
+    }
 
-        if (it->info.flags & ESP_EXT_PART_FLAG_ACTIVE) {
-            partition->status = MBR_PARTITION_STATUS_ACTIVE;
-        }
-        partition->lba_start = esp_mbr_lba_align((uint32_t) first_sector_address, args.sector_size, args.alignment);
-        partition->sector_count = (uint32_t) sector_count;
-        partition->type = ext_part_type_known_to_mbr_type(it->info.type);
+    return ESP_OK;
+}
 
-        if (mbr_partition_fill(partition, it) == false) {
-            return ESP_ERR_INVALID_STATE; // Error filling partition
+esp_err_t esp_mbr_remove_gaps_between_partiton_entries(mbr_t* mbr)
+{
+    if (mbr == NULL) {
+        return ESP_ERR_INVALID_ARG; // Invalid MBR pointer
+    }
+
+    // Iterate through the partition table and remove gaps
+    mbr_partition_t* partition;
+    uint8_t gap_index = 0; // Next index to fill
+    for (int i = 0; i < 4; i++) {
+        partition = &mbr->partition_table[i];
+        if (partition->type == 0x00) {
+            continue; // Skip empty entries
         }
+        if (gap_index != i) {
+            // Move the partition to the next available index
+            memcpy(&mbr->partition_table[gap_index], partition, sizeof(mbr_partition_t));
+            memset(partition, 0, sizeof(mbr_partition_t)); // Clear the old entry
+        }
+        gap_index++;
     }
 
     return ESP_OK;
-}
+}

esp_ext_part_tables/test_apps/main/test_esp_ext_part.c

@@ -29,7 +29,7 @@ uint8_t mbr_bin[512] = {
 
 unsigned int mbr_bin_len = 512;
 
-void print_esp_ext_part_list_item(esp_ext_part_list_item_t* head)
+static void print_esp_ext_part_list_items(esp_ext_part_list_item_t* head)
 {
     esp_ext_part_list_item_t* it = head;
     int i = 0;
@@ -59,7 +59,7 @@ TEST_CASE("Test esp_mbr_parse", "[esp_ext_part_table]")
     esp_ext_part_list_item_t* it = esp_ext_part_list_item_head(&part_list);
     TEST_ASSERT_NOT_NULL(it);
 
-    print_esp_ext_part_list_item(it);
+    print_esp_ext_part_list_items(it);
     fflush(stdout);
 
     do {
@@ -125,8 +125,8 @@ TEST_CASE("Test esp_mbr_generate generates the (almost) same MBR as the original
     esp_ext_part_list_item_t* it2 = esp_ext_part_list_item_head(&part_list2);
     TEST_ASSERT_NOT_NULL(it2);
 
-    print_esp_ext_part_list_item(it1);
-    print_esp_ext_part_list_item(it2);
+    print_esp_ext_part_list_items(it1);
+    print_esp_ext_part_list_items(it2);
     fflush(stdout);
 
     uint8_t* mbr_bin_from_part_table = (uint8_t*) mbr_bin + MBR_PARTITION_TABLE_OFFSET;
@@ -156,7 +156,7 @@ TEST_CASE("Test esp_mbr_generate with esp_mbr_parse", "[esp_ext_part_table]")
     TEST_ASSERT_NOT_NULL(it);
 
     // Print the partition list
-    print_esp_ext_part_list_item(it);
+    print_esp_ext_part_list_items(it);
     fflush(stdout);
 
     do {
@@ -214,7 +214,7 @@ TEST_CASE("Test esp_mbr_generate with esp_mbr_parse", "[esp_ext_part_table]")
     // Print the partition list
     it = esp_ext_part_list_item_head(&part_list);
     TEST_ASSERT_NOT_NULL(it);
-    print_esp_ext_part_list_item(it);
+    print_esp_ext_part_list_items(it);
     fflush(stdout);
 
     // Deinitialize the part list
@@ -241,6 +241,102 @@ TEST_CASE("Test esp_ext_part_list_signature_t get and set", "[esp_ext_part_table
     TEST_ESP_OK(esp_ext_part_list_deinit(&part_list));
 }
 
+TEST_CASE("Test esp_mbr_partition_set and esp_mbr_remove_gaps_between_partiton_entries", "[esp_ext_part_table]")
+{
+    esp_ext_part_list_t part_list = {0};
+
+    esp_mbr_generate_extra_args_t mbr_args = {
+        .sector_size = ESP_EXT_PART_SECTOR_SIZE_512B,
+        .alignment = ESP_EXT_PART_ALIGN_1MiB
+    };
+
+    // 4 FAT12 partitions
+    esp_ext_part_list_item_t item = {
+        .info = {
+            .size = 10 * 1024 * 1024, // 10 MiB
+            .type = ESP_EXT_PART_TYPE_FAT12,
+        }
+    };
+
+    for (int i = 0; i < 4; i++) {
+        item.info.address = 1024 * 1024 + i * item.info.size; // First partition starts at 1 MiB offset, next partitions are 10 MiB apart
+        TEST_ESP_OK(esp_ext_part_list_insert(&part_list, &item));
+    }
+
+    printf("Partition list after creation:\n");
+    esp_ext_part_list_item_t* it = esp_ext_part_list_item_head(&part_list);
+    TEST_ASSERT_NOT_NULL(it);
+    print_esp_ext_part_list_items(it);
+    fflush(stdout);
+
+    // Generate the MBR
+    mbr_t* mbr = (mbr_t*) calloc(1, sizeof(mbr_t));
+    TEST_ASSERT_NOT_NULL(mbr);
+
+    TEST_ESP_OK(esp_mbr_generate(mbr, &part_list, &mbr_args));
+    // Deinitialize the part list
+    TEST_ESP_OK(esp_ext_part_list_deinit(&part_list));
+
+    // Create gaps in MBR at index 1 and 2
+    // This will remove the second and third partitions from the MBR
+    esp_ext_part_list_item_t empty_item = {
+        .info = {
+            .type = ESP_EXT_PART_TYPE_NONE, // No type
+        }
+    };
+    esp_mbr_partition_set(mbr, 1, &empty_item, &mbr_args);
+    esp_mbr_partition_set(mbr, 2, &empty_item, &mbr_args);
+    printf("Partition 1 and 2 removed, 0 and 3 remained, gaps created\n\n");
+
+    // Parse the MBR to get the partition list without removing the gaps
+    esp_ext_part_list_t part_list_from_mbr = {0};
+    TEST_ESP_OK(esp_mbr_parse((void*) mbr, &part_list_from_mbr, NULL));
+
+    it = esp_ext_part_list_item_head(&part_list_from_mbr);
+    TEST_ASSERT_NOT_NULL(it);
+    int partition_count = 1;
+    while ((it = esp_ext_part_list_item_next(it)) != NULL) {
+        partition_count++;
+    }
+    TEST_ASSERT_EQUAL(partition_count, 1);
+
+    // Print the partition list
+    printf("Partition list after creating gaps (partition 3 is missing because the gaps were created and not shifted out):\n");
+    it = esp_ext_part_list_item_head(&part_list_from_mbr);
+    TEST_ASSERT_NOT_NULL(it);
+    print_esp_ext_part_list_items(it);
+    fflush(stdout);
+
+    // Deinitialize the part list
+    TEST_ESP_OK(esp_ext_part_list_deinit(&part_list_from_mbr));
+
+    // Now remove the gaps between partition entries
+    esp_mbr_remove_gaps_between_partiton_entries(mbr);
+    // Parse the MBR to get the partition list with gaps removed
+    esp_ext_part_list_t part_list_from_mbr_correct = {0};
+    TEST_ESP_OK(esp_mbr_parse((void*) mbr, &part_list_from_mbr_correct, NULL));
+    free(mbr);
+
+    // Now the partition list should contain 2 partitions (originally partition 0 and 3, now partition 0 and 1)
+    it = esp_ext_part_list_item_head(&part_list_from_mbr_correct);
+    TEST_ASSERT_NOT_NULL(it);
+    partition_count = 1;
+    while ((it = esp_ext_part_list_item_next(it)) != NULL) {
+        partition_count++;
+    }
+    TEST_ASSERT_EQUAL(partition_count, 2);
+
+    // Print the partition list
+    printf("Partition list after removing gaps (partition 0 stayed the same, partition 3 was shifted and now is partition 1):\n");
+    it = esp_ext_part_list_item_head(&part_list_from_mbr_correct);
+    TEST_ASSERT_NOT_NULL(it);
+    print_esp_ext_part_list_items(it);
+    fflush(stdout);
+
+    // Deinitialize the part list
+    TEST_ESP_OK(esp_ext_part_list_deinit(&part_list_from_mbr_correct));
+}
+
 void app_main(void)
 {
     unity_run_menu();