arch/sandbox/cpu/start.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (c) 2011-2012 The Chromium OS Authors.
   4  */
   5
   6 #include <common.h>
   7 #include <cli.h>
   8 #include <command.h>
   9 #include <efi_loader.h>
  10 #include <errno.h>
  11 #include <event.h>
  12 #include <init.h>
  13 #include <log.h>
  14 #include <os.h>
  15 #include <sort.h>
  16 #include <asm/getopt.h>
  17 #include <asm/global_data.h>
  18 #include <asm/io.h>
  19 #include <asm/malloc.h>
  20 #include <asm/sections.h>
  21 #include <asm/state.h>
  22 #include <dm/root.h>
  23 #include <linux/ctype.h>
  24
  25 DECLARE_GLOBAL_DATA_PTR;
  26
  27 static char **os_argv;
  28
  29 /* Compare two options so that they can be sorted into alphabetical order */
  30 static int h_compare_opt(const void *p1, const void *p2)
  31 {
  32         const struct sandbox_cmdline_option *opt1 = p1;
  33         const struct sandbox_cmdline_option *opt2 = p2;
  34         const char *str1, *str2;
  35         char flag1[2], flag2[2];
  36
  37         opt1 = *(struct sandbox_cmdline_option **)p1;
  38         opt2 = *(struct sandbox_cmdline_option **)p2;
  39         flag1[1] = '\0';
  40         flag2[1] = '\0';
  41
  42         *flag1 = opt1->flag_short < 0x100 ? opt1->flag_short : '\0';
  43         *flag2 = opt2->flag_short < 0x100 ? opt2->flag_short : '\0';
  44
  45         str1 = *flag1 ? flag1 : opt1->flag;
  46         str2 = *flag2 ? flag2 : opt2->flag;
  47
  48         /*
  49          * Force lower-case flags to come before upper-case ones. We only
  50          * support upper-case for short flags.
  51          */
  52         if (isalpha(*str1) && isalpha(*str2) &&
  53             tolower(*str1) == tolower(*str2))
  54                 return isupper(*str1) - isupper(*str2);
  55
  56         return strcasecmp(str1, str2);
  57 }
  58
  59 int sandbox_early_getopt_check(void)
  60 {
  61         struct sandbox_state *state = state_get_current();
  62         struct sandbox_cmdline_option **sb_opt =
  63                 __u_boot_sandbox_option_start();
  64         size_t num_options = __u_boot_sandbox_option_count();
  65         size_t i;
  66         int max_arg_len, max_noarg_len;
  67         struct sandbox_cmdline_option **sorted_opt;
  68         int size;
  69
  70         /* parse_err will be a string of the faulting option */
  71         if (!state->parse_err)
  72                 return 0;
  73
  74         if (strcmp(state->parse_err, "help")) {
  75                 printf("u-boot: error: failed while parsing option: %s\n"
  76                         "\ttry running with --help for more information.\n",
  77                         state->parse_err);
  78                 os_exit(1);
  79         }
  80
  81         printf(
  82                 "u-boot, a command line test interface to U-Boot\n\n"
  83                 "Usage: u-boot [options]\n"
  84                 "Options:\n");
  85
  86         max_arg_len = 0;
  87         for (i = 0; i < num_options; ++i)
  88                 max_arg_len = max((int)strlen(sb_opt[i]->flag), max_arg_len);
  89         max_noarg_len = max_arg_len + 7;
  90
  91         /* Sort the options */
  92         size = sizeof(*sorted_opt) * num_options;
  93         sorted_opt = os_malloc(size);
  94         if (!sorted_opt) {
  95                 printf("No memory to sort options\n");
  96                 os_exit(1);
  97         }
  98         memcpy(sorted_opt, sb_opt, size);
  99         qsort(sorted_opt, num_options, sizeof(*sorted_opt), h_compare_opt);
 100
 101         for (i = 0; i < num_options; ++i) {
 102                 struct sandbox_cmdline_option *opt = sorted_opt[i];
 103
 104                 /* first output the short flag if it has one */
 105                 if (opt->flag_short >= 0x100)
 106                         printf("      ");
 107                 else
 108                         printf("  -%c, ", opt->flag_short);
 109
 110                 /* then the long flag */
 111                 if (opt->has_arg)
 112                         printf("--%-*s <arg> ", max_arg_len, opt->flag);
 113                 else
 114                         printf("--%-*s", max_noarg_len, opt->flag);
 115
 116                 /* finally the help text */
 117                 printf("  %s\n", opt->help);
 118         }
 119
 120         os_exit(0);
 121 }
 122
 123 static int sandbox_misc_init_f(void *ctx, struct event *event)
 124 {
 125         return sandbox_early_getopt_check();
 126 }
 127 EVENT_SPY(EVT_MISC_INIT_F, sandbox_misc_init_f);
 128
 129 static int sandbox_cmdline_cb_help(struct sandbox_state *state, const char *arg)
 130 {
 131         /* just flag to sandbox_early_getopt_check to show usage */
 132         return 1;
 133 }
 134 SANDBOX_CMDLINE_OPT_SHORT(help, 'h', 0, "Display help");
 135
 136 #ifndef CONFIG_SPL_BUILD
 137 int sandbox_main_loop_init(void)
 138 {
 139         struct sandbox_state *state = state_get_current();
 140
 141         /* Execute command if required */
 142         if (state->cmd || state->run_distro_boot) {
 143                 int retval = 0;
 144
 145                 cli_init();
 146
 147 #ifdef CONFIG_CMDLINE
 148                 if (state->cmd)
 149                         retval = run_command_list(state->cmd, -1, 0);
 150
 151                 if (state->run_distro_boot)
 152                         retval = cli_simple_run_command("run distro_bootcmd",
 153                                                         0);
 154 #endif
 155                 if (!state->interactive)
 156                         os_exit(retval);
 157         }
 158
 159         return 0;
 160 }
 161 #endif
 162
 163 static int sandbox_cmdline_cb_boot(struct sandbox_state *state,
 164                                       const char *arg)
 165 {
 166         state->run_distro_boot = true;
 167         return 0;
 168 }
 169 SANDBOX_CMDLINE_OPT_SHORT(boot, 'b', 0, "Run distro boot commands");
 170
 171 static int sandbox_cmdline_cb_command(struct sandbox_state *state,
 172                                       const char *arg)
 173 {
 174         state->cmd = arg;
 175         return 0;
 176 }
 177 SANDBOX_CMDLINE_OPT_SHORT(command, 'c', 1, "Execute U-Boot command");
 178
 179 static int sandbox_cmdline_cb_fdt(struct sandbox_state *state, const char *arg)
 180 {
 181         state->fdt_fname = arg;
 182         return 0;
 183 }
 184 SANDBOX_CMDLINE_OPT_SHORT(fdt, 'd', 1, "Specify U-Boot's control FDT");
 185
 186 static int sandbox_cmdline_cb_default_fdt(struct sandbox_state *state,
 187                                           const char *arg)
 188 {
 189         const char *fmt = "%s.dtb";
 190         char *fname;
 191         int len;
 192
 193         len = strlen(state->argv[0]) + strlen(fmt) + 1;
 194         fname = os_malloc(len);
 195         if (!fname)
 196                 return -ENOMEM;
 197         snprintf(fname, len, fmt, state->argv[0]);
 198         state->fdt_fname = fname;
 199
 200         return 0;
 201 }
 202 SANDBOX_CMDLINE_OPT_SHORT(default_fdt, 'D', 0,
 203                 "Use the default u-boot.dtb control FDT in U-Boot directory");
 204
 205 static int sandbox_cmdline_cb_test_fdt(struct sandbox_state *state,
 206                                        const char *arg)
 207 {
 208         char buf[256];
 209         char *fname;
 210         int len;
 211
 212         len = state_get_rel_filename("arch/sandbox/dts/test.dtb", buf,
 213                                      sizeof(buf));
 214         if (len < 0)
 215                 return len;
 216
 217         fname = os_malloc(len);
 218         if (!fname)
 219                 return -ENOMEM;
 220         strcpy(fname, buf);
 221         state->fdt_fname = fname;
 222
 223         return 0;
 224 }
 225 SANDBOX_CMDLINE_OPT_SHORT(test_fdt, 'T', 0,
 226                           "Use the test.dtb control FDT in U-Boot directory");
 227
 228 static int sandbox_cmdline_cb_interactive(struct sandbox_state *state,
 229                                           const char *arg)
 230 {
 231         state->interactive = true;
 232         return 0;
 233 }
 234
 235 SANDBOX_CMDLINE_OPT_SHORT(interactive, 'i', 0, "Enter interactive mode");
 236
 237 static int sandbox_cmdline_cb_jump(struct sandbox_state *state,
 238                                    const char *arg)
 239 {
 240         /* Remember to delete this U-Boot image later */
 241         state->jumped_fname = arg;
 242
 243         return 0;
 244 }
 245 SANDBOX_CMDLINE_OPT_SHORT(jump, 'j', 1, "Jumped from previous U-Boot");
 246
 247 static int sandbox_cmdline_cb_program(struct sandbox_state *state,
 248                                       const char *arg)
 249 {
 250         /*
 251          * Record the program name to use when jumping to future phases. This
 252          * is the original executable which holds all the phases. We need to
 253          * use this instead of argv[0] since each phase is started by
 254          * extracting a particular binary from the full program, then running
 255          * it. Therefore in that binary, argv[0] contains only the
 256          * current-phase executable.
 257          *
 258          * For example, sandbox TPL may be started using image file:
 259          *
 260          *     ./image.bin
 261          *
 262          * but then TPL needs to run VPL, which it does by extracting the VPL
 263          * image from the image.bin file.
 264          *
 265          *    ./temp-vpl
 266          *
 267          * When VPL runs it needs access to the original image.bin so it can
 268          * extract the next phase (SPL). This works if we use '-f image.bin'
 269          * when starting the original image.bin file.
 270          */
 271         state->prog_fname = arg;
 272
 273         return 0;
 274 }
 275 SANDBOX_CMDLINE_OPT_SHORT(program, 'p', 1, "U-Boot program name");
 276
 277 static int sandbox_cmdline_cb_memory(struct sandbox_state *state,
 278                                      const char *arg)
 279 {
 280         int err;
 281
 282         /* For now assume we always want to write it */
 283         state->write_ram_buf = true;
 284         state->ram_buf_fname = arg;
 285
 286         err = os_read_ram_buf(arg);
 287         if (err) {
 288                 printf("Failed to read RAM buffer '%s': %d\n", arg, err);
 289                 return err;
 290         }
 291         state->ram_buf_read = true;
 292
 293         return 0;
 294 }
 295 SANDBOX_CMDLINE_OPT_SHORT(memory, 'm', 1,
 296                           "Read/write ram_buf memory contents from file");
 297
 298 static int sandbox_cmdline_cb_rm_memory(struct sandbox_state *state,
 299                                         const char *arg)
 300 {
 301         state->ram_buf_rm = true;
 302
 303         return 0;
 304 }
 305 SANDBOX_CMDLINE_OPT(rm_memory, 0, "Remove memory file after reading");
 306
 307 static int sandbox_cmdline_cb_state(struct sandbox_state *state,
 308                                     const char *arg)
 309 {
 310         state->state_fname = arg;
 311         return 0;
 312 }
 313 SANDBOX_CMDLINE_OPT_SHORT(state, 's', 1, "Specify the sandbox state FDT");
 314
 315 static int sandbox_cmdline_cb_read(struct sandbox_state *state,
 316                                    const char *arg)
 317 {
 318         state->read_state = true;
 319         return 0;
 320 }
 321 SANDBOX_CMDLINE_OPT_SHORT(read, 'r', 0, "Read the state FDT on startup");
 322
 323 static int sandbox_cmdline_cb_write(struct sandbox_state *state,
 324                                     const char *arg)
 325 {
 326         state->write_state = true;
 327         return 0;
 328 }
 329 SANDBOX_CMDLINE_OPT_SHORT(write, 'w', 0, "Write state FDT on exit");
 330
 331 static int sandbox_cmdline_cb_ignore_missing(struct sandbox_state *state,
 332                                              const char *arg)
 333 {
 334         state->ignore_missing_state_on_read = true;
 335         return 0;
 336 }
 337 SANDBOX_CMDLINE_OPT_SHORT(ignore_missing, 'n', 0,
 338                           "Ignore missing state on read");
 339
 340 static int sandbox_cmdline_cb_show_lcd(struct sandbox_state *state,
 341                                        const char *arg)
 342 {
 343         state->show_lcd = true;
 344         return 0;
 345 }
 346 SANDBOX_CMDLINE_OPT_SHORT(show_lcd, 'l', 0,
 347                           "Show the sandbox LCD display");
 348
 349 static int sandbox_cmdline_cb_double_lcd(struct sandbox_state *state,
 350                                          const char *arg)
 351 {
 352         state->double_lcd = true;
 353
 354         return 0;
 355 }
 356 SANDBOX_CMDLINE_OPT_SHORT(double_lcd, 'K', 0,
 357                           "Double the LCD display size in each direction");
 358
 359 static const char *term_args[STATE_TERM_COUNT] = {
 360         "raw-with-sigs",
 361         "raw",
 362         "cooked",
 363 };
 364
 365 static int sandbox_cmdline_cb_terminal(struct sandbox_state *state,
 366                                        const char *arg)
 367 {
 368         int i;
 369
 370         for (i = 0; i < STATE_TERM_COUNT; i++) {
 371                 if (!strcmp(arg, term_args[i])) {
 372                         state->term_raw = i;
 373                         return 0;
 374                 }
 375         }
 376
 377         printf("Unknown terminal setting '%s' (", arg);
 378         for (i = 0; i < STATE_TERM_COUNT; i++)
 379                 printf("%s%s", i ? ", " : "", term_args[i]);
 380         puts(")\n");
 381
 382         return 1;
 383 }
 384 SANDBOX_CMDLINE_OPT_SHORT(terminal, 't', 1,
 385                           "Set terminal to raw/cooked mode");
 386
 387 static int sandbox_cmdline_cb_verbose(struct sandbox_state *state,
 388                                       const char *arg)
 389 {
 390         state->show_test_output = true;
 391         return 0;
 392 }
 393 SANDBOX_CMDLINE_OPT_SHORT(verbose, 'v', 0, "Show test output");
 394
 395 static int sandbox_cmdline_cb_log_level(struct sandbox_state *state,
 396                                         const char *arg)
 397 {
 398         state->default_log_level = simple_strtol(arg, NULL, 10);
 399
 400         return 0;
 401 }
 402 SANDBOX_CMDLINE_OPT_SHORT(log_level, 'L', 1,
 403                           "Set log level (0=panic, 7=debug)");
 404
 405 static int sandbox_cmdline_cb_unittests(struct sandbox_state *state,
 406                                         const char *arg)
 407 {
 408         state->run_unittests = true;
 409
 410         return 0;
 411 }
 412 SANDBOX_CMDLINE_OPT_SHORT(unittests, 'u', 0, "Run unit tests");
 413
 414 static int sandbox_cmdline_cb_select_unittests(struct sandbox_state *state,
 415                                                const char *arg)
 416 {
 417         state->select_unittests = arg;
 418
 419         return 0;
 420 }
 421 SANDBOX_CMDLINE_OPT_SHORT(select_unittests, 'k', 1, "Select unit tests to run");
 422
 423 static int sandbox_cmdline_cb_signals(struct sandbox_state *state,
 424                                       const char *arg)
 425 {
 426         state->handle_signals = true;
 427
 428         return 0;
 429 }
 430 SANDBOX_CMDLINE_OPT_SHORT(signals, 'S', 0,
 431                           "Handle signals (such as SIGSEGV) in sandbox");
 432
 433 static int sandbox_cmdline_cb_autoboot_keyed(struct sandbox_state *state,
 434                                              const char *arg)
 435 {
 436         state->autoboot_keyed = true;
 437
 438         return 0;
 439 }
 440 SANDBOX_CMDLINE_OPT(autoboot_keyed, 0, "Allow keyed autoboot");
 441
 442 static void setup_ram_buf(struct sandbox_state *state)
 443 {
 444         /* Zero the RAM buffer if we didn't read it, to keep valgrind happy */
 445         if (!state->ram_buf_read)
 446                 memset(state->ram_buf, '\0', state->ram_size);
 447
 448         gd->arch.ram_buf = state->ram_buf;
 449         gd->ram_size = state->ram_size;
 450 }
 451
 452 void state_show(struct sandbox_state *state)
 453 {
 454         char **p;
 455
 456         printf("Arguments:\n");
 457         for (p = state->argv; *p; p++)
 458                 printf("%s ", *p);
 459         printf("\n");
 460 }
 461
 462 void __efi_runtime EFIAPI efi_reset_system(
 463                 enum efi_reset_type reset_type,
 464                 efi_status_t reset_status,
 465                 unsigned long data_size, void *reset_data)
 466 {
 467         if (reset_type == EFI_RESET_SHUTDOWN)
 468                 sandbox_exit();
 469         else
 470                 sandbox_reset();
 471 }
 472
 473 void sandbox_reset(void)
 474 {
 475         /* Do this here while it still has an effect */
 476         os_fd_restore();
 477         if (state_uninit())
 478                 os_exit(2);
 479
 480         /* Restart U-Boot */
 481         os_relaunch(os_argv);
 482 }
 483
 484 int sandbox_main(int argc, char *argv[])
 485 {
 486         struct sandbox_state *state;
 487         void * text_base;
 488         gd_t data;
 489         int size;
 490         int ret;
 491
 492         text_base = os_find_text_base();
 493
 494         /*
 495          * This must be the first invocation of os_malloc() to have
 496          * state->ram_buf in the low 4 GiB.
 497          */
 498         ret = state_init();
 499         if (ret)
 500                 goto err;
 501
 502         /*
 503          * Copy argv[] so that we can pass the arguments in the original
 504          * sequence when resetting the sandbox.
 505          */
 506         size = sizeof(char *) * (argc + 1);
 507         os_argv = os_malloc(size);
 508         if (!os_argv)
 509                 os_exit(1);
 510         memcpy(os_argv, argv, size);
 511
 512         memset(&data, '\0', sizeof(data));
 513         gd = &data;
 514         gd->arch.text_base = text_base;
 515
 516         state = state_get_current();
 517         if (os_parse_args(state, argc, argv))
 518                 return 1;
 519
 520         /* Remove old memory file if required */
 521         if (state->ram_buf_rm && state->ram_buf_fname) {
 522                 os_unlink(state->ram_buf_fname);
 523                 state->write_ram_buf = false;
 524                 state->ram_buf_fname = NULL;
 525         }
 526
 527         ret = sandbox_read_state(state, state->state_fname);
 528         if (ret)
 529                 goto err;
 530
 531         if (state->handle_signals) {
 532                 ret = os_setup_signal_handlers();
 533                 if (ret)
 534                         goto err;
 535         }
 536
 537 #if CONFIG_VAL(SYS_MALLOC_F_LEN)
 538         gd->malloc_base = CFG_MALLOC_F_ADDR;
 539 #endif
 540 #if CONFIG_IS_ENABLED(LOG)
 541         gd->default_log_level = state->default_log_level;
 542 #endif
 543         setup_ram_buf(state);
 544
 545         /*
 546          * Set up the relocation offset here, since sandbox symbols are always
 547          * relocated by the OS before sandbox is entered.
 548          */
 549         gd->reloc_off = (ulong)gd->arch.text_base;
 550
 551         /* sandbox test: log functions called before log_init in board_init_f */
 552         log_debug("debug: %s\n", __func__);
 553
 554         /* Do pre- and post-relocation init */
 555         board_init_f(0);
 556
 557         board_init_r(gd->new_gd, 0);
 558
 559         /* NOTREACHED - board_init_r() does not return */
 560         return 0;
 561
 562 err:
 563         printf("Error %d\n", ret);
 564         return 1;
 565 }