Commit 921ee510 authored by Thomas Altenbach's avatar Thomas Altenbach Committed by Jamie McCrae
Browse files

bootutil: loader: Expose routine to determine sector layout 



For most upgrade strategies, it is currently needed to determine the
sector layout of each flash area to initialize a bootloader state. This
is made in loader.c by the internal boot_read_sectors routine. Since
doing so will also be needed in boot_serial, this commit exposes this
routine in bootutil_priv.h.

Previously boot_read_sectors was assuming the provided bootloader state
already contained buffers where to store the sectors. To avoid code
duplication, the routine is now also responsible for initializing the
state with the buffers that are provided as argument. By default, the
global static buffers defined in loader.c are used. This will avoid
allocating dedicated buffers in boot_serial.

Note: This PR has been modified from the upstream commit due to
a merge failure from other changes that are not being brought into
Zephyr 3.7

Signed-off-by: default avatarThomas Altenbach <thomas.altenbach@legrand.com>
(cherry picked from commit f1efd483)
parent 5ceb9d7e

boot/bootutil/src/bootutil_priv.h

+26 −0
Original line number Diff line number Diff line
@@ -265,6 +265,17 @@ struct boot_loader_state { 
#endif /* MCUBOOT_DIRECT_XIP || MCUBOOT_RAM_LOAD */

};



struct boot_sector_buffer {

    boot_sector_t primary[BOOT_IMAGE_NUMBER][BOOT_MAX_IMG_SECTORS];

    boot_sector_t secondary[BOOT_IMAGE_NUMBER][BOOT_MAX_IMG_SECTORS];

#if MCUBOOT_SWAP_USING_SCRATCH

    boot_sector_t scratch[BOOT_MAX_IMG_SECTORS];

#endif

};



/* The function is intended for verification of image hash against

 * provided signature.

 */

fih_ret bootutil_verify_sig(uint8_t *hash, uint32_t hlen, uint8_t *sig,

                            size_t slen, uint8_t key_id);
@@ -350,6 +361,21 @@ int boot_open_all_flash_areas(struct boot_loader_state *state); 
 */

void boot_close_all_flash_areas(struct boot_loader_state *state);



#if !defined(MCUBOOT_DIRECT_XIP) && !defined(MCUBOOT_RAM_LOAD)

/**

 * Determines the sector layout of both image slots and the scratch area.

 *

 * This information is necessary for calculating the number of bytes to erase

 * and copy during an image swap. The information collected during this

 * function is used to populate the state.

 *

 * @param state   Bootloader state.

 * @param sectors Buffers where to store the sector layout. If NULL, the statically-allocated

 *                buffers in loader.c will be used.

 */

int boot_read_sectors(struct boot_loader_state *state, struct boot_sector_buffer *sectors);

#endif



/**

 * Safe (non-overflowing) uint32_t addition.  Returns true, and stores

 * the result in *dest if it can be done without overflow.  Otherwise,

boot/bootutil/src/loader.c

+75 −88
Original line number Diff line number Diff line
@@ -63,6 +63,7 @@ 
BOOT_LOG_MODULE_DECLARE(mcuboot);



static struct boot_loader_state boot_data;

static struct boot_sector_buffer sector_buffers;



#if (BOOT_IMAGE_NUMBER > 1)

#define IMAGES_ITER(x) for ((x) = 0; (x) < BOOT_IMAGE_NUMBER; ++(x))
@@ -270,6 +271,45 @@ boot_version_cmp(const struct image_version *ver1, 
}

#endif



#if (!defined(MCUBOOT_DIRECT_XIP) && !defined(MCUBOOT_RAM_LOAD))

static int

boot_initialize_area(struct boot_loader_state *state, int flash_area)

{

    uint32_t num_sectors = BOOT_MAX_IMG_SECTORS;

    boot_sector_t *out_sectors;

    uint32_t *out_num_sectors;

    int rc;



    num_sectors = BOOT_MAX_IMG_SECTORS;



    if (flash_area == FLASH_AREA_IMAGE_PRIMARY(BOOT_CURR_IMG(state))) {

        out_sectors = BOOT_IMG(state, BOOT_PRIMARY_SLOT).sectors;

        out_num_sectors = &BOOT_IMG(state, BOOT_PRIMARY_SLOT).num_sectors;

    } else if (flash_area == FLASH_AREA_IMAGE_SECONDARY(BOOT_CURR_IMG(state))) {

        out_sectors = BOOT_IMG(state, BOOT_SECONDARY_SLOT).sectors;

        out_num_sectors = &BOOT_IMG(state, BOOT_SECONDARY_SLOT).num_sectors;

#if MCUBOOT_SWAP_USING_SCRATCH

    } else if (flash_area == FLASH_AREA_IMAGE_SCRATCH) {

        out_sectors = state->scratch.sectors;

        out_num_sectors = &state->scratch.num_sectors;

#endif

    } else {

        return BOOT_EFLASH;

    }



#ifdef MCUBOOT_USE_FLASH_AREA_GET_SECTORS

    rc = flash_area_get_sectors(flash_area, &num_sectors, out_sectors);

#else

    _Static_assert(sizeof(int) <= sizeof(uint32_t), "Fix needed");

    rc = flash_area_to_sectors(flash_area, (int *)&num_sectors, out_sectors);

#endif /* defined(MCUBOOT_USE_FLASH_AREA_GET_SECTORS) */

    if (rc != 0) {

        return rc;

    }

    *out_num_sectors = num_sectors;

    return 0;

}

