blob: 234652872ecc554a8962a9aff5f8df4bca0e141b [file] [log] [blame]
Tom Rini10e47792018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
Simon Glass5ba8ef62011-10-03 19:26:45 +00002/*
Simon Glass20bf89a2012-02-15 15:51:15 -08003 * Copyright (c) 2011-2012 The Chromium OS Authors.
Simon Glass5ba8ef62011-10-03 19:26:45 +00004 */
5
6#include <common.h>
Simon Glassfe143ee2022-03-04 08:42:58 -07007#include <cli.h>
Simon Glassadaaa482019-11-14 12:57:43 -07008#include <command.h>
Heinrich Schuchardt43eb8722020-12-02 16:22:11 +01009#include <efi_loader.h>
Simon Glass07a3b232015-05-04 11:31:08 -060010#include <errno.h>
Simon Glassf1c51912022-03-04 08:43:04 -070011#include <event.h>
Simon Glass97589732020-05-10 11:40:02 -060012#include <init.h>
Patrick Delaunay053156d2020-11-27 11:20:55 +010013#include <log.h>
Simon Glass9dd10bf2013-11-10 10:27:03 -070014#include <os.h>
Simon Glass11c92b12020-02-03 07:35:47 -070015#include <sort.h>
Simon Glass8a3e0352012-02-15 15:51:16 -080016#include <asm/getopt.h>
Simon Glass3ba929a2020-10-30 21:38:53 -060017#include <asm/global_data.h>
Simon Glassc395fdf2014-07-10 22:23:27 -060018#include <asm/io.h>
Simon Glass30f92052020-02-03 07:36:05 -070019#include <asm/malloc.h>
Simon Glass8a3e0352012-02-15 15:51:16 -080020#include <asm/sections.h>
Simon Glass20bf89a2012-02-15 15:51:15 -080021#include <asm/state.h>
Simon Glassfe143ee2022-03-04 08:42:58 -070022#include <dm/root.h>
Simon Glass11c92b12020-02-03 07:35:47 -070023#include <linux/ctype.h>
Simon Glass5ba8ef62011-10-03 19:26:45 +000024
Simon Glass2fd34e62013-11-10 10:26:59 -070025DECLARE_GLOBAL_DATA_PTR;
26
Heinrich Schuchardt1c678442020-10-27 20:29:25 +010027static char **os_argv;
28
Simon Glass11c92b12020-02-03 07:35:47 -070029/* Compare two options so that they can be sorted into alphabetical order */
30static 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
Simon Glass8a3e0352012-02-15 15:51:16 -080059int sandbox_early_getopt_check(void)
60{
61 struct sandbox_state *state = state_get_current();
Marek BehĂșn184c4af2021-05-20 13:24:06 +020062 struct sandbox_cmdline_option **sb_opt =
63 __u_boot_sandbox_option_start();
Simon Glass8a3e0352012-02-15 15:51:16 -080064 size_t num_options = __u_boot_sandbox_option_count();
65 size_t i;
66 int max_arg_len, max_noarg_len;
Simon Glass11c92b12020-02-03 07:35:47 -070067 struct sandbox_cmdline_option **sorted_opt;
68 int size;
Simon Glass8a3e0352012-02-15 15:51:16 -080069
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)
Masahiro Yamadadb204642014-11-07 03:03:31 +090088 max_arg_len = max((int)strlen(sb_opt[i]->flag), max_arg_len);
Simon Glass8a3e0352012-02-15 15:51:16 -080089 max_noarg_len = max_arg_len + 7;
90
Simon Glass11c92b12020-02-03 07:35:47 -070091 /* Sort the options */
92 size = sizeof(*sorted_opt) * num_options;
Simon Glassedd094e2021-02-06 09:57:33 -070093 sorted_opt = os_malloc(size);
Simon Glass11c92b12020-02-03 07:35:47 -070094 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
Simon Glass8a3e0352012-02-15 15:51:16 -0800101 for (i = 0; i < num_options; ++i) {
Simon Glass11c92b12020-02-03 07:35:47 -0700102 struct sandbox_cmdline_option *opt = sorted_opt[i];
Simon Glass8a3e0352012-02-15 15:51:16 -0800103
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)
Simon Glass8a3e0352012-02-15 15:51:16 -0800112 printf("--%-*s <arg> ", max_arg_len, opt->flag);
Simon Glass5f679f02013-11-10 10:26:58 -0700113 else
114 printf("--%-*s", max_noarg_len, opt->flag);
Simon Glass8a3e0352012-02-15 15:51:16 -0800115
116 /* finally the help text */
117 printf(" %s\n", opt->help);
118 }
119
120 os_exit(0);
121}
122
Simon Glassf1c51912022-03-04 08:43:04 -0700123static int sandbox_misc_init_f(void *ctx, struct event *event)
Simon Glassb419dbb2017-03-28 10:27:28 -0600124{
125 return sandbox_early_getopt_check();
126}
Simon Glassf1c51912022-03-04 08:43:04 -0700127EVENT_SPY(EVT_MISC_INIT_F, sandbox_misc_init_f);
Simon Glassb419dbb2017-03-28 10:27:28 -0600128
Simon Glass64367c82013-12-03 16:43:23 -0700129static int sandbox_cmdline_cb_help(struct sandbox_state *state, const char *arg)
Simon Glass8a3e0352012-02-15 15:51:16 -0800130{
131 /* just flag to sandbox_early_getopt_check to show usage */
132 return 1;
133}
Simon Glass64367c82013-12-03 16:43:23 -0700134SANDBOX_CMDLINE_OPT_SHORT(help, 'h', 0, "Display help");
Simon Glass8a3e0352012-02-15 15:51:16 -0800135
Simon Glass5cf16632016-07-04 11:57:50 -0600136#ifndef CONFIG_SPL_BUILD
Simon Glass0fc3c222012-02-26 17:38:50 -0500137int sandbox_main_loop_init(void)
138{
Simon Glass8a3e0352012-02-15 15:51:16 -0800139 struct sandbox_state *state = state_get_current();
140
141 /* Execute command if required */
Sjoerd Simons335f4702015-04-30 22:16:09 +0200142 if (state->cmd || state->run_distro_boot) {
143 int retval = 0;
Joe Hershberger744d7882015-02-06 15:37:31 -0600144
Rabin Vincent7e0194a2014-10-29 23:21:38 +0100145 cli_init();
146
Simon Glasse0f12802016-03-13 19:07:30 -0600147#ifdef CONFIG_CMDLINE
Sjoerd Simons335f4702015-04-30 22:16:09 +0200148 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);
Simon Glasse0f12802016-03-13 19:07:30 -0600154#endif
Simon Glassf498e432013-11-10 10:27:02 -0700155 if (!state->interactive)
Joe Hershberger744d7882015-02-06 15:37:31 -0600156 os_exit(retval);
Simon Glass8a3e0352012-02-15 15:51:16 -0800157 }
158
Sjoerd Simons335f4702015-04-30 22:16:09 +0200159 return 0;
160}
Simon Glass5cf16632016-07-04 11:57:50 -0600161#endif
Sjoerd Simons335f4702015-04-30 22:16:09 +0200162
163static int sandbox_cmdline_cb_boot(struct sandbox_state *state,
164 const char *arg)
165{
166 state->run_distro_boot = true;
Simon Glass0fc3c222012-02-26 17:38:50 -0500167 return 0;
168}
Sjoerd Simons335f4702015-04-30 22:16:09 +0200169SANDBOX_CMDLINE_OPT_SHORT(boot, 'b', 0, "Run distro boot commands");
Simon Glass0fc3c222012-02-26 17:38:50 -0500170
Simon Glass64367c82013-12-03 16:43:23 -0700171static int sandbox_cmdline_cb_command(struct sandbox_state *state,
172 const char *arg)
Simon Glass8a3e0352012-02-15 15:51:16 -0800173{
174 state->cmd = arg;
175 return 0;
176}
Simon Glass64367c82013-12-03 16:43:23 -0700177SANDBOX_CMDLINE_OPT_SHORT(command, 'c', 1, "Execute U-Boot command");
Simon Glass8a3e0352012-02-15 15:51:16 -0800178
Simon Glass64367c82013-12-03 16:43:23 -0700179static int sandbox_cmdline_cb_fdt(struct sandbox_state *state, const char *arg)
Simon Glass15393432013-04-20 08:42:41 +0000180{
181 state->fdt_fname = arg;
182 return 0;
183}
Simon Glass64367c82013-12-03 16:43:23 -0700184SANDBOX_CMDLINE_OPT_SHORT(fdt, 'd', 1, "Specify U-Boot's control FDT");
Simon Glass15393432013-04-20 08:42:41 +0000185
Simon Glass8e170782015-01-19 20:21:34 -0700186static 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;
Simon Glassedd094e2021-02-06 09:57:33 -0700194 fname = os_malloc(len);
Simon Glass8e170782015-01-19 20:21:34 -0700195 if (!fname)
196 return -ENOMEM;
197 snprintf(fname, len, fmt, state->argv[0]);
198 state->fdt_fname = fname;
199
200 return 0;
201}
202SANDBOX_CMDLINE_OPT_SHORT(default_fdt, 'D', 0,
203 "Use the default u-boot.dtb control FDT in U-Boot directory");
204
Simon Glass3c3968f2019-09-25 08:56:07 -0600205static int sandbox_cmdline_cb_test_fdt(struct sandbox_state *state,
206 const char *arg)
207{
Simon Glassd74c4612022-09-06 20:27:08 -0600208 char buf[256];
Simon Glass3c3968f2019-09-25 08:56:07 -0600209 char *fname;
210 int len;
211
Simon Glassd74c4612022-09-06 20:27:08 -0600212 len = state_get_rel_filename("arch/sandbox/dts/test.dtb", buf,
213 sizeof(buf));
214 if (len < 0)
215 return len;
216
Simon Glassedd094e2021-02-06 09:57:33 -0700217 fname = os_malloc(len);
Simon Glass3c3968f2019-09-25 08:56:07 -0600218 if (!fname)
219 return -ENOMEM;
Simon Glassd74c4612022-09-06 20:27:08 -0600220 strcpy(fname, buf);
Simon Glass3c3968f2019-09-25 08:56:07 -0600221 state->fdt_fname = fname;
222
223 return 0;
224}
225SANDBOX_CMDLINE_OPT_SHORT(test_fdt, 'T', 0,
226 "Use the test.dtb control FDT in U-Boot directory");
227
Simon Glassf498e432013-11-10 10:27:02 -0700228static int sandbox_cmdline_cb_interactive(struct sandbox_state *state,
229 const char *arg)
230{
231 state->interactive = true;
232 return 0;
233}
234
235SANDBOX_CMDLINE_OPT_SHORT(interactive, 'i', 0, "Enter interactive mode");
236
Simon Glasse9906532014-02-27 13:26:16 -0700237static int sandbox_cmdline_cb_jump(struct sandbox_state *state,
238 const char *arg)
239{
Simon Glass47acfc62014-02-27 13:26:23 -0700240 /* Remember to delete this U-Boot image later */
241 state->jumped_fname = arg;
Simon Glasse9906532014-02-27 13:26:16 -0700242
243 return 0;
244}
245SANDBOX_CMDLINE_OPT_SHORT(jump, 'j', 1, "Jumped from previous U-Boot");
246
Simon Glassf0b534f2022-10-20 18:23:02 -0600247static 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}
275SANDBOX_CMDLINE_OPT_SHORT(program, 'p', 1, "U-Boot program name");
276
Simon Glass9dd10bf2013-11-10 10:27:03 -0700277static 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
Simon Glassc043e032014-11-11 12:47:08 -0700286 err = os_read_ram_buf(arg);
287 if (err) {
Simon Glass332894d2018-10-01 11:55:12 -0600288 printf("Failed to read RAM buffer '%s': %d\n", arg, err);
Simon Glass9dd10bf2013-11-10 10:27:03 -0700289 return err;
290 }
Simon Glass24a284a2018-11-23 21:29:29 -0700291 state->ram_buf_read = true;
Simon Glass9dd10bf2013-11-10 10:27:03 -0700292
293 return 0;
294}
295SANDBOX_CMDLINE_OPT_SHORT(memory, 'm', 1,
296 "Read/write ram_buf memory contents from file");
297
Simon Glass47acfc62014-02-27 13:26:23 -0700298static 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}
305SANDBOX_CMDLINE_OPT(rm_memory, 0, "Remove memory file after reading");
306
Simon Glassd7c8d8d2013-11-10 10:27:04 -0700307static int sandbox_cmdline_cb_state(struct sandbox_state *state,
308 const char *arg)
309{
310 state->state_fname = arg;
311 return 0;
312}
313SANDBOX_CMDLINE_OPT_SHORT(state, 's', 1, "Specify the sandbox state FDT");
314
315static int sandbox_cmdline_cb_read(struct sandbox_state *state,
316 const char *arg)
317{
318 state->read_state = true;
319 return 0;
320}
321SANDBOX_CMDLINE_OPT_SHORT(read, 'r', 0, "Read the state FDT on startup");
322
323static int sandbox_cmdline_cb_write(struct sandbox_state *state,
324 const char *arg)
325{
326 state->write_state = true;
327 return 0;
328}
329SANDBOX_CMDLINE_OPT_SHORT(write, 'w', 0, "Write state FDT on exit");
330
331static 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}
337SANDBOX_CMDLINE_OPT_SHORT(ignore_missing, 'n', 0,
338 "Ignore missing state on read");
339
Simon Glassb9ddbf42014-02-27 13:26:19 -0700340static int sandbox_cmdline_cb_show_lcd(struct sandbox_state *state,
341 const char *arg)
342{
343 state->show_lcd = true;
344 return 0;
345}
346SANDBOX_CMDLINE_OPT_SHORT(show_lcd, 'l', 0,
347 "Show the sandbox LCD display");
348
Simon Glassf91de0b2020-02-03 07:36:13 -0700349static 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}
356SANDBOX_CMDLINE_OPT_SHORT(double_lcd, 'K', 0,
357 "Double the LCD display size in each direction");
358
Simon Glass678ef472014-02-27 13:26:22 -0700359static const char *term_args[STATE_TERM_COUNT] = {
360 "raw-with-sigs",
361 "raw",
362 "cooked",
363};
364
365static 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}
384SANDBOX_CMDLINE_OPT_SHORT(terminal, 't', 1,
385 "Set terminal to raw/cooked mode");
386
Simon Glassfe6d12a2015-11-08 23:47:50 -0700387static int sandbox_cmdline_cb_verbose(struct sandbox_state *state,
388 const char *arg)
389{
390 state->show_test_output = true;
391 return 0;
392}
393SANDBOX_CMDLINE_OPT_SHORT(verbose, 'v', 0, "Show test output");
394
Simon Glass4e9a64d2018-10-01 11:55:11 -0600395static 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}
402SANDBOX_CMDLINE_OPT_SHORT(log_level, 'L', 1,
403 "Set log level (0=panic, 7=debug)");
404
Simon Glassa4e289b2020-10-25 20:38:28 -0600405static int sandbox_cmdline_cb_unittests(struct sandbox_state *state,
406 const char *arg)
407{
408 state->run_unittests = true;
409
410 return 0;
411}
412SANDBOX_CMDLINE_OPT_SHORT(unittests, 'u', 0, "Run unit tests");
413
Simon Glasseff96582020-10-25 20:38:33 -0600414static 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}
421SANDBOX_CMDLINE_OPT_SHORT(select_unittests, 'k', 1, "Select unit tests to run");
422
Simon Glassb78cc9b2021-03-22 18:21:01 +1300423static int sandbox_cmdline_cb_signals(struct sandbox_state *state,
424 const char *arg)
425{
426 state->handle_signals = true;
427
428 return 0;
429}
430SANDBOX_CMDLINE_OPT_SHORT(signals, 'S', 0,
431 "Handle signals (such as SIGSEGV) in sandbox");
432
Simon Glassd8c60172021-07-24 15:14:39 -0600433static 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}
440SANDBOX_CMDLINE_OPT(autoboot_keyed, 0, "Allow keyed autoboot");
441
Simon Glassb94eed52017-03-28 10:27:16 -0600442static void setup_ram_buf(struct sandbox_state *state)
443{
Simon Glass24a284a2018-11-23 21:29:29 -0700444 /* Zero the RAM buffer if we didn't read it, to keep valgrind happy */
Simon Glasscd3705e2019-04-08 13:20:43 -0600445 if (!state->ram_buf_read)
Simon Glass24a284a2018-11-23 21:29:29 -0700446 memset(state->ram_buf, '\0', state->ram_size);
Simon Glass24a284a2018-11-23 21:29:29 -0700447
Simon Glassb94eed52017-03-28 10:27:16 -0600448 gd->arch.ram_buf = state->ram_buf;
449 gd->ram_size = state->ram_size;
450}
451
Simon Glass46508c92018-11-15 18:44:03 -0700452void 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
Heinrich Schuchardt43eb8722020-12-02 16:22:11 +0100462void __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{
Heinrich Schuchardt7fb72542021-11-20 14:49:18 +0100467 if (reset_type == EFI_RESET_SHUTDOWN)
468 sandbox_exit();
469 else
470 sandbox_reset();
Heinrich Schuchardt43eb8722020-12-02 16:22:11 +0100471}
472
Heinrich Schuchardt1c678442020-10-27 20:29:25 +0100473void 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
Heinrich Schuchardt1c678442020-10-27 20:29:25 +0100480 /* Restart U-Boot */
481 os_relaunch(os_argv);
482}
483
Andrew Scullca5d1372022-05-30 10:00:10 +0000484int sandbox_main(int argc, char *argv[])
Simon Glass5ba8ef62011-10-03 19:26:45 +0000485{
Simon Glass8a3e0352012-02-15 15:51:16 -0800486 struct sandbox_state *state;
Heinrich Schuchardtb8b92372021-05-15 19:29:13 +0200487 void * text_base;
Simon Glassc395fdf2014-07-10 22:23:27 -0600488 gd_t data;
Simon Glassedd094e2021-02-06 09:57:33 -0700489 int size;
Simon Glassd7c8d8d2013-11-10 10:27:04 -0700490 int ret;
Simon Glass20bf89a2012-02-15 15:51:15 -0800491
Heinrich Schuchardtb8b92372021-05-15 19:29:13 +0200492 text_base = os_find_text_base();
493
Heinrich Schuchardt1c678442020-10-27 20:29:25 +0100494 /*
Heinrich Schuchardte6d24be2021-05-11 21:03:16 +0200495 * 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 /*
Heinrich Schuchardt1c678442020-10-27 20:29:25 +0100503 * Copy argv[] so that we can pass the arguments in the original
504 * sequence when resetting the sandbox.
505 */
Simon Glassedd094e2021-02-06 09:57:33 -0700506 size = sizeof(char *) * (argc + 1);
507 os_argv = os_malloc(size);
Heinrich Schuchardt1c678442020-10-27 20:29:25 +0100508 if (!os_argv)
509 os_exit(1);
Simon Glassedd094e2021-02-06 09:57:33 -0700510 memcpy(os_argv, argv, size);
Heinrich Schuchardt1c678442020-10-27 20:29:25 +0100511
Simon Glass752707a2019-04-08 13:20:41 -0600512 memset(&data, '\0', sizeof(data));
513 gd = &data;
Heinrich Schuchardtb8b92372021-05-15 19:29:13 +0200514 gd->arch.text_base = text_base;
Simon Glass752707a2019-04-08 13:20:41 -0600515
Simon Glass8a3e0352012-02-15 15:51:16 -0800516 state = state_get_current();
517 if (os_parse_args(state, argc, argv))
518 return 1;
519
Patrick Delaunay6daf9052020-11-20 09:48:33 +0100520 /* 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
Simon Glassd7c8d8d2013-11-10 10:27:04 -0700527 ret = sandbox_read_state(state, state->state_fname);
528 if (ret)
529 goto err;
530
Simon Glassb78cc9b2021-03-22 18:21:01 +1300531 if (state->handle_signals) {
532 ret = os_setup_signal_handlers();
533 if (ret)
534 goto err;
535 }
Heinrich Schuchardt28eb5092020-11-12 00:29:56 +0100536
Andy Yan25428c42017-07-24 17:49:59 +0800537#if CONFIG_VAL(SYS_MALLOC_F_LEN)
Tom Rinifb52b942022-12-04 10:04:49 -0500538 gd->malloc_base = CFG_MALLOC_F_ADDR;
Simon Glass0cc6f5c2014-07-10 22:23:31 -0600539#endif
Simon Glass4e9a64d2018-10-01 11:55:11 -0600540#if CONFIG_IS_ENABLED(LOG)
541 gd->default_log_level = state->default_log_level;
542#endif
Simon Glassb94eed52017-03-28 10:27:16 -0600543 setup_ram_buf(state);
Simon Glassc395fdf2014-07-10 22:23:27 -0600544
Simon Glass752707a2019-04-08 13:20:41 -0600545 /*
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
Patrick Delaunay053156d2020-11-27 11:20:55 +0100551 /* sandbox test: log functions called before log_init in board_init_f */
Patrick Delaunay053156d2020-11-27 11:20:55 +0100552 log_debug("debug: %s\n", __func__);
553
Simon Glass2fd34e62013-11-10 10:26:59 -0700554 /* Do pre- and post-relocation init */
Simon Glass5ba8ef62011-10-03 19:26:45 +0000555 board_init_f(0);
Allen Martin074b4552013-01-22 13:11:21 +0000556
Simon Glass2fd34e62013-11-10 10:26:59 -0700557 board_init_r(gd->new_gd, 0);
558
559 /* NOTREACHED - board_init_r() does not return */
Allen Martin074b4552013-01-22 13:11:21 +0000560 return 0;
Simon Glassd7c8d8d2013-11-10 10:27:04 -0700561
562err:
563 printf("Error %d\n", ret);
564 return 1;
Simon Glass5ba8ef62011-10-03 19:26:45 +0000565}