test/common/print.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (c) 2012, The Chromium Authors
   4  */
   5
   6 #include <command.h>
   7 #include <efi_api.h>
   8 #include <display_options.h>
   9 #include <log.h>
  10 #include <mapmem.h>
  11 #include <version_string.h>
  12 #include <stdio.h>
  13 #include <vsprintf.h>
  14 #include <test/common.h>
  15 #include <test/test.h>
  16 #include <test/ut.h>
  17
  18 #define BUF_SIZE        0x100
  19
  20 #define FAKE_BUILD_TAG  "jenkins-u-boot-denx_uboot_dm-master-build-aarch64" \
  21                         "and a lot more text to come"
  22
  23 #if CONFIG_IS_ENABLED(LIB_UUID)
  24 /* Test printing GUIDs */
  25 static int print_guid(struct unit_test_state *uts)
  26 {
  27         unsigned char guid[16] = {
  28                 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16
  29         };
  30         unsigned char guid_esp[16] = {
  31                 0x28, 0x73, 0x2a, 0xc1, 0x1f, 0xf8, 0xd2, 0x11,
  32                 0xBA, 0x4B, 0x00, 0xA0, 0xC9, 0x3E, 0xC9, 0x3B
  33         };
  34         char str[40];
  35         int ret;
  36
  37         sprintf(str, "%pUb", guid);
  38         ut_asserteq_str("01020304-0506-0708-090a-0b0c0d0e0f10", str);
  39         sprintf(str, "%pUB", guid);
  40         ut_asserteq_str("01020304-0506-0708-090A-0B0C0D0E0F10", str);
  41         sprintf(str, "%pUl", guid);
  42         ut_asserteq_str("04030201-0605-0807-090a-0b0c0d0e0f10", str);
  43         sprintf(str, "%pUs", guid);
  44         ut_asserteq_str("04030201-0605-0807-090a-0b0c0d0e0f10", str);
  45         sprintf(str, "%pUL", guid);
  46         ut_asserteq_str("04030201-0605-0807-090A-0B0C0D0E0F10", str);
  47         sprintf(str, "%pUs", guid_esp);
  48         if (IS_ENABLED(CONFIG_PARTITION_TYPE_GUID)) { /* brace needed */
  49                 ut_asserteq_str("system", str);
  50         } else {
  51                 ut_asserteq_str("c12a7328-f81f-11d2-ba4b-00a0c93ec93b", str);
  52         }
  53         ret = snprintf(str, 4, "%pUL", guid);
  54         ut_asserteq(0, str[3]);
  55         ut_asserteq(36, ret);
  56
  57         return 0;
  58 }
  59 COMMON_TEST(print_guid, 0);
  60 #endif
  61
  62 #if CONFIG_IS_ENABLED(EFI_LOADER) && !defined(API_BUILD)
  63 /* Test efi_loader specific printing */
  64 static int print_efi_ut(struct unit_test_state *uts)
  65 {
  66         char str[10];
  67         u8 buf[sizeof(struct efi_device_path_sd_mmc_path) +
  68                sizeof(struct efi_device_path)];
  69         u8 *pos = buf;
  70         struct efi_device_path *dp_end;
  71         struct efi_device_path_sd_mmc_path *dp_sd =
  72                         (struct efi_device_path_sd_mmc_path *)pos;
  73
  74         /* Create a device path for an SD card */
  75         dp_sd->dp.type = DEVICE_PATH_TYPE_MESSAGING_DEVICE;
  76         dp_sd->dp.sub_type = DEVICE_PATH_SUB_TYPE_MSG_SD;
  77         dp_sd->dp.length = sizeof(struct efi_device_path_sd_mmc_path);
  78         dp_sd->slot_number = 3;
  79         pos += sizeof(struct efi_device_path_sd_mmc_path);
  80         /* Append end node */
  81         dp_end = (struct efi_device_path *)pos;
  82         dp_end->type = DEVICE_PATH_TYPE_END;
  83         dp_end->sub_type = DEVICE_PATH_SUB_TYPE_END;
  84         dp_end->length = sizeof(struct efi_device_path);
  85
  86         snprintf(str, sizeof(str), "_%pD_", buf);
  87         ut_assertok(strcmp("_/SD(3)_", str));
  88
  89         /* NULL device path */
  90         snprintf(str, sizeof(str), "_%pD_", NULL);
  91         ut_assertok(strcmp("_<NULL>_", str));
  92
  93         return 0;
  94 }
  95 COMMON_TEST(print_efi_ut, 0);
  96 #endif
  97
  98 static int print_printf(struct unit_test_state *uts)
  99 {
 100         char big_str[400];
 101         int big_str_len;
 102         char str[10], *s;
 103         int len;
 104
 105         snprintf(str, sizeof(str), "testing");
 106         ut_assertok(strcmp("testing", str));
 107
 108         snprintf(str, sizeof(str), "testing but too long");
 109         ut_assertok(strcmp("testing b", str));
 110
 111         snprintf(str, 1, "testing none");
 112         ut_assertok(strcmp("", str));
 113
 114         *str = 'x';
 115         snprintf(str, 0, "testing none");
 116         ut_asserteq('x', *str);
 117
 118         if (CONFIG_IS_ENABLED(EFI_LOADER) || IS_ENABLED(CONFIG_EFI_APP)) {
 119                 sprintf(big_str, "_%ls_", u"foo");
 120                 ut_assertok(strcmp("_foo_", big_str));
 121         }
 122
 123         /* Test the banner function */
 124         s = display_options_get_banner(true, str, sizeof(str));
 125         ut_asserteq_ptr(str, s);
 126         ut_assertok(strcmp("\n\nU-Boo\n\n", s));
 127
 128         /* Assert that we do not overwrite memory before the buffer */
 129         str[0] = '`';
 130         s = display_options_get_banner(true, str + 1, 1);
 131         ut_asserteq_ptr(str + 1, s);
 132         ut_assertok(strcmp("`", str));
 133
 134         str[0] = '~';
 135         s = display_options_get_banner(true, str + 1, 2);
 136         ut_asserteq_ptr(str + 1, s);
 137         ut_assertok(strcmp("~\n", str));
 138
 139         /* The last two characters are set to \n\n for all buffer sizes > 2 */
 140         s = display_options_get_banner(false, str, sizeof(str));
 141         ut_asserteq_ptr(str, s);
 142         ut_assertok(strcmp("U-Boot \n\n", s));
 143
 144         /* Give it enough space for some of the version */
 145         big_str_len = strlen(version_string) - 5;
 146         s = display_options_get_banner_priv(false, FAKE_BUILD_TAG, big_str,
 147                                             big_str_len);
 148         ut_asserteq_ptr(big_str, s);
 149         ut_assertok(strncmp(version_string, s, big_str_len - 3));
 150         ut_assertok(strcmp("\n\n", s + big_str_len - 3));
 151
 152         /* Give it enough space for the version and some of the build tag */
 153         big_str_len = strlen(version_string) + 9 + 20;
 154         s = display_options_get_banner_priv(false, FAKE_BUILD_TAG, big_str,
 155                                             big_str_len);
 156         ut_asserteq_ptr(big_str, s);
 157         len = strlen(version_string);
 158         ut_assertok(strncmp(version_string, s, len));
 159         ut_assertok(strncmp(", Build: ", s + len, 9));
 160         ut_assertok(strncmp(FAKE_BUILD_TAG, s + 9 + len, 12));
 161         ut_assertok(strcmp("\n\n", s + big_str_len - 3));
 162
 163         return 0;
 164 }
 165 COMMON_TEST(print_printf, 0);
 166
 167 static int print_display_buffer(struct unit_test_state *uts)
 168 {
 169         u8 *buf;
 170         int i;
 171
 172         /* This test requires writable memory at zero */
 173         if (IS_ENABLED(CONFIG_X86))
 174                 return -EAGAIN;
 175
 176         buf = map_sysmem(0, BUF_SIZE);
 177         memset(buf, '\0', BUF_SIZE);
 178         for (i = 0; i < 0x11; i++)
 179                 buf[i] = i * 0x11;
 180
 181         /* bytes */
 182         print_buffer(0, buf, 1, 0x12, 0);
 183         ut_assert_nextline("00000000: 00 11 22 33 44 55 66 77 88 99 aa bb cc dd ee ff  ..\"3DUfw........");
 184         ut_assert_nextline("00000010: 10 00                                            ..");
 185         ut_assert_console_end();
 186
 187         /* line length */
 188         print_buffer(0, buf, 1, 0x12, 8);
 189         ut_assert_nextline("00000000: 00 11 22 33 44 55 66 77  ..\"3DUfw");
 190         ut_assert_nextline("00000008: 88 99 aa bb cc dd ee ff  ........");
 191         ut_assert_nextline("00000010: 10 00                    ..");
 192         ut_assert_console_end();
 193
 194         /* long line */
 195         buf[0x41] = 0x41;
 196         print_buffer(0, buf, 1, 0x42, 0x40);
 197         ut_assert_nextline("00000000: 00 11 22 33 44 55 66 77 88 99 aa bb cc dd ee ff 10 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ..\"3DUfw........................................................");
 198         ut_assert_nextline("00000040: 00 41                                                                                                                                                                                            .A");
 199         ut_assert_console_end();
 200
 201         /* address */
 202         print_buffer(0x12345678, buf, 1, 0x12, 0);
 203         ut_assert_nextline("12345678: 00 11 22 33 44 55 66 77 88 99 aa bb cc dd ee ff  ..\"3DUfw........");
 204         ut_assert_nextline("12345688: 10 00                                            ..");
 205         ut_assert_console_end();
 206
 207         /* 16-bit */
 208         print_buffer(0, buf, 2, 9, 0);
 209         ut_assert_nextline("00000000: 1100 3322 5544 7766 9988 bbaa ddcc ffee  ..\"3DUfw........");
 210         ut_assert_nextline("00000010: 0010                                     ..");
 211         ut_assert_console_end();
 212
 213         /* 32-bit */
 214         print_buffer(0, buf, 4, 5, 0);
 215         ut_assert_nextline("00000000: 33221100 77665544 bbaa9988 ffeeddcc  ..\"3DUfw........");
 216         ut_assert_nextline("00000010: 00000010                             ....");
 217         ut_assert_console_end();
 218
 219         /* 64-bit */
 220         print_buffer(0, buf, 8, 3, 0);
 221         ut_assert_nextline("00000000: 7766554433221100 ffeeddccbbaa9988  ..\"3DUfw........");
 222         ut_assert_nextline("00000010: 0000000000000010                   ........");
 223         ut_assert_console_end();
 224
 225         /* ASCII */
 226         buf[1] = 31;
 227         buf[2] = 32;
 228         buf[3] = 33;
 229         for (i = 0; i < 4; i++)
 230                 buf[4 + i] = 126 + i;
 231         buf[8] = 255;
 232         print_buffer(0, buf, 1, 10, 0);
 233         ut_assert_nextline("00000000: 00 1f 20 21 7e 7f 80 81 ff 99                    .. !~.....");
 234         ut_assert_console_end();
 235
 236         unmap_sysmem(buf);
 237
 238         return 0;
 239 }
 240 COMMON_TEST(print_display_buffer, UTF_CONSOLE);
 241
 242 static int print_hexdump_line(struct unit_test_state *uts)
 243 {
 244         u8 *linebuf;
 245         u8 *buf;
 246         int i;
 247
 248         buf = map_sysmem(0, BUF_SIZE);
 249         memset(buf, '\0', BUF_SIZE);
 250         for (i = 0; i < 0x11; i++)
 251                 buf[i] = i * 0x11;
 252
 253         /* Check buffer size calculations */
 254         linebuf = map_sysmem(0x400, BUF_SIZE);
 255         memset(linebuf, '\xff', BUF_SIZE);
 256         ut_asserteq(-ENOSPC, hexdump_line(0, buf, 1, 0x10, 0, linebuf, 75));
 257         ut_asserteq(0xff, linebuf[0]);
 258         ut_asserteq(0x10, hexdump_line(0, buf, 1, 0x10, 0, linebuf, 76));
 259         ut_asserteq('\0', linebuf[75]);
 260         ut_asserteq(0xff, linebuf[76]);
 261
 262         unmap_sysmem(buf);
 263
 264         return 0;
 265 }
 266 COMMON_TEST(print_hexdump_line, UTF_CONSOLE);
 267
 268 static int print_do_hex_dump(struct unit_test_state *uts)
 269 {
 270         u8 *buf;
 271         int i;
 272
 273         /* This test requires writable memory at zero */
 274         if (IS_ENABLED(CONFIG_X86))
 275                 return -EAGAIN;
 276
 277         buf = map_sysmem(0, BUF_SIZE);
 278         memset(buf, '\0', BUF_SIZE);
 279         for (i = 0; i < 0x11; i++)
 280                 buf[i] = i * 0x11;
 281
 282         /* bytes */
 283         print_hex_dump_bytes("", DUMP_PREFIX_ADDRESS, buf, 0x12);
 284         ut_assert_nextline("%0*lx: 00 11 22 33 44 55 66 77 88 99 aa bb cc dd ee ff  ..\"3DUfw........",
 285                            IS_ENABLED(CONFIG_PHYS_64BIT) ? 16 : 8, 0x0UL);
 286         ut_assert_nextline("%0*lx: 10 00                                            ..",
 287                            IS_ENABLED(CONFIG_PHYS_64BIT) ? 16 : 8, 0x10UL);
 288         ut_assert_console_end();
 289
 290         /* line length */
 291         print_hex_dump("", DUMP_PREFIX_ADDRESS, 8, 1, buf, 0x12, true);
 292         ut_assert_nextline("%0*lx: 00 11 22 33 44 55 66 77  ..\"3DUfw",
 293                            IS_ENABLED(CONFIG_PHYS_64BIT) ? 16 : 8, 0x0UL);
 294         ut_assert_nextline("%0*lx: 88 99 aa bb cc dd ee ff  ........",
 295                            IS_ENABLED(CONFIG_PHYS_64BIT) ? 16 : 8, 0x8UL);
 296         ut_assert_nextline("%0*lx: 10 00                    ..",
 297                            IS_ENABLED(CONFIG_PHYS_64BIT) ? 16 : 8, 0x10UL);
 298         ut_assert_console_end();
 299         unmap_sysmem(buf);
 300
 301         /* long line */
 302         buf[0x41] = 0x41;
 303         print_hex_dump("", DUMP_PREFIX_ADDRESS, 0x40, 1, buf, 0x42, true);
 304         ut_assert_nextline("%0*lx: 00 11 22 33 44 55 66 77 88 99 aa bb cc dd ee ff 10 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ..\"3DUfw........................................................",
 305                            IS_ENABLED(CONFIG_PHYS_64BIT) ? 16 : 8, 0x0UL);
 306         ut_assert_nextline("%0*lx: 00 41                                                                                                                                                                                            .A",
 307                            IS_ENABLED(CONFIG_PHYS_64BIT) ? 16 : 8, 0x40UL);
 308         ut_assert_console_end();
 309
 310         /* 16-bit */
 311         print_hex_dump("", DUMP_PREFIX_ADDRESS, 0, 2, buf, 0x12, true);
 312         ut_assert_nextline("%0*lx: 1100 3322 5544 7766 9988 bbaa ddcc ffee  ..\"3DUfw........",
 313                            IS_ENABLED(CONFIG_PHYS_64BIT) ? 16 : 8, 0x0UL);
 314         ut_assert_nextline("%0*lx: 0010                                     ..",
 315                            IS_ENABLED(CONFIG_PHYS_64BIT) ? 16 : 8, 0x10UL);
 316         ut_assert_console_end();
 317         unmap_sysmem(buf);
 318
 319         /* 32-bit */
 320         print_hex_dump("", DUMP_PREFIX_ADDRESS, 0, 4, buf, 0x14, true);
 321         ut_assert_nextline("%0*lx: 33221100 77665544 bbaa9988 ffeeddcc  ..\"3DUfw........",
 322                            IS_ENABLED(CONFIG_PHYS_64BIT) ? 16 : 8, 0x0UL);
 323         ut_assert_nextline("%0*lx: 00000010                             ....",
 324                            IS_ENABLED(CONFIG_PHYS_64BIT) ? 16 : 8, 0x10UL);
 325         ut_assert_console_end();
 326         unmap_sysmem(buf);
 327
 328         /* 64-bit */
 329         print_hex_dump("", DUMP_PREFIX_ADDRESS, 16, 8, buf, 0x18, true);
 330         ut_assert_nextline("%0*lx: 7766554433221100 ffeeddccbbaa9988  ..\"3DUfw........",
 331                            IS_ENABLED(CONFIG_PHYS_64BIT) ? 16 : 8, 0x0UL);
 332         ut_assert_nextline("%0*lx: 0000000000000010                   ........",
 333                            IS_ENABLED(CONFIG_PHYS_64BIT) ? 16 : 8, 0x10UL);
 334         ut_assert_console_end();
 335         unmap_sysmem(buf);
 336
 337         /* ASCII */
 338         buf[1] = 31;
 339         buf[2] = 32;
 340         buf[3] = 33;
 341         for (i = 0; i < 4; i++)
 342                 buf[4 + i] = 126 + i;
 343         buf[8] = 255;
 344         print_hex_dump("", DUMP_PREFIX_ADDRESS, 0, 1, buf, 10, true);
 345         ut_assert_nextline("%0*lx: 00 1f 20 21 7e 7f 80 81 ff 99                    .. !~.....",
 346                            IS_ENABLED(CONFIG_PHYS_64BIT) ? 16 : 8, 0x0UL);
 347         ut_assert_console_end();
 348         unmap_sysmem(buf);
 349
 350         return 0;
 351 }
 352 COMMON_TEST(print_do_hex_dump, UTF_CONSOLE);
 353
 354 static int snprint(struct unit_test_state *uts)
 355 {
 356         char buf[10] = "xxxxxxxxx";
 357         int ret;
 358
 359         ret = snprintf(buf, 5, "%d", 12345678);
 360         ut_asserteq_str("1234", buf);
 361         ut_asserteq(8, ret);
 362         ret = snprintf(buf, 5, "0x%x", 0x1234);
 363         ut_asserteq_str("0x12", buf);
 364         ut_asserteq(6, ret);
 365         ret = snprintf(buf, 5, "0x%08x", 0x1234);
 366         ut_asserteq_str("0x00", buf);
 367         ut_asserteq(10, ret);
 368         ret = snprintf(buf, 3, "%s", "abc");
 369         ut_asserteq_str("ab", buf);
 370         ut_asserteq(3, ret);
 371         ret = snprintf(buf, 4, "%s:%s", "abc", "def");
 372         ut_asserteq(0, buf[3]);
 373         ut_asserteq(7, ret);
 374         ret = snprintf(buf, 4, "%s:%d", "abc", 9999);
 375         ut_asserteq(8, ret);
 376         return 0;
 377 }
 378 COMMON_TEST(snprint, 0);