[PATCH] cmd: mbr: Allow 4 MBR partitions without need for extended

Simon Glass sjg at google.com
Sun Oct 8 01:10:02 CEST 2023


Hi Alexander,

On Fri, 6 Oct 2023 at 21:58, Alexander Gendin <agendin at matrox.com> wrote:
>
> Current code allows up to 3 MBR partitions without extended one.
> If more than 3 partitions are required, then extended partition(s)
> must be used.
> This commit allows up to 4 primary MBR partitions without the
> need for extended partition.
>
> Add mbr test unit. In order to use the test, mmc1.img file of size
> 12 MiB or greater is required in the same directory as u-boot.
> Running mbr test is only supported in sandbox mode.
>
> Signed-off-by: Alex Gendin <agendin at matrox.com>
> ---
>  disk/part_dos.c       |   2 +-
>  include/test/suites.h |   1 +
>  test/cmd/Makefile     |   1 +
>  test/cmd/mbr.c        | 440 ++++++++++++++++++++++++++++++++++++++++++
>  test/cmd_ut.c         |   4 +
>  5 files changed, 447 insertions(+), 1 deletion(-)
>  create mode 100644 test/cmd/mbr.c

This looks OK apart from one thing...also I have a few suggestions /
questions below.

>
> diff --git a/disk/part_dos.c b/disk/part_dos.c
> index 3337438437..567ead7511 100644
> --- a/disk/part_dos.c
> +++ b/disk/part_dos.c
> @@ -466,7 +466,7 @@ int layout_mbr_partitions(struct disk_partition *p, int count,
>                         ext = &p[i];
>         }
>
> -       if (count < 4)
> +       if (count <= 4)
>                 return 0;
>
>         if (!ext) {
> diff --git a/include/test/suites.h b/include/test/suites.h
> index 1c7dc65966..51acbe47b2 100644
> --- a/include/test/suites.h
> +++ b/include/test/suites.h
> @@ -45,6 +45,7 @@ int do_ut_font(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]);
>  int do_ut_lib(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]);
>  int do_ut_loadm(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]);
>  int do_ut_log(struct cmd_tbl *cmdtp, int flag, int argc, char * const argv[]);
> +int do_ut_mbr(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]);
>  int do_ut_mem(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]);
>  int do_ut_optee(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]);
>  int do_ut_overlay(struct cmd_tbl *cmdtp, int flag, int argc,
> diff --git a/test/cmd/Makefile b/test/cmd/Makefile
> index 6e3d7e919e..2f251e07b4 100644
> --- a/test/cmd/Makefile
> +++ b/test/cmd/Makefile
> @@ -23,6 +23,7 @@ obj-$(CONFIG_CMD_PINMUX) += pinmux.o
>  obj-$(CONFIG_CMD_PWM) += pwm.o
>  obj-$(CONFIG_CMD_SEAMA) += seama.o
>  ifdef CONFIG_SANDBOX
> +obj-$(CONFIG_CMD_MBR) += mbr.o
>  obj-$(CONFIG_CMD_READ) += rw.o
>  obj-$(CONFIG_CMD_SETEXPR) += setexpr.o
>  obj-$(CONFIG_ARM_FFA_TRANSPORT) += armffa.o
> diff --git a/test/cmd/mbr.c b/test/cmd/mbr.c
> new file mode 100644
> index 0000000000..bedcef0638
> --- /dev/null
> +++ b/test/cmd/mbr.c
> @@ -0,0 +1,440 @@
> +// SPDX-License-Identifier: GPL-2.0+
> +/*
> + * Tests for mbr command
> + *
> + * Copyright 2023 Matrox Video
> + * Written by Alex Gendin <agendin at matrox.com>
> + */
> +
> +#include <common.h>
> +#include <console.h>
> +#include <mapmem.h>
> +#include <part.h>
> +#include <asm/global_data.h>
> +#include <test/suites.h>
> +#include <test/ut.h>
> +
> +DECLARE_GLOBAL_DATA_PTR;
> +/*
> + * Test requirements:
> + * mmc1.img - File size needs to be at least 12 MiB
> + *
> + * Command to create mmc1.img:
> + * $ dd if=/dev/zero of=mmc1.img bs=12M count=1
> + *
> + * Place mmc1.img into the same directory as sandboxed u-boot
> + *
> + * To run this test manually:
> + * $ ./u-boot -Tc 'ut mbr'

These requirements need to be dealt with by a test script. You can set
up this device in test_ut_dm_init_bootstd(). You may need to create a
new mmc as the others are in use.

> + */
> +
> +static char * mbr_parts_header = "setenv mbr_parts '";
> +static char * mbr_parts_p1 = "uuid_disk=0x12345678;name=p1,start=8M,bootable,size=1M,id=0x0e";
> +static char * mbr_parts_p2 = ";name=p2,size=1M,id=0x0e";
> +static char * mbr_parts_p3 = ";name=p3,size=1M,id=0x0e";
> +static char * mbr_parts_p4 = ";name=p4,size=1M,id=0x0e";
> +static char * mbr_parts_p5 = ";name=[ext],size=2M,id=0x05;name=p5,size=1M,id=0x0e";
> +static char * mbr_parts_tail = "'";
> +
> +/*
> + * One MBR partition
> +000001b0  00 00 00 00 00 00 00 00  78 56 34 12 00 00 80 05  |........xV4.....|
> +000001c0  05 01 0e 25 24 01 00 40  00 00 00 08 00 00 00 00  |...%$.. at ........|
> +000001d0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
> +000001e0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
> +000001f0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 55 aa  |..............U.|
> +*/
> +static unsigned mbr_cmp_start = 0x1B8;
> +static unsigned mbr_cmp_size = 0x48;
> +static unsigned char mbr_parts_ref_p1[] = {
> +                                                0x78, 0x56, 0x34, 0x12, 0x00, 0x00, 0x80, 0x05,
> +0x05, 0x01, 0x0e, 0x25, 0x24, 0x01, 0x00, 0x40, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00,
> +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
> +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
> +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x55, 0xaa
> +};
> +
> +/*
> + * Two MBR partitions
> +000001b0  00 00 00 00 00 00 00 00  78 56 34 12 00 00 80 05  |........xV4.....|
> +000001c0  05 01 0e 25 24 01 00 40  00 00 00 08 00 00 00 25  |...%$.. at .......%|
> +000001d0  25 01 0e 46 05 01 00 48  00 00 00 08 00 00 00 00  |%..F...H........|
> +000001e0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
> +000001f0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 55 aa  |..............U.|
> +*/
> +static unsigned char mbr_parts_ref_p2[] = {
> +                                                0x78, 0x56, 0x34, 0x12, 0x00, 0x00, 0x80, 0x05,
> +0x05, 0x01, 0x0e, 0x25, 0x24, 0x01, 0x00, 0x40, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x25,
> +0x25, 0x01, 0x0e, 0x46, 0x05, 0x01, 0x00, 0x48, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00,
> +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
> +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x55, 0xaa
> +};
> +
> +/*
> + * Three MBR partitions
> +000001b0  00 00 00 00 00 00 00 00  78 56 34 12 00 00 80 05  |........xV4.....|
> +000001c0  05 01 0e 25 24 01 00 40  00 00 00 08 00 00 00 25  |...%$.. at .......%|
> +000001d0  25 01 0e 46 05 01 00 48  00 00 00 08 00 00 00 46  |%..F...H.......F|
> +000001e0  06 01 0e 66 25 01 00 50  00 00 00 08 00 00 00 00  |...f%..P........|
> +000001f0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 55 aa  |..............U.|
> +*/
> +static unsigned char mbr_parts_ref_p3[] = {
> +                                                0x78, 0x56, 0x34, 0x12, 0x00, 0x00, 0x80, 0x05,
> +0x05, 0x01, 0x0e, 0x25, 0x24, 0x01, 0x00, 0x40, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x25,
> +0x25, 0x01, 0x0e, 0x46, 0x05, 0x01, 0x00, 0x48, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x46,
> +0x06, 0x01, 0x0e, 0x66, 0x25, 0x01, 0x00, 0x50, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00,
> +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x55, 0xaa
> +};
> +
> +/*
> + * Four MBR partitions
> +000001b0  00 00 00 00 00 00 00 00  78 56 34 12 00 00 80 05  |........xV4.....|
> +000001c0  05 01 0e 25 24 01 00 40  00 00 00 08 00 00 00 25  |...%$.. at .......%|
> +000001d0  25 01 0e 46 05 01 00 48  00 00 00 08 00 00 00 46  |%..F...H.......F|
> +000001e0  06 01 0e 66 25 01 00 50  00 00 00 08 00 00 00 66  |...f%..P.......f|
> +000001f0  26 01 0e 87 06 01 00 58  00 00 00 08 00 00 55 aa  |&......X......U.|
> +*/
> +static unsigned char mbr_parts_ref_p4[] = {
> +                                                0x78, 0x56, 0x34, 0x12, 0x00, 0x00, 0x80, 0x05,
> +0x05, 0x01, 0x0e, 0x25, 0x24, 0x01, 0x00, 0x40, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x25,
> +0x25, 0x01, 0x0e, 0x46, 0x05, 0x01, 0x00, 0x48, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x46,
> +0x06, 0x01, 0x0e, 0x66, 0x25, 0x01, 0x00, 0x50, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x66,
> +0x26, 0x01, 0x0e, 0x87, 0x06, 0x01, 0x00, 0x58, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x55, 0xaa
> +};
> +
> +/*
> + * Five MBR partitions
> +000001b0  00 00 00 00 00 00 00 00  78 56 34 12 00 00 80 05  |........xV4.....|
> +000001c0  05 01 0e 25 24 01 00 40  00 00 00 08 00 00 00 25  |...%$.. at .......%|
> +000001d0  25 01 0e 46 05 01 00 48  00 00 00 08 00 00 00 46  |%..F...H.......F|
> +000001e0  06 01 0e 66 25 01 00 50  00 00 00 08 00 00 00 66  |...f%..P.......f|
> +000001f0  26 01 05 a7 26 01 00 58  00 00 00 10 00 00 55 aa  |&...&..X......U.|
> +*/
> +static unsigned char mbr_parts_ref_p5[] = {
> +                                                0x78, 0x56, 0x34, 0x12, 0x00, 0x00, 0x80, 0x05,
> +0x05, 0x01, 0x0e, 0x25, 0x24, 0x01, 0x00, 0x40, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x25,
> +0x25, 0x01, 0x0e, 0x46, 0x05, 0x01, 0x00, 0x48, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x46,
> +0x06, 0x01, 0x0e, 0x66, 0x25, 0x01, 0x00, 0x50, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x66,
> +0x26, 0x01, 0x05, 0xa7, 0x26, 0x01, 0x00, 0x58, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x55, 0xaa
> +};
> +static unsigned ebr_cmp_start = 0x1B8;
> +static unsigned ebr_cmp_size = 0x48;
> +/*
> + * EBR
> +00b001b0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 87  |................|
> +00b001c0  07 01 0e a7 26 01 00 08  00 00 00 08 00 00 00 00  |....&...........|
> +00b001d0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
> +00b001e0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
> +00b001f0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 55 aa  |..............U.|
> +*/
> +static unsigned char ebr_parts_ref_p5[] = {
> +                                                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x87,
> +0x07, 0x01, 0x0e, 0xa7, 0x26, 0x01, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00,
> +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
> +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
> +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x55, 0xaa
> +};

What do you think about creating these in code? E.g. have a function
which outputs the bytes for a partition and then call it 1 to 4 times?

> +
> +static void init_buffers(char *rb, size_t rb_size, char *mbr_wb, size_t mbr_wb_size,
> +                       char *ebr_wb, size_t ebr_wb_size, unsigned seed)

Needs a comment

> +{
> +       memset(rb, 0, rb_size);
> +       while (mbr_wb_size--) {
> +               *mbr_wb++ = seed;
> +               seed *= 43;
> +               seed += 17 + mbr_wb_size/4;
> +       }
> +       while (ebr_wb_size--) {
> +               *ebr_wb++ = seed;
> +               seed *= 43;
> +               seed += 17 + ebr_wb_size/4;
> +       }
> +}
> +
> +static unsigned build_mbr_parts(char *buf, size_t buf_size, unsigned num_parts)
> +{
> +       size_t bytes_remaining, cur_str_size;
> +       char * cur_buf;
> +
> +       if (0 == num_parts || 5 < num_parts || NULL == buf)
> +               return 1;

!num_parts
!buf

(we normally put the var before the value, so numparts >= 5)

> +
> +       cur_buf = buf;
> +       *cur_buf = '\0';
> +       bytes_remaining = buf_size;
> +
> +       cur_str_size = sizeof(mbr_parts_header);
> +       if (1 + cur_str_size > bytes_remaining)

Again, better to use cur_str_size + 1

> +               return 1;
> +       strcat(cur_buf, mbr_parts_header);
> +       bytes_remaining -= cur_str_size;
> +
> +       if (1 <= num_parts) {
> +               cur_str_size = sizeof(mbr_parts_p1);
> +               if (1 + cur_str_size > bytes_remaining)
> +                       return 1;
> +               strcat(cur_buf, mbr_parts_p1);
> +               bytes_remaining -= cur_str_size;
> +
> +               if (2 <= num_parts) {
> +                       cur_str_size = sizeof(mbr_parts_p2);
> +                       if (1 + cur_str_size > bytes_remaining)
> +                               return 1;
> +                       strcat(cur_buf, mbr_parts_p2);
> +                       bytes_remaining -= cur_str_size;
> +
> +                       if (3 <= num_parts) {
> +                               cur_str_size = sizeof(mbr_parts_p3);
> +                               if (1 + cur_str_size > bytes_remaining)
> +                                       return 1;
> +                               strcat(cur_buf, mbr_parts_p3);
> +                               bytes_remaining -= cur_str_size;
> +
> +                               if (4 == num_parts) {
> +                                       cur_str_size = sizeof(mbr_parts_p4);
> +                                       if (1 + cur_str_size > bytes_remaining)
> +                                               return 1;
> +                                       strcat(cur_buf, mbr_parts_p4);
> +                                       bytes_remaining -= cur_str_size;
> +
> +                               }
> +                       else if (5 == num_parts) {
> +                               cur_str_size = sizeof(mbr_parts_p5);
> +                               if (1 + cur_str_size > bytes_remaining)
> +                                       return 1;
> +                               strcat(cur_buf, mbr_parts_p5);
> +                               bytes_remaining -= cur_str_size;
> +
> +                       }
> +                       else if (5 < num_parts)
> +                               return 1;
> +                       }
> +               }
> +       }
> +
> +       cur_str_size = sizeof(mbr_parts_tail);
> +       if (1 + cur_str_size > bytes_remaining)
> +               return 1;
> +       strcat(cur_buf, mbr_parts_tail);
> +
> +       return 0;
> +}
> +
> +static int mbr_test_run(struct unit_test_state *uts)
> +{
> +       struct blk_desc *mmc_dev_desc;
> +       unsigned char mbr_wbuf[512], ebr_wbuf[512], rbuf[512];
> +       char mbr_parts_buf[256];
> +       ulong mbr_wa, ebr_wa, ra, ebr_blk, mbr_parts_max;
> +
> +       mbr_parts_max = 2 + sizeof('\0')
> +               + strlen(mbr_parts_header)
> +               + strlen(mbr_parts_p1)
> +               + strlen(mbr_parts_p2)
> +               + strlen(mbr_parts_p3)
> +               + strlen(mbr_parts_p4)
> +               + strlen(mbr_parts_p5)
> +               + strlen(mbr_parts_tail);
> +       ut_assertf(sizeof(mbr_parts_buf) >= mbr_parts_max, "Buffer avail: %ld; buffer req: %ld\n",
> +               sizeof(mbr_parts_buf), mbr_parts_max);
> +
> +       mbr_wa = map_to_sysmem(mbr_wbuf);
> +       ebr_wa = map_to_sysmem(ebr_wbuf);
> +       ra = map_to_sysmem(rbuf);
> +       ebr_blk = (ulong)0xB00000 / 0x200;
> +
> +       /* Make sure mmc1 exists */
> +       ut_asserteq(1, blk_get_device_by_str("mmc", "1", &mmc_dev_desc));
> +       ut_assertok(console_record_reset_enable());

You shouldn't need these

> +       ut_assertok(run_commandf("mmc dev 1"));
> +       ut_assert_nextline("switch to partitions #0, OK");
> +       ut_assert_nextline("mmc1 is current device");
> +       ut_assertok(ut_check_console_end(uts));
> +
> +       /* Make sure mmc1 is 12+ MiB in size */
> +       ut_assertok(run_commandf("mmc read 0x%lx 0x%lx 1", ra, (ulong)0xBFFE00 / 0x200));
> +
> +       /* Test one MBR partition */
> +       init_buffers(rbuf, sizeof(rbuf), mbr_wbuf, sizeof(mbr_wbuf), ebr_wbuf, sizeof(ebr_wbuf), __LINE__);
> +       ut_assertok(build_mbr_parts(mbr_parts_buf, sizeof(mbr_parts_buf), 1));
> +       ut_assertok(run_commandf("write mmc 1:0 0x%lx 0 1", mbr_wa));
> +       ut_assertok(run_commandf("read mmc 1:0 0x%lx 0 1", ra));
> +       ut_assertok(memcmp(mbr_wbuf, rbuf, 512));
> +       ut_assertok(run_commandf("write mmc 1:0 0x%lx 0x%lx 1", ebr_wa, ebr_blk));
> +       ut_assertok(run_commandf("read mmc 1:0 0x%lx 0x%lx 1", ra, ebr_blk));
> +       ut_assertok(memcmp(ebr_wbuf, rbuf, 512));
> +       ut_assertok(console_record_reset_enable());
> +       ut_assertf(0 == run_commandf(mbr_parts_buf), "Invalid partitions string: %s\n", mbr_parts_buf);
> +       ut_assertok(run_commandf("mbr write mmc 1"));
> +       ut_assert_nextline("MBR: write success!");
> +       ut_assertok(run_commandf("mbr verify mmc 1"));
> +       ut_assert_nextline("MBR: verify success!");
> +       ut_assertok(run_commandf("read mmc 1:0 0x%lx 0x%lx 1", ra, ebr_blk));
> +       ut_assertok(memcmp(ebr_wbuf, rbuf, 512));
> +       ut_assertok(ut_check_console_end(uts));
> +       /*
> +       000001b0  00 00 00 00 00 00 00 00  78 56 34 12 00 00 80 05  |........xV4.....|
> +       000001c0  05 01 0e 25 24 01 00 40  00 00 00 08 00 00 00 00  |...%$.. at ........|
> +       000001d0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
> +       000001e0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
> +       000001f0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 55 aa  |..............U.|
> +       */
> +       ut_assertok(run_commandf("read mmc 1:0 0x%lx 0 1", ra));
> +       for (unsigned i = 0; i < mbr_cmp_size; i++) {
> +               ut_assertf(rbuf[mbr_cmp_start + i] == mbr_parts_ref_p1[i],
> +                       "1P MBR+0x%04X: expected 0x%02X, actual: 0x%02X\n",
> +                       mbr_cmp_start + i, mbr_parts_ref_p1[i], rbuf[mbr_cmp_start + i]);
> +       }
> +
> +       /* Test two MBR partitions */
> +       init_buffers(rbuf, sizeof(rbuf), mbr_wbuf, sizeof(mbr_wbuf), ebr_wbuf, sizeof(ebr_wbuf), __LINE__);
> +       ut_assertok(build_mbr_parts(mbr_parts_buf, sizeof(mbr_parts_buf), 2));
> +       ut_assertok(run_commandf("write mmc 1:0 0x%lx 0 1", mbr_wa));
> +       ut_assertok(run_commandf("read mmc 1:0 0x%lx 0 1", ra));
> +       ut_assertok(memcmp(mbr_wbuf, rbuf, 512));
> +       ut_assertok(run_commandf("write mmc 1:0 0x%lx 0x%lx 1", ebr_wa, ebr_blk));
> +       ut_assertok(run_commandf("read mmc 1:0 0x%lx 0x%lx 1", ra, ebr_blk));
> +       ut_assertok(memcmp(ebr_wbuf, rbuf, 512));
> +       ut_assertok(console_record_reset_enable());
> +       ut_assertf(0 == run_commandf(mbr_parts_buf), "Invalid partitions string: %s\n", mbr_parts_buf);
> +       ut_assertok(run_commandf("mbr write mmc 1"));
> +       ut_assert_nextline("MBR: write success!");
> +       ut_assertok(run_commandf("mbr verify mmc 1"));
> +       ut_assert_nextline("MBR: verify success!");
> +       ut_assertok(run_commandf("read mmc 1:0 0x%lx 0x%lx 1", ra, ebr_blk));
> +       ut_assertok(memcmp(ebr_wbuf, rbuf, 512));
> +       ut_assertok(ut_check_console_end(uts));
> +       /*
> +       000001b0  00 00 00 00 00 00 00 00  78 56 34 12 00 00 80 05  |........xV4.....|
> +       000001c0  05 01 0e 25 24 01 00 40  00 00 00 08 00 00 00 25  |...%$.. at .......%|
> +       000001d0  25 01 0e 46 05 01 00 48  00 00 00 08 00 00 00 00  |%..F...H........|
> +       000001e0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
> +       000001f0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 55 aa  |..............U.|
> +       */
> +       ut_assertok(run_commandf("read mmc 1:0 0x%lx 0 1", ra));
> +       for (unsigned i = 0; i < mbr_cmp_size; i++) {
> +               ut_assertf(rbuf[mbr_cmp_start + i] == mbr_parts_ref_p2[i],
> +                       "2P MBR+0x%04X: expected 0x%02X, actual: 0x%02X\n",
> +                       mbr_cmp_start + i, mbr_parts_ref_p2[i], rbuf[mbr_cmp_start + i]);
> +       }
> +
> +       /* Test three MBR partitions */
> +       init_buffers(rbuf, sizeof(rbuf), mbr_wbuf, sizeof(mbr_wbuf), ebr_wbuf, sizeof(ebr_wbuf), __LINE__);
> +       ut_assertok(build_mbr_parts(mbr_parts_buf, sizeof(mbr_parts_buf), 3));
> +       ut_assertok(run_commandf("write mmc 1:0 0x%lx 0 1", mbr_wa));
> +       ut_assertok(run_commandf("read mmc 1:0 0x%lx 0 1", ra));
> +       ut_assertok(memcmp(mbr_wbuf, rbuf, 512));
> +       ut_assertok(run_commandf("write mmc 1:0 0x%lx 0x%lx 1", ebr_wa, ebr_blk));
> +       ut_assertok(run_commandf("read mmc 1:0 0x%lx 0x%lx 1", ra, ebr_blk));
> +       ut_assertok(memcmp(ebr_wbuf, rbuf, 512));
> +       ut_assertok(console_record_reset_enable());
> +       ut_assertf(0 == run_commandf(mbr_parts_buf), "Invalid partitions string: %s\n", mbr_parts_buf);
> +       ut_assertok(run_commandf("mbr write mmc 1"));
> +       ut_assert_nextline("MBR: write success!");
> +       ut_assertok(run_commandf("mbr verify mmc 1"));
> +       ut_assert_nextline("MBR: verify success!");
> +       ut_assertok(run_commandf("read mmc 1:0 0x%lx 0x%lx 1", ra, ebr_blk));
> +       ut_assertok(memcmp(ebr_wbuf, rbuf, 512));
> +       ut_assertok(ut_check_console_end(uts));
> +       /*
> +       000001b0  00 00 00 00 00 00 00 00  78 56 34 12 00 00 80 05  |........xV4.....|
> +       000001c0  05 01 0e 25 24 01 00 40  00 00 00 08 00 00 00 25  |...%$.. at .......%|
> +       000001d0  25 01 0e 46 05 01 00 48  00 00 00 08 00 00 00 46  |%..F...H.......F|
> +       000001e0  06 01 0e 66 25 01 00 50  00 00 00 08 00 00 00 00  |...f%..P........|
> +       000001f0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 55 aa  |..............U.|
> +       */
> +       ut_assertok(run_commandf("read mmc 1:0 0x%lx 0 1", ra));
> +       for (unsigned i = 0; i < mbr_cmp_size; i++) {
> +               ut_assertf(rbuf[mbr_cmp_start + i] == mbr_parts_ref_p3[i],
> +                       "3P MBR+0x%04X: expected 0x%02X, actual: 0x%02X\n",
> +                       mbr_cmp_start + i, mbr_parts_ref_p3[i], rbuf[mbr_cmp_start + i]);
> +       }
> +
> +       /* Test four MBR partitions */
> +       init_buffers(rbuf, sizeof(rbuf), mbr_wbuf, sizeof(mbr_wbuf), ebr_wbuf, sizeof(ebr_wbuf), __LINE__);
> +       ut_assertok(build_mbr_parts(mbr_parts_buf, sizeof(mbr_parts_buf), 4));
> +       ut_assertok(run_commandf("write mmc 1:0 0x%lx 0 1", mbr_wa));
> +       ut_assertok(run_commandf("read mmc 1:0 0x%lx 0 1", ra));
> +       ut_assertok(memcmp(mbr_wbuf, rbuf, 512));
> +       ut_assertok(run_commandf("write mmc 1:0 0x%lx 0x%lx 1", ebr_wa, ebr_blk));
> +       ut_assertok(run_commandf("read mmc 1:0 0x%lx 0x%lx 1", ra, ebr_blk));
> +       ut_assertok(memcmp(ebr_wbuf, rbuf, 512));
> +       ut_assertok(console_record_reset_enable());
> +       ut_assertf(0 == run_commandf(mbr_parts_buf), "Invalid partitions string: %s\n", mbr_parts_buf);
> +       ut_assertok(run_commandf("mbr write mmc 1"));
> +       ut_assert_nextline("MBR: write success!");
> +       ut_assertok(run_commandf("mbr verify mmc 1"));
> +       ut_assert_nextline("MBR: verify success!");
> +       ut_assertok(run_commandf("read mmc 1:0 0x%lx 0x%lx 1", ra, ebr_blk));
> +       ut_assertok(memcmp(ebr_wbuf, rbuf, 512));
> +       ut_assertok(ut_check_console_end(uts));
> +       /*
> +       000001b0  00 00 00 00 00 00 00 00  78 56 34 12 00 00 80 05  |........xV4.....|
> +       000001c0  05 01 0e 25 24 01 00 40  00 00 00 08 00 00 00 25  |...%$.. at .......%|
> +       000001d0  25 01 0e 46 05 01 00 48  00 00 00 08 00 00 00 46  |%..F...H.......F|
> +       000001e0  06 01 0e 66 25 01 00 50  00 00 00 08 00 00 00 66  |...f%..P.......f|
> +       000001f0  26 01 0e 87 06 01 00 58  00 00 00 08 00 00 55 aa  |&......X......U.|
> +       */
> +       ut_assertok(run_commandf("read mmc 1:0 0x%lx 0 1", ra));
> +       for (unsigned i = 0; i < mbr_cmp_size; i++) {
> +               ut_assertf(rbuf[mbr_cmp_start + i] == mbr_parts_ref_p4[i],
> +                       "4P MBR+0x%04X: expected 0x%02X, actual: 0x%02X\n",
> +                       mbr_cmp_start + i, mbr_parts_ref_p4[i], rbuf[mbr_cmp_start + i]);
> +       }
> +
> +       /* Test five MBR partitions */
> +       init_buffers(rbuf, sizeof(rbuf), mbr_wbuf, sizeof(mbr_wbuf), ebr_wbuf, sizeof(ebr_wbuf), __LINE__);
> +       ut_assertok(build_mbr_parts(mbr_parts_buf, sizeof(mbr_parts_buf), 5));
> +       ut_assertok(run_commandf("write mmc 1:0 0x%lx 0 1", mbr_wa));
> +       ut_assertok(run_commandf("read mmc 1:0 0x%lx 0 1", ra));
> +       ut_assertok(memcmp(mbr_wbuf, rbuf, 512));
> +       ut_assertok(run_commandf("write mmc 1:0 0x%lx 0x%lx 1", ebr_wa, ebr_blk));
> +       ut_assertok(run_commandf("read mmc 1:0 0x%lx 0x%lx 1", ra, ebr_blk));
> +       ut_assertok(memcmp(ebr_wbuf, rbuf, 512));
> +       ut_assertok(console_record_reset_enable());
> +       ut_assertf(0 == run_commandf(mbr_parts_buf), "Invalid partitions string: %s\n", mbr_parts_buf);
> +       ut_assertf(0 == run_commandf("mbr write mmc 1"), "Invalid partitions string: %s\n", mbr_parts_buf);
> +       ut_assert_nextline("MBR: write success!");
> +       ut_assertok(run_commandf("mbr verify mmc 1"));
> +       ut_assert_nextline("MBR: verify success!");
> +       ut_assertok(ut_check_console_end(uts));
> +       /*
> +       000001b0  00 00 00 00 00 00 00 00  78 56 34 12 00 00 80 05  |........xV4.....|
> +       000001c0  05 01 0e 25 24 01 00 40  00 00 00 08 00 00 00 25  |...%$.. at .......%|
> +       000001d0  25 01 0e 46 05 01 00 48  00 00 00 08 00 00 00 46  |%..F...H.......F|
> +       000001e0  06 01 0e 66 25 01 00 50  00 00 00 08 00 00 00 66  |...f%..P.......f|
> +       000001f0  26 01 05 a7 26 01 00 58  00 00 00 10 00 00 55 aa  |&...&..X......U.|
> +       */
> +       ut_assertok(run_commandf("read mmc 1:0 0x%lx 0 1", ra));
> +       for (unsigned i = 0; i < mbr_cmp_size; i++) {
> +               ut_assertf(rbuf[mbr_cmp_start + i] == mbr_parts_ref_p5[i],
> +                       "5P MBR+0x%04X: expected 0x%02X, actual: 0x%02X\n",
> +                       mbr_cmp_start + i, mbr_parts_ref_p5[i], rbuf[mbr_cmp_start + i]);
> +       }
> +       /*
> +       00b001b0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 87  |................|
> +       00b001c0  07 01 0e a7 26 01 00 08  00 00 00 08 00 00 00 00  |....&...........|
> +       00b001d0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
> +       00b001e0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
> +       00b001f0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 55 aa  |..............U.|
> +       */
> +       ut_assertok(run_commandf("read mmc 1:0 0x%lx 0x%lx 1", ra, ebr_blk));
> +       for (unsigned i = 0; i < ebr_cmp_size; i++) {
> +               ut_assertf(rbuf[ebr_cmp_start + i] == ebr_parts_ref_p5[i],
> +                       "5P EBR+0x%04X: expected 0x%02X, actual: 0x%02X\n",
> +                       ebr_cmp_start + i, ebr_parts_ref_p5[i], rbuf[ebr_cmp_start + i]);
> +       }
> +
> +       return 0;
> +}
> +
> +/* Declare mbr test */
> +UNIT_TEST(mbr_test_run, UT_TESTF_CONSOLE_REC, mbr_test);
> +
> +int do_ut_mbr(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
> +{
> +       struct unit_test *tests = UNIT_TEST_SUITE_START(mbr_test);
> +       const int n_ents = UNIT_TEST_SUITE_COUNT(mbr_test);
> +
> +       return cmd_ut_category("mbr", "mbr_test_", tests, n_ents, argc, argv);
> +}
> diff --git a/test/cmd_ut.c b/test/cmd_ut.c
> index 0f56409e80..123db7cc7d 100644
> --- a/test/cmd_ut.c
> +++ b/test/cmd_ut.c
> @@ -86,6 +86,10 @@ static struct cmd_tbl cmd_ut_sub[] = {
>  #endif
>  #ifdef CONFIG_UT_LOG
>         U_BOOT_CMD_MKENT(log, CONFIG_SYS_MAXARGS, 1, do_ut_log, "", ""),
> +#endif
> +#if defined(CONFIG_SANDBOX) && defined(CONFIG_CMD_MBR) && defined(CONFIG_CMD_MMC) \
> +        && defined(CONFIG_MMC_SANDBOX) && defined(CONFIG_MMC_WRITE)
> +       U_BOOT_CMD_MKENT(mbr, CONFIG_SYS_MAXARGS, 1, do_ut_mbr, "", ""),
>  #endif
>         U_BOOT_CMD_MKENT(mem, CONFIG_SYS_MAXARGS, 1, do_ut_mem, "", ""),
>  #if defined(CONFIG_SANDBOX) && defined(CONFIG_CMD_SETEXPR)
> --
> 2.41.0

Regards,
Simon


More information about the U-Boot mailing list