LXR uboot/test/bootm.c

   1// SPDX-License-Identifier: GPL-2.0+
   2/*
   3 * Tests for bootm routines
   4 *
   5 * Copyright 2020 Google LLC
   6 */
   7
   8#include <common.h>
   9#include <bootm.h>
  10#include <asm/global_data.h>
  11#include <test/suites.h>
  12#include <test/test.h>
  13#include <test/ut.h>
  14
  15DECLARE_GLOBAL_DATA_PTR;
  16
  17#define BOOTM_TEST(_name, _flags)       UNIT_TEST(_name, _flags, bootm_test)
  18
  19enum {
  20        BUF_SIZE        = 1024,
  21};
  22
  23#define CONSOLE_STR     "console=/dev/ttyS0"
  24
  25/* Test cmdline processing where nothing happens */
  26static int bootm_test_nop(struct unit_test_state *uts)
  27{
  28        char buf[BUF_SIZE];
  29
  30        *buf = '\0';
  31        ut_assertok(bootm_process_cmdline(buf, BUF_SIZE, true));
  32        ut_asserteq_str("", buf);
  33
  34        strcpy(buf, "test");
  35        ut_assertok(bootm_process_cmdline(buf, BUF_SIZE, true));
  36        ut_asserteq_str("test", buf);
  37
  38        return 0;
  39}
  40BOOTM_TEST(bootm_test_nop, 0);
  41
  42/* Test cmdline processing when out of space */
  43static int bootm_test_nospace(struct unit_test_state *uts)
  44{
  45        char buf[BUF_SIZE];
  46
  47        /* Zero buffer size */
  48        *buf = '\0';
  49        ut_asserteq(-ENOSPC, bootm_process_cmdline(buf, 0, true));
  50
  51        /* Buffer string not terminated */
  52        memset(buf, 'a', BUF_SIZE);
  53        ut_asserteq(-ENOSPC, bootm_process_cmdline(buf, BUF_SIZE, true));
  54
  55        /* Not enough space to copy string */
  56        memset(buf, '\0', BUF_SIZE);
  57        memset(buf, 'a', BUF_SIZE / 2);
  58        ut_asserteq(-ENOSPC, bootm_process_cmdline(buf, BUF_SIZE, true));
  59
  60        /* Just enough space */
  61        memset(buf, '\0', BUF_SIZE);
  62        memset(buf, 'a', BUF_SIZE / 2 - 1);
  63        ut_assertok(bootm_process_cmdline(buf, BUF_SIZE, true));
  64
  65        return 0;
  66}
  67BOOTM_TEST(bootm_test_nospace, 0);
  68
  69/* Test silent processing */
  70static int bootm_test_silent(struct unit_test_state *uts)
  71{
  72        char buf[BUF_SIZE];
  73
  74        /* 'silent_linux' not set should do nothing */
  75        env_set("silent_linux", NULL);
  76        strcpy(buf, CONSOLE_STR);
  77        ut_assertok(bootm_process_cmdline(buf, BUF_SIZE, BOOTM_CL_SILENT));
  78        ut_asserteq_str(CONSOLE_STR, buf);
  79
  80        ut_assertok(env_set("silent_linux", "no"));
  81        ut_assertok(bootm_process_cmdline(buf, BUF_SIZE, BOOTM_CL_SILENT));
  82        ut_asserteq_str(CONSOLE_STR, buf);
  83
  84        ut_assertok(env_set("silent_linux", "yes"));
  85        ut_assertok(bootm_process_cmdline(buf, BUF_SIZE, BOOTM_CL_SILENT));
  86        ut_asserteq_str("console=", buf);
  87
  88        /* Empty buffer should still add the string */
  89        *buf = '\0';
  90        ut_assertok(bootm_process_cmdline(buf, BUF_SIZE, BOOTM_CL_SILENT));
  91        ut_asserteq_str("console=", buf);
  92
  93        /* Check nothing happens when do_silent is false */
  94        *buf = '\0';
  95        ut_assertok(bootm_process_cmdline(buf, BUF_SIZE, 0));
  96        ut_asserteq_str("", buf);
  97
  98        /* Not enough space */
  99        *buf = '\0';
 100        ut_asserteq(-ENOSPC, bootm_process_cmdline(buf, 8, BOOTM_CL_SILENT));
 101
 102        /* Just enough space */
 103        *buf = '\0';
 104        ut_assertok(bootm_process_cmdline(buf, 9, BOOTM_CL_SILENT));
 105
 106        /* add at end */
 107        strcpy(buf, "something");
 108        ut_assertok(bootm_process_cmdline(buf, BUF_SIZE, BOOTM_CL_SILENT));
 109        ut_asserteq_str("something console=", buf);
 110
 111        /* change at start */
 112        strcpy(buf, CONSOLE_STR " something");
 113        ut_assertok(bootm_process_cmdline(buf, BUF_SIZE, BOOTM_CL_SILENT));
 114        ut_asserteq_str("console= something", buf);
 115
 116        return 0;
 117}
 118BOOTM_TEST(bootm_test_silent, 0);
 119
 120/* Test substitution processing */
 121static int bootm_test_subst(struct unit_test_state *uts)
 122{
 123        char buf[BUF_SIZE];
 124
 125        /* try with an unset variable */
 126        ut_assertok(env_set("var", NULL));
 127        strcpy(buf, "some${var}thing");
 128        ut_assertok(bootm_process_cmdline(buf, BUF_SIZE, BOOTM_CL_SUBST));
 129        ut_asserteq_str("something", buf);
 130
 131        /* Replace with shorter string */
 132        ut_assertok(env_set("var", "bb"));
 133        strcpy(buf, "some${var}thing");
 134        ut_assertok(bootm_process_cmdline(buf, BUF_SIZE, BOOTM_CL_SUBST));
 135        ut_asserteq_str("somebbthing", buf);
 136
 137        /* Replace with same-length string */
 138        ut_assertok(env_set("var", "abc"));
 139        strcpy(buf, "some${var}thing");
 140        ut_assertok(bootm_process_cmdline(buf, BUF_SIZE, BOOTM_CL_SUBST));
 141        ut_asserteq_str("someabcthing", buf);
 142
 143        /* Replace with longer string */
 144        ut_assertok(env_set("var", "abcde"));
 145        strcpy(buf, "some${var}thing");
 146        ut_assertok(bootm_process_cmdline(buf, BUF_SIZE, BOOTM_CL_SUBST));
 147        ut_asserteq_str("someabcdething", buf);
 148
 149        /* Check it is case sensitive */
 150        ut_assertok(env_set("VAR", NULL));
 151        strcpy(buf, "some${VAR}thing");
 152        ut_assertok(bootm_process_cmdline(buf, BUF_SIZE, BOOTM_CL_SUBST));
 153        ut_asserteq_str("something", buf);
 154
 155        /* Check too long - need 12 bytes for each string */
 156        strcpy(buf, "some${var}thing");
 157        ut_asserteq(-ENOSPC,
 158                    bootm_process_cmdline(buf, 12 * 2 - 1, BOOTM_CL_SUBST));
 159
 160        /* Check just enough space */
 161        strcpy(buf, "some${var}thing");
 162        ut_assertok(bootm_process_cmdline(buf, 16 * 2, BOOTM_CL_SUBST));
 163        ut_asserteq_str("someabcdething", buf);
 164
 165        /*
 166         * Check the substition string being too long. This results in a string
 167         * of 12 (13 bytes). We need enough space for that plus the original
 168         * "a${var}c" string of 9 bytes. So 12 + 9 = 21 bytes.
 169         */
 170        ut_assertok(env_set("var", "1234567890"));
 171        strcpy(buf, "a${var}c");
 172        ut_asserteq(-ENOSPC, bootm_process_cmdline(buf, 21, BOOTM_CL_SUBST));
 173
 174        strcpy(buf, "a${var}c");
 175        ut_asserteq(0, bootm_process_cmdline(buf, 22, BOOTM_CL_SUBST));
 176
 177        /* Check multiple substitutions */
 178        ut_assertok(env_set("var", "abc"));
 179        strcpy(buf, "some${var}thing${bvar}else");
 180        ut_asserteq(0, bootm_process_cmdline(buf, BUF_SIZE, BOOTM_CL_SUBST));
 181        ut_asserteq_str("someabcthingelse", buf);
 182
 183        /* Check multiple substitutions */
 184        ut_assertok(env_set("bvar", "123"));
 185        strcpy(buf, "some${var}thing${bvar}else");
 186        ut_asserteq(0, bootm_process_cmdline(buf, BUF_SIZE, BOOTM_CL_SUBST));
 187        ut_asserteq_str("someabcthing123else", buf);
 188
 189        return 0;
 190}
 191BOOTM_TEST(bootm_test_subst, 0);
 192
 193/* Test silent processing in the bootargs variable */
 194static int bootm_test_silent_var(struct unit_test_state *uts)
 195{
 196        env_set("bootargs", NULL);
 197        ut_assertok(bootm_process_cmdline_env(BOOTM_CL_SUBST));
 198        ut_assertnull(env_get("bootargs"));
 199
 200        ut_assertok(env_set("bootargs", "some${var}thing"));
 201        ut_assertok(bootm_process_cmdline_env(BOOTM_CL_SUBST));
 202        ut_asserteq_str("something", env_get("bootargs"));
 203
 204        return 0;
 205}
 206BOOTM_TEST(bootm_test_silent_var, 0);
 207
 208/* Test substitution processing in the bootargs variable */
 209static int bootm_test_subst_var(struct unit_test_state *uts)
 210{
 211        env_set("bootargs", NULL);
 212        ut_assertok(bootm_process_cmdline_env(BOOTM_CL_SILENT));
 213        ut_asserteq_str("console=", env_get("bootargs"));
 214
 215        ut_assertok(env_set("var", "abc"));
 216        ut_assertok(env_set("bootargs", "some${var}thing"));
 217        ut_assertok(bootm_process_cmdline_env(BOOTM_CL_SILENT));
 218        ut_asserteq_str("some${var}thing console=", env_get("bootargs"));
 219
 220        return 0;
 221}
 222BOOTM_TEST(bootm_test_subst_var, 0);
 223
 224/* Test substitution and silent console processing in the bootargs variable */
 225static int bootm_test_subst_both(struct unit_test_state *uts)
 226{
 227        ut_assertok(env_set("silent_linux", "yes"));
 228        env_set("bootargs", NULL);
 229        ut_assertok(bootm_process_cmdline_env(BOOTM_CL_ALL));
 230        ut_asserteq_str("console=", env_get("bootargs"));
 231
 232        ut_assertok(env_set("bootargs", "some${var}thing " CONSOLE_STR));
 233        ut_assertok(env_set("var", "1234567890"));
 234        ut_assertok(bootm_process_cmdline_env(BOOTM_CL_ALL));
 235        ut_asserteq_str("some1234567890thing console=", env_get("bootargs"));
 236
 237        return 0;
 238}
 239BOOTM_TEST(bootm_test_subst_both, 0);
 240
 241int do_ut_bootm(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
 242{
 243        struct unit_test *tests = UNIT_TEST_SUITE_START(bootm_test);
 244        const int n_ents = UNIT_TEST_SUITE_COUNT(bootm_test);
 245
 246        return cmd_ut_category("bootm", "bootm_test_", tests, n_ents,
 247                               argc, argv);
 248}
 249