#endif



#if (BOOT_IMAGE_NUMBER > 1)
@@ -586,58 +626,26 @@ boot_write_sz(struct boot_loader_state *state) 
    return elem_sz;

}



static int

boot_initialize_area(struct boot_loader_state *state, int flash_area)

int

boot_read_sectors(struct boot_loader_state *state, struct boot_sector_buffer *sectors)

{

    uint32_t num_sectors = BOOT_MAX_IMG_SECTORS;

    boot_sector_t *out_sectors;

    uint32_t *out_num_sectors;

    uint8_t image_index;

    int rc;



    num_sectors = BOOT_MAX_IMG_SECTORS;



    if (flash_area == FLASH_AREA_IMAGE_PRIMARY(BOOT_CURR_IMG(state))) {

        out_sectors = BOOT_IMG(state, BOOT_PRIMARY_SLOT).sectors;

        out_num_sectors = &BOOT_IMG(state, BOOT_PRIMARY_SLOT).num_sectors;

    } else if (flash_area == FLASH_AREA_IMAGE_SECONDARY(BOOT_CURR_IMG(state))) {

        out_sectors = BOOT_IMG(state, BOOT_SECONDARY_SLOT).sectors;

        out_num_sectors = &BOOT_IMG(state, BOOT_SECONDARY_SLOT).num_sectors;

#if MCUBOOT_SWAP_USING_SCRATCH

    } else if (flash_area == FLASH_AREA_IMAGE_SCRATCH) {

        out_sectors = state->scratch.sectors;

        out_num_sectors = &state->scratch.num_sectors;

#endif

    } else {

        return BOOT_EFLASH;

    }



#ifdef MCUBOOT_USE_FLASH_AREA_GET_SECTORS

    rc = flash_area_get_sectors(flash_area, &num_sectors, out_sectors);

#else

    _Static_assert(sizeof(int) <= sizeof(uint32_t), "Fix needed");

    rc = flash_area_to_sectors(flash_area, (int *)&num_sectors, out_sectors);

#endif /* defined(MCUBOOT_USE_FLASH_AREA_GET_SECTORS) */

    if (rc != 0) {

        return rc;

    }

    *out_num_sectors = num_sectors;

    return 0;

    if (sectors == NULL) {

        sectors = &sector_buffers;

    }



/**

 * Determines the sector layout of both image slots and the scratch area.

 * This information is necessary for calculating the number of bytes to erase

 * and copy during an image swap.  The information collected during this

 * function is used to populate the state.

 */

static int

boot_read_sectors(struct boot_loader_state *state)

{

    uint8_t image_index;

    int rc;



    image_index = BOOT_CURR_IMG(state);



    BOOT_IMG(state, BOOT_PRIMARY_SLOT).sectors =

        sectors->primary[image_index];

    BOOT_IMG(state, BOOT_SECONDARY_SLOT).sectors =

        sectors->secondary[image_index];

#if MCUBOOT_SWAP_USING_SCRATCH

    state->scratch.sectors = sectors->scratch;

#endif



    rc = boot_initialize_area(state, FLASH_AREA_IMAGE_PRIMARY(image_index));

    if (rc != 0) {

        return BOOT_EFLASH;
@@ -1815,22 +1823,6 @@ boot_prepare_image_for_update(struct boot_loader_state *state, 
    int rc;

    FIH_DECLARE(fih_rc, FIH_FAILURE);



    /* Determine the sector layout of the image slots and scratch area. */

    rc = boot_read_sectors(state);

    if (rc != 0) {

        BOOT_LOG_WRN("Failed reading sectors; BOOT_MAX_IMG_SECTORS=%d"

                     " - too small?", BOOT_MAX_IMG_SECTORS);

        /* Unable to determine sector layout, continue with next image

         * if there is one.

         */

        BOOT_SWAP_TYPE(state) = BOOT_SWAP_TYPE_NONE;

        if (rc == BOOT_EFLASH)

        {

            /* Only return on error from the primary image flash */

            return;

        }

    }



    /* Attempt to read an image header from each slot. */

    rc = boot_read_image_headers(state, false, NULL);

    if (rc != 0) {
@@ -2080,21 +2072,15 @@ fih_ret 
context_boot_go(struct boot_loader_state *state, struct boot_rsp *rsp)

{

    struct boot_status bs;

    struct boot_sector_buffer *sectors = NULL;

    int rc = -1;

    FIH_DECLARE(fih_rc, FIH_FAILURE);

    int image_index;

    bool has_upgrade;

    volatile int fih_cnt;



    /* The array of slot sectors are defined here (as opposed to file scope) so

     * that they don't get allocated for non-boot-loader apps.  This is

     * necessary because the gcc option "-fdata-sections" doesn't seem to have

     * any effect in older gcc versions (e.g., 4.8.4).

     */

    TARGET_STATIC boot_sector_t primary_slot_sectors[BOOT_IMAGE_NUMBER][BOOT_MAX_IMG_SECTORS];

    TARGET_STATIC boot_sector_t secondary_slot_sectors[BOOT_IMAGE_NUMBER][BOOT_MAX_IMG_SECTORS];

#if MCUBOOT_SWAP_USING_SCRATCH

    TARGET_STATIC boot_sector_t scratch_sectors[BOOT_MAX_IMG_SECTORS];

#if defined(__BOOTSIM__)

    struct boot_sector_buffer sector_buf;

    sectors = &sector_buf;

#endif



    has_upgrade = false;
@@ -2129,19 +2115,22 @@ context_boot_go(struct boot_loader_state *state, struct boot_rsp *rsp) 
         */

        boot_enc_zeroize(BOOT_CURR_ENC(state));

#endif

        /* Determine the sector layout of the image slots and scratch area. */

        rc = boot_read_sectors(state, sectors);

        if (rc != 0) {

            BOOT_LOG_WRN("Failed reading sectors; BOOT_MAX_IMG_SECTORS=%d"

                          " - too small?", BOOT_MAX_IMG_SECTORS);

            BOOT_SWAP_TYPE(state) = BOOT_SWAP_TYPE_NONE;

        }



        image_index = BOOT_CURR_IMG(state);



        BOOT_IMG(state, BOOT_PRIMARY_SLOT).sectors =

            primary_slot_sectors[image_index];

        BOOT_IMG(state, BOOT_SECONDARY_SLOT).sectors =

            secondary_slot_sectors[image_index];

#if MCUBOOT_SWAP_USING_SCRATCH

        state->scratch.sectors = scratch_sectors;

#endif



        /* Determine swap type and complete swap if it has been aborted. */

        /* Unless there was an error when determining the sector layout of the primary slot,

         * determine swap type and complete swap if it has been aborted.

         *

         * Note boot_read_sectors returns BOOT_EFLASH_SEC for errors regarding the secondary slot.

         */

        if (rc != BOOT_EFLASH) {

            boot_prepare_image_for_update(state, &bs);

        }



        if (BOOT_IS_UPGRADE(BOOT_SWAP_TYPE(state))) {

            has_upgrade = true;
@@ -2355,19 +2344,17 @@ out: 
fih_ret

split_go(int loader_slot, int split_slot, void **entry)

{

    boot_sector_t *sectors;

    struct boot_sector_buffer *sectors;

    uintptr_t entry_val;

    int loader_flash_id;

    int split_flash_id;

    int rc;

    FIH_DECLARE(fih_rc, FIH_FAILURE);



    sectors = malloc(BOOT_MAX_IMG_SECTORS * 2 * sizeof *sectors);

    sectors = malloc(sizeof(struct boot_sector_buffer));

    if (sectors == NULL) {

        FIH_RET(FIH_FAILURE);

    }

    BOOT_IMG(&boot_data, loader_slot).sectors = sectors + 0;

    BOOT_IMG(&boot_data, split_slot).sectors = sectors + BOOT_MAX_IMG_SECTORS;



    loader_flash_id = flash_area_id_from_image_slot(loader_slot);

    rc = flash_area_open(loader_flash_id,
@@ -2379,7 +2366,7 @@ split_go(int loader_slot, int split_slot, void **entry) 
    assert(rc == 0);



    /* Determine the sector layout of the image slots and scratch area. */

    rc = boot_read_sectors(&boot_data);

    rc = boot_read_sectors(&boot_data, sectors);

    if (rc != 0) {

        rc = SPLIT_GO_ERR;

        goto done;

CRA Git | Maintained and supported by SUSTech CRA and CCSE