test/bloblist.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (c) 2018, Google Inc. All rights reserved.
   4  */
   5
   6 #include <common.h>
   7 #include <bloblist.h>
   8 #include <log.h>
   9 #include <mapmem.h>
  10 #include <asm/state.h>
  11 #include <test/suites.h>
  12 #include <test/test.h>
  13 #include <test/ut.h>
  14
  15 DECLARE_GLOBAL_DATA_PTR;
  16
  17 /* Declare a new compression test */
  18 #define BLOBLIST_TEST(_name, _flags) \
  19                 UNIT_TEST(_name, _flags, bloblist_test)
  20
  21 enum {
  22         TEST_TAG                = 1,
  23         TEST_TAG2               = 2,
  24         TEST_TAG_MISSING        = 3,
  25
  26         TEST_SIZE               = 10,
  27         TEST_SIZE2              = 20,
  28         TEST_SIZE_LARGE         = 0x3e0,
  29
  30         TEST_ADDR               = CONFIG_BLOBLIST_ADDR,
  31         TEST_BLOBLIST_SIZE      = 0x400,
  32
  33         ERASE_BYTE              = '\xff',
  34 };
  35
  36 static struct bloblist_hdr *clear_bloblist(void)
  37 {
  38         struct bloblist_hdr *hdr;
  39
  40         /*
  41          * Clear out any existing bloblist so we have a clean slate. Zero the
  42          * header so that existing records are removed, but set everything else
  43          * to 0xff for testing purposes.
  44          */
  45         hdr = map_sysmem(CONFIG_BLOBLIST_ADDR, TEST_BLOBLIST_SIZE);
  46         memset(hdr, ERASE_BYTE, TEST_BLOBLIST_SIZE);
  47         memset(hdr, '\0', sizeof(*hdr));
  48
  49         return hdr;
  50 }
  51
  52 static int check_zero(void *data, int size)
  53 {
  54         u8 *ptr;
  55         int i;
  56
  57         for (ptr = data, i = 0; i < size; i++, ptr++) {
  58                 if (*ptr)
  59                         return -EINVAL;
  60         }
  61
  62         return 0;
  63 }
  64
  65 static int bloblist_test_init(struct unit_test_state *uts)
  66 {
  67         struct bloblist_hdr *hdr;
  68
  69         hdr = clear_bloblist();
  70         ut_asserteq(-ENOENT, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
  71         ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0));
  72         hdr->version++;
  73         ut_asserteq(-EPROTONOSUPPORT, bloblist_check(TEST_ADDR,
  74                                                      TEST_BLOBLIST_SIZE));
  75
  76         ut_asserteq(-ENOSPC, bloblist_new(TEST_ADDR, 0x10, 0));
  77         ut_asserteq(-EFAULT, bloblist_new(1, TEST_BLOBLIST_SIZE, 0));
  78         ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0));
  79
  80         ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
  81         ut_assertok(bloblist_finish());
  82         ut_assertok(bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
  83         hdr->flags++;
  84         ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
  85
  86         return 1;
  87 }
  88 BLOBLIST_TEST(bloblist_test_init, 0);
  89
  90 static int bloblist_test_blob(struct unit_test_state *uts)
  91 {
  92         struct bloblist_hdr *hdr;
  93         struct bloblist_rec *rec, *rec2;
  94         char *data;
  95
  96         /* At the start there should be no records */
  97         hdr = clear_bloblist();
  98         ut_assertnull(bloblist_find(TEST_TAG, TEST_BLOBLIST_SIZE));
  99         ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0));
 100         ut_asserteq(map_to_sysmem(hdr), TEST_ADDR);
 101
 102         /* Add a record and check that we can find it */
 103         data = bloblist_add(TEST_TAG, TEST_SIZE, 0);
 104         rec = (void *)(hdr + 1);
 105         ut_asserteq_addr(rec + 1, data);
 106         data = bloblist_find(TEST_TAG, TEST_SIZE);
 107         ut_asserteq_addr(rec + 1, data);
 108
 109         /* Check the data is zeroed */
 110         ut_assertok(check_zero(data, TEST_SIZE));
 111
 112         /* Check the 'ensure' method */
 113         ut_asserteq_addr(data, bloblist_ensure(TEST_TAG, TEST_SIZE));
 114         ut_assertnull(bloblist_ensure(TEST_TAG, TEST_SIZE2));
 115         rec2 = (struct bloblist_rec *)(data + ALIGN(TEST_SIZE, BLOBLIST_ALIGN));
 116         ut_assertok(check_zero(data, TEST_SIZE));
 117
 118         /* Check for a non-existent record */
 119         ut_asserteq_addr(data, bloblist_ensure(TEST_TAG, TEST_SIZE));
 120         ut_asserteq_addr(rec2 + 1, bloblist_ensure(TEST_TAG2, TEST_SIZE2));
 121         ut_assertnull(bloblist_find(TEST_TAG_MISSING, 0));
 122
 123         return 0;
 124 }
 125 BLOBLIST_TEST(bloblist_test_blob, 0);
 126
 127 /* Check bloblist_ensure_size_ret() */
 128 static int bloblist_test_blob_ensure(struct unit_test_state *uts)
 129 {
 130         void *data, *data2;
 131         int size;
 132
 133         /* At the start there should be no records */
 134         clear_bloblist();
 135         ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0));
 136
 137         /* Test with an empty bloblist */
 138         size = TEST_SIZE;
 139         ut_assertok(bloblist_ensure_size_ret(TEST_TAG, &size, &data));
 140         ut_asserteq(TEST_SIZE, size);
 141         ut_assertok(check_zero(data, TEST_SIZE));
 142
 143         /* Check that we get the same thing again */
 144         ut_assertok(bloblist_ensure_size_ret(TEST_TAG, &size, &data2));
 145         ut_asserteq(TEST_SIZE, size);
 146         ut_asserteq_addr(data, data2);
 147
 148         /* Check that the size remains the same */
 149         size = TEST_SIZE2;
 150         ut_assertok(bloblist_ensure_size_ret(TEST_TAG, &size, &data));
 151         ut_asserteq(TEST_SIZE, size);
 152
 153         /* Check running out of space */
 154         size = TEST_SIZE_LARGE;
 155         ut_asserteq(-ENOSPC, bloblist_ensure_size_ret(TEST_TAG2, &size, &data));
 156
 157         return 0;
 158 }
 159 BLOBLIST_TEST(bloblist_test_blob_ensure, 0);
 160
 161 static int bloblist_test_bad_blob(struct unit_test_state *uts)
 162 {
 163         struct bloblist_hdr *hdr;
 164         void *data;
 165
 166         hdr = clear_bloblist();
 167         ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0));
 168         data = hdr + 1;
 169         data += sizeof(struct bloblist_rec);
 170         ut_asserteq_addr(data, bloblist_ensure(TEST_TAG, TEST_SIZE));
 171         ut_asserteq_addr(data, bloblist_ensure(TEST_TAG, TEST_SIZE));
 172
 173         return 0;
 174 }
 175 BLOBLIST_TEST(bloblist_test_bad_blob, 0);
 176
 177 static int bloblist_test_checksum(struct unit_test_state *uts)
 178 {
 179         struct bloblist_hdr *hdr;
 180         char *data, *data2;
 181
 182         hdr = clear_bloblist();
 183         ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0));
 184         ut_assertok(bloblist_finish());
 185         ut_assertok(bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
 186
 187         /*
 188          * Now change things amd make sure that the checksum notices. We cannot
 189          * change the size or alloced fields, since that will crash the code.
 190          * It has to rely on these being correct.
 191          */
 192         hdr->flags--;
 193         ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
 194         hdr->flags++;
 195
 196         hdr->size--;
 197         ut_asserteq(-EFBIG, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
 198         hdr->size++;
 199
 200         hdr->spare++;
 201         ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
 202         hdr->spare--;
 203
 204         hdr->chksum++;
 205         ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
 206         hdr->chksum--;
 207
 208         /* Make sure the checksum changes when we add blobs */
 209         data = bloblist_add(TEST_TAG, TEST_SIZE, 0);
 210         ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
 211
 212         data2 = bloblist_add(TEST_TAG2, TEST_SIZE2, 0);
 213         ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
 214         ut_assertok(bloblist_finish());
 215
 216         /* It should also change if we change the data */
 217         ut_assertok(bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
 218         *data += 1;
 219         ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
 220         *data -= 1;
 221
 222         ut_assertok(bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
 223         *data2 += 1;
 224         ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
 225         *data2 -= 1;
 226
 227         /*
 228          * Changing data outside the range of valid data should not affect
 229          * the checksum.
 230          */
 231         ut_assertok(bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
 232         data[TEST_SIZE]++;
 233         data2[TEST_SIZE2]++;
 234         ut_assertok(bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
 235
 236         return 0;
 237 }
 238 BLOBLIST_TEST(bloblist_test_checksum, 0);
 239
 240 /* Test the 'bloblist info' command */
 241 static int bloblist_test_cmd_info(struct unit_test_state *uts)
 242 {
 243         struct sandbox_state *state = state_get_current();
 244         struct bloblist_hdr *hdr;
 245         char *data, *data2;
 246
 247         hdr = clear_bloblist();
 248         ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0));
 249         data = bloblist_ensure(TEST_TAG, TEST_SIZE);
 250         data2 = bloblist_ensure(TEST_TAG2, TEST_SIZE2);
 251
 252         console_record_reset_enable();
 253         if (!state->show_test_output)
 254                 gd->flags |= GD_FLG_SILENT;
 255         console_record_reset();
 256         run_command("bloblist info", 0);
 257         ut_assert_nextline("base:     %lx", (ulong)map_to_sysmem(hdr));
 258         ut_assert_nextline("size:     400    1 KiB");
 259         ut_assert_nextline("alloced:  70     112 Bytes");
 260         ut_assert_nextline("free:     390    912 Bytes");
 261         ut_assert_console_end();
 262         gd->flags &= ~(GD_FLG_SILENT | GD_FLG_RECORD);
 263
 264         return 0;
 265 }
 266 BLOBLIST_TEST(bloblist_test_cmd_info, 0);
 267
 268 /* Test the 'bloblist list' command */
 269 static int bloblist_test_cmd_list(struct unit_test_state *uts)
 270 {
 271         struct sandbox_state *state = state_get_current();
 272         struct bloblist_hdr *hdr;
 273         char *data, *data2;
 274
 275         hdr = clear_bloblist();
 276         ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0));
 277         data = bloblist_ensure(TEST_TAG, TEST_SIZE);
 278         data2 = bloblist_ensure(TEST_TAG2, TEST_SIZE2);
 279
 280         console_record_reset_enable();
 281         if (!state->show_test_output)
 282                 gd->flags |= GD_FLG_SILENT;
 283         console_record_reset();
 284         run_command("bloblist list", 0);
 285         ut_assert_nextline("Address       Size  Tag Name");
 286         ut_assert_nextline("%08lx  %8x    1 EC host event",
 287                            (ulong)map_to_sysmem(data), TEST_SIZE);
 288         ut_assert_nextline("%08lx  %8x    2 SPL hand-off",
 289                            (ulong)map_to_sysmem(data2), TEST_SIZE2);
 290         ut_assert_console_end();
 291         gd->flags &= ~(GD_FLG_SILENT | GD_FLG_RECORD);
 292
 293         return 0;
 294 }
 295 BLOBLIST_TEST(bloblist_test_cmd_list, 0);
 296
 297 /* Test alignment of bloblist blobs */
 298 static int bloblist_test_align(struct unit_test_state *uts)
 299 {
 300         struct bloblist_hdr *hdr;
 301         ulong addr;
 302         char *data;
 303         int i;
 304
 305         /* At the start there should be no records */
 306         hdr = clear_bloblist();
 307         ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0));
 308         ut_assertnull(bloblist_find(TEST_TAG, TEST_BLOBLIST_SIZE));
 309
 310         /* Check the default alignment */
 311         for (i = 0; i < 3; i++) {
 312                 int size = i * 3;
 313                 ulong addr;
 314                 char *data;
 315                 int j;
 316
 317                 data = bloblist_add(i, size, 0);
 318                 ut_assertnonnull(data);
 319                 addr = map_to_sysmem(data);
 320                 ut_asserteq(0, addr & (BLOBLIST_ALIGN - 1));
 321
 322                 /* Only the bytes in the blob data should be zeroed */
 323                 for (j = 0; j < size; j++)
 324                         ut_asserteq(0, data[j]);
 325                 for (; j < BLOBLIST_ALIGN; j++)
 326                         ut_asserteq(ERASE_BYTE, data[j]);
 327         }
 328
 329         /* Check larger alignment */
 330         for (i = 0; i < 3; i++) {
 331                 int align = 32 << i;
 332
 333                 data = bloblist_add(3 + i, i * 4, align);
 334                 ut_assertnonnull(data);
 335                 addr = map_to_sysmem(data);
 336                 ut_asserteq(0, addr & (align - 1));
 337         }
 338
 339         /* Check alignment with an bloblist starting on a smaller alignment */
 340         hdr = map_sysmem(TEST_ADDR + BLOBLIST_ALIGN, TEST_BLOBLIST_SIZE);
 341         memset(hdr, ERASE_BYTE, TEST_BLOBLIST_SIZE);
 342         memset(hdr, '\0', sizeof(*hdr));
 343         ut_assertok(bloblist_new(TEST_ADDR + BLOBLIST_ALIGN, TEST_BLOBLIST_SIZE,
 344                                  0));
 345
 346         data = bloblist_add(1, 5, BLOBLIST_ALIGN * 2);
 347         ut_assertnonnull(data);
 348         addr = map_to_sysmem(data);
 349         ut_asserteq(0, addr & (BLOBLIST_ALIGN * 2 - 1));
 350
 351         return 0;
 352 }
 353 BLOBLIST_TEST(bloblist_test_align, 0);
 354
 355 int do_ut_bloblist(struct cmd_tbl *cmdtp, int flag, int argc,
 356                    char *const argv[])
 357 {
 358         struct unit_test *tests = ll_entry_start(struct unit_test,
 359                                                  bloblist_test);
 360         const int n_ents = ll_entry_count(struct unit_test, bloblist_test);
 361
 362         return cmd_ut_category("bloblist", "bloblist_test_",
 363                                tests, n_ents, argc, argv);
 364 }