1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Copyright (c) 2011 The Chromium OS Authors.
4 */
5
6 #define _GNU_SOURCE
7
8 #include <dirent.h>
9 #include <errno.h>
10 #include <fcntl.h>
11 #include <getopt.h>
12 #include <setjmp.h>
13 #include <signal.h>
14 #include <stdio.h>
15 #include <stdint.h>
16 #include <stdlib.h>
17 #include <string.h>
18 #include <termios.h>
19 #include <time.h>
20 #include <ucontext.h>
21 #include <unistd.h>
22 #include <sys/mman.h>
23 #include <sys/stat.h>
24 #include <sys/time.h>
25 #include <sys/types.h>
26 #include <linux/compiler_attributes.h>
27 #include <linux/types.h>
28
29 #include <asm/getopt.h>
30 #include <asm/sections.h>
31 #include <asm/state.h>
32 #include <os.h>
33 #include <rtc_def.h>
34
35 /* Environment variable for time offset */
36 #define ENV_TIME_OFFSET "UBOOT_SB_TIME_OFFSET"
37
38 /* Operating System Interface */
39
40 struct os_mem_hdr {
41 size_t length; /* number of bytes in the block */
42 };
43
os_read(int fd,void * buf,size_t count)44 ssize_t os_read(int fd, void *buf, size_t count)
45 {
46 return read(fd, buf, count);
47 }
48
os_write(int fd,const void * buf,size_t count)49 ssize_t os_write(int fd, const void *buf, size_t count)
50 {
51 return write(fd, buf, count);
52 }
53
os_lseek(int fd,off_t offset,int whence)54 off_t os_lseek(int fd, off_t offset, int whence)
55 {
56 if (whence == OS_SEEK_SET)
57 whence = SEEK_SET;
58 else if (whence == OS_SEEK_CUR)
59 whence = SEEK_CUR;
60 else if (whence == OS_SEEK_END)
61 whence = SEEK_END;
62 else
63 os_exit(1);
64 return lseek(fd, offset, whence);
65 }
66
os_open(const char * pathname,int os_flags)67 int os_open(const char *pathname, int os_flags)
68 {
69 int flags;
70
71 switch (os_flags & OS_O_MASK) {
72 case OS_O_RDONLY:
73 default:
74 flags = O_RDONLY;
75 break;
76
77 case OS_O_WRONLY:
78 flags = O_WRONLY;
79 break;
80
81 case OS_O_RDWR:
82 flags = O_RDWR;
83 break;
84 }
85
86 if (os_flags & OS_O_CREAT)
87 flags |= O_CREAT;
88 if (os_flags & OS_O_TRUNC)
89 flags |= O_TRUNC;
90 /*
91 * During a cold reset execv() is used to relaunch the U-Boot binary.
92 * We must ensure that all files are closed in this case.
93 */
94 flags |= O_CLOEXEC;
95
96 return open(pathname, flags, 0777);
97 }
98
os_close(int fd)99 int os_close(int fd)
100 {
101 /* Do not close the console input */
102 if (fd)
103 return close(fd);
104 return -1;
105 }
106
os_unlink(const char * pathname)107 int os_unlink(const char *pathname)
108 {
109 return unlink(pathname);
110 }
111
os_exit(int exit_code)112 void os_exit(int exit_code)
113 {
114 exit(exit_code);
115 }
116
os_write_file(const char * fname,const void * buf,int size)117 int os_write_file(const char *fname, const void *buf, int size)
118 {
119 int fd;
120
121 fd = os_open(fname, OS_O_WRONLY | OS_O_CREAT | OS_O_TRUNC);
122 if (fd < 0) {
123 printf("Cannot open file '%s'\n", fname);
124 return -EIO;
125 }
126 if (os_write(fd, buf, size) != size) {
127 printf("Cannot write to file '%s'\n", fname);
128 os_close(fd);
129 return -EIO;
130 }
131 os_close(fd);
132
133 return 0;
134 }
135
os_read_file(const char * fname,void ** bufp,int * sizep)136 int os_read_file(const char *fname, void **bufp, int *sizep)
137 {
138 off_t size;
139 int ret = -EIO;
140 int fd;
141
142 fd = os_open(fname, OS_O_RDONLY);
143 if (fd < 0) {
144 printf("Cannot open file '%s'\n", fname);
145 goto err;
146 }
147 size = os_lseek(fd, 0, OS_SEEK_END);
148 if (size < 0) {
149 printf("Cannot seek to end of file '%s'\n", fname);
150 goto err;
151 }
152 if (os_lseek(fd, 0, OS_SEEK_SET) < 0) {
153 printf("Cannot seek to start of file '%s'\n", fname);
154 goto err;
155 }
156 *bufp = os_malloc(size);
157 if (!*bufp) {
158 printf("Not enough memory to read file '%s'\n", fname);
159 ret = -ENOMEM;
160 goto err;
161 }
162 if (os_read(fd, *bufp, size) != size) {
163 printf("Cannot read from file '%s'\n", fname);
164 goto err;
165 }
166 os_close(fd);
167 *sizep = size;
168
169 return 0;
170 err:
171 os_close(fd);
172 return ret;
173 }
174
175 /* Restore tty state when we exit */
176 static struct termios orig_term;
177 static bool term_setup;
178 static bool term_nonblock;
179
os_fd_restore(void)180 void os_fd_restore(void)
181 {
182 if (term_setup) {
183 int flags;
184
185 tcsetattr(0, TCSANOW, &orig_term);
186 if (term_nonblock) {
187 flags = fcntl(0, F_GETFL, 0);
188 fcntl(0, F_SETFL, flags & ~O_NONBLOCK);
189 }
190 term_setup = false;
191 }
192 }
193
os_sigint_handler(int sig)194 static void os_sigint_handler(int sig)
195 {
196 os_fd_restore();
197 signal(SIGINT, SIG_DFL);
198 raise(SIGINT);
199 }
200
os_signal_handler(int sig,siginfo_t * info,void * con)201 static void os_signal_handler(int sig, siginfo_t *info, void *con)
202 {
203 ucontext_t __maybe_unused *context = con;
204 unsigned long pc;
205
206 #if defined(__x86_64__)
207 pc = context->uc_mcontext.gregs[REG_RIP];
208 #elif defined(__aarch64__)
209 pc = context->uc_mcontext.pc;
210 #elif defined(__riscv)
211 pc = context->uc_mcontext.__gregs[REG_PC];
212 #else
213 const char msg[] =
214 "\nUnsupported architecture, cannot read program counter\n";
215
216 os_write(1, msg, sizeof(msg));
217 pc = 0;
218 #endif
219
220 os_signal_action(sig, pc);
221 }
222
os_setup_signal_handlers(void)223 int os_setup_signal_handlers(void)
224 {
225 struct sigaction act;
226
227 act.sa_sigaction = os_signal_handler;
228 sigemptyset(&act.sa_mask);
229 act.sa_flags = SA_SIGINFO | SA_NODEFER;
230 if (sigaction(SIGILL, &act, NULL) ||
231 sigaction(SIGBUS, &act, NULL) ||
232 sigaction(SIGSEGV, &act, NULL))
233 return -1;
234 return 0;
235 }
236
237 /* Put tty into raw mode so <tab> and <ctrl+c> work */
os_tty_raw(int fd,bool allow_sigs)238 void os_tty_raw(int fd, bool allow_sigs)
239 {
240 struct termios term;
241 int flags;
242
243 if (term_setup)
244 return;
245
246 /* If not a tty, don't complain */
247 if (tcgetattr(fd, &orig_term))
248 return;
249
250 term = orig_term;
251 term.c_iflag = IGNBRK | IGNPAR;
252 term.c_oflag = OPOST | ONLCR;
253 term.c_cflag = CS8 | CREAD | CLOCAL;
254 term.c_lflag = allow_sigs ? ISIG : 0;
255 if (tcsetattr(fd, TCSANOW, &term))
256 return;
257
258 flags = fcntl(fd, F_GETFL, 0);
259 if (!(flags & O_NONBLOCK)) {
260 if (fcntl(fd, F_SETFL, flags | O_NONBLOCK))
261 return;
262 term_nonblock = true;
263 }
264
265 term_setup = true;
266 atexit(os_fd_restore);
267 signal(SIGINT, os_sigint_handler);
268 }
269
270 /*
271 * Provide our own malloc so we don't use space in the sandbox ram_buf for
272 * allocations that are internal to sandbox, or need to be done before U-Boot's
273 * malloc() is ready.
274 */
os_malloc(size_t length)275 void *os_malloc(size_t length)
276 {
277 int page_size = getpagesize();
278 struct os_mem_hdr *hdr;
279
280 if (!length)
281 return NULL;
282 /*
283 * Use an address that is hopefully available to us so that pointers
284 * to this memory are fairly obvious. If we end up with a different
285 * address, that's fine too.
286 */
287 hdr = mmap((void *)0x10000000, length + page_size,
288 PROT_READ | PROT_WRITE | PROT_EXEC,
289 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
290 if (hdr == MAP_FAILED)
291 return NULL;
292 hdr->length = length;
293
294 return (void *)hdr + page_size;
295 }
296
os_free(void * ptr)297 void os_free(void *ptr)
298 {
299 int page_size = getpagesize();
300 struct os_mem_hdr *hdr;
301
302 if (ptr) {
303 hdr = ptr - page_size;
304 munmap(hdr, hdr->length + page_size);
305 }
306 }
307
308 /* These macros are from kernel.h but not accessible in this file */
309 #define ALIGN(x, a) __ALIGN_MASK((x), (typeof(x))(a) - 1)
310 #define __ALIGN_MASK(x, mask) (((x) + (mask)) & ~(mask))
311
312 /*
313 * Provide our own malloc so we don't use space in the sandbox ram_buf for
314 * allocations that are internal to sandbox, or need to be done before U-Boot's
315 * malloc() is ready.
316 */
os_realloc(void * ptr,size_t length)317 void *os_realloc(void *ptr, size_t length)
318 {
319 int page_size = getpagesize();
320 struct os_mem_hdr *hdr;
321 void *new_ptr;
322
323 /* Reallocating a NULL pointer is just an alloc */
324 if (!ptr)
325 return os_malloc(length);
326
327 /* Changing a length to 0 is just a free */
328 if (length) {
329 os_free(ptr);
330 return NULL;
331 }
332
333 /*
334 * If the new size is the same number of pages as the old, nothing to
335 * do. There isn't much point in shrinking things
336 */
337 hdr = ptr - page_size;
338 if (ALIGN(length, page_size) <= ALIGN(hdr->length, page_size))
339 return ptr;
340
341 /* We have to grow it, so allocate something new */
342 new_ptr = os_malloc(length);
343 memcpy(new_ptr, ptr, hdr->length);
344 os_free(ptr);
345
346 return new_ptr;
347 }
348
os_usleep(unsigned long usec)349 void os_usleep(unsigned long usec)
350 {
351 usleep(usec);
352 }
353
os_get_nsec(void)354 uint64_t __attribute__((no_instrument_function)) os_get_nsec(void)
355 {
356 #if defined(CLOCK_MONOTONIC) && defined(_POSIX_MONOTONIC_CLOCK)
357 struct timespec tp;
358 if (EINVAL == clock_gettime(CLOCK_MONOTONIC, &tp)) {
359 struct timeval tv;
360
361 gettimeofday(&tv, NULL);
362 tp.tv_sec = tv.tv_sec;
363 tp.tv_nsec = tv.tv_usec * 1000;
364 }
365 return tp.tv_sec * 1000000000ULL + tp.tv_nsec;
366 #else
367 struct timeval tv;
368 gettimeofday(&tv, NULL);
369 return tv.tv_sec * 1000000000ULL + tv.tv_usec * 1000;
370 #endif
371 }
372
373 static char *short_opts;
374 static struct option *long_opts;
375
os_parse_args(struct sandbox_state * state,int argc,char * argv[])376 int os_parse_args(struct sandbox_state *state, int argc, char *argv[])
377 {
378 struct sandbox_cmdline_option **sb_opt =
379 __u_boot_sandbox_option_start();
380 size_t num_options = __u_boot_sandbox_option_count();
381 size_t i;
382
383 int hidden_short_opt;
384 size_t si;
385
386 int c;
387
388 if (short_opts || long_opts)
389 return 1;
390
391 state->argc = argc;
392 state->argv = argv;
393
394 /* dynamically construct the arguments to the system getopt_long */
395 short_opts = os_malloc(sizeof(*short_opts) * num_options * 2 + 1);
396 long_opts = os_malloc(sizeof(*long_opts) * (num_options + 1));
397 if (!short_opts || !long_opts)
398 return 1;
399
400 /*
401 * getopt_long requires "val" to be unique (since that is what the
402 * func returns), so generate unique values automatically for flags
403 * that don't have a short option. pick 0x100 as that is above the
404 * single byte range (where ASCII/ISO-XXXX-X charsets live).
405 */
406 hidden_short_opt = 0x100;
407 si = 0;
408 for (i = 0; i < num_options; ++i) {
409 long_opts[i].name = sb_opt[i]->flag;
410 long_opts[i].has_arg = sb_opt[i]->has_arg ?
411 required_argument : no_argument;
412 long_opts[i].flag = NULL;
413
414 if (sb_opt[i]->flag_short) {
415 short_opts[si++] = long_opts[i].val = sb_opt[i]->flag_short;
416 if (long_opts[i].has_arg == required_argument)
417 short_opts[si++] = ':';
418 } else
419 long_opts[i].val = sb_opt[i]->flag_short = hidden_short_opt++;
420 }
421 short_opts[si] = '\0';
422
423 /* we need to handle output ourselves since u-boot provides printf */
424 opterr = 0;
425
426 memset(&long_opts[num_options], '\0', sizeof(*long_opts));
427 /*
428 * walk all of the options the user gave us on the command line,
429 * figure out what u-boot option structure they belong to (via
430 * the unique short val key), and call the appropriate callback.
431 */
432 while ((c = getopt_long(argc, argv, short_opts, long_opts, NULL)) != -1) {
433 for (i = 0; i < num_options; ++i) {
434 if (sb_opt[i]->flag_short == c) {
435 if (sb_opt[i]->callback(state, optarg)) {
436 state->parse_err = sb_opt[i]->flag;
437 return 0;
438 }
439 break;
440 }
441 }
442 if (i == num_options) {
443 /*
444 * store the faulting flag for later display. we have to
445 * store the flag itself as the getopt parsing itself is
446 * tricky: need to handle the following flags (assume all
447 * of the below are unknown):
448 * -a optopt='a' optind=<next>
449 * -abbbb optopt='a' optind=<this>
450 * -aaaaa optopt='a' optind=<this>
451 * --a optopt=0 optind=<this>
452 * as you can see, it is impossible to determine the exact
453 * faulting flag without doing the parsing ourselves, so
454 * we just report the specific flag that failed.
455 */
456 if (optopt) {
457 static char parse_err[3] = { '-', 0, '\0', };
458 parse_err[1] = optopt;
459 state->parse_err = parse_err;
460 } else
461 state->parse_err = argv[optind - 1];
462 break;
463 }
464 }
465
466 return 0;
467 }
468
os_dirent_free(struct os_dirent_node * node)469 void os_dirent_free(struct os_dirent_node *node)
470 {
471 struct os_dirent_node *next;
472
473 while (node) {
474 next = node->next;
475 os_free(node);
476 node = next;
477 }
478 }
479
os_dirent_ls(const char * dirname,struct os_dirent_node ** headp)480 int os_dirent_ls(const char *dirname, struct os_dirent_node **headp)
481 {
482 struct dirent *entry;
483 struct os_dirent_node *head, *node, *next;
484 struct stat buf;
485 DIR *dir;
486 int ret;
487 char *fname;
488 char *old_fname;
489 int len;
490 int dirlen;
491
492 *headp = NULL;
493 dir = opendir(dirname);
494 if (!dir)
495 return -1;
496
497 /* Create a buffer upfront, with typically sufficient size */
498 dirlen = strlen(dirname) + 2;
499 len = dirlen + 256;
500 fname = os_malloc(len);
501 if (!fname) {
502 ret = -ENOMEM;
503 goto done;
504 }
505
506 for (node = head = NULL;; node = next) {
507 errno = 0;
508 entry = readdir(dir);
509 if (!entry) {
510 ret = errno;
511 break;
512 }
513 next = os_malloc(sizeof(*node) + strlen(entry->d_name) + 1);
514 if (!next) {
515 os_dirent_free(head);
516 ret = -ENOMEM;
517 goto done;
518 }
519 if (dirlen + strlen(entry->d_name) > len) {
520 len = dirlen + strlen(entry->d_name);
521 old_fname = fname;
522 fname = os_realloc(fname, len);
523 if (!fname) {
524 os_free(old_fname);
525 os_free(next);
526 os_dirent_free(head);
527 ret = -ENOMEM;
528 goto done;
529 }
530 }
531 next->next = NULL;
532 strcpy(next->name, entry->d_name);
533 switch (entry->d_type) {
534 case DT_REG:
535 next->type = OS_FILET_REG;
536 break;
537 case DT_DIR:
538 next->type = OS_FILET_DIR;
539 break;
540 case DT_LNK:
541 next->type = OS_FILET_LNK;
542 break;
543 default:
544 next->type = OS_FILET_UNKNOWN;
545 }
546 next->size = 0;
547 snprintf(fname, len, "%s/%s", dirname, next->name);
548 if (!stat(fname, &buf))
549 next->size = buf.st_size;
550 if (node)
551 node->next = next;
552 else
553 head = next;
554 }
555 *headp = head;
556
557 done:
558 closedir(dir);
559 os_free(fname);
560 return ret;
561 }
562
563 const char *os_dirent_typename[OS_FILET_COUNT] = {
564 " ",
565 "SYM",
566 "DIR",
567 "???",
568 };
569
os_dirent_get_typename(enum os_dirent_t type)570 const char *os_dirent_get_typename(enum os_dirent_t type)
571 {
572 if (type >= OS_FILET_REG && type < OS_FILET_COUNT)
573 return os_dirent_typename[type];
574
575 return os_dirent_typename[OS_FILET_UNKNOWN];
576 }
577
os_get_filesize(const char * fname,loff_t * size)578 int os_get_filesize(const char *fname, loff_t *size)
579 {
580 struct stat buf;
581 int ret;
582
583 ret = stat(fname, &buf);
584 if (ret)
585 return ret;
586 *size = buf.st_size;
587 return 0;
588 }
589
os_putc(int ch)590 void os_putc(int ch)
591 {
592 putchar(ch);
593 }
594
os_puts(const char * str)595 void os_puts(const char *str)
596 {
597 while (*str)
598 os_putc(*str++);
599 }
600
os_write_ram_buf(const char * fname)601 int os_write_ram_buf(const char *fname)
602 {
603 struct sandbox_state *state = state_get_current();
604 int fd, ret;
605
606 fd = open(fname, O_CREAT | O_WRONLY, 0777);
607 if (fd < 0)
608 return -ENOENT;
609 ret = write(fd, state->ram_buf, state->ram_size);
610 close(fd);
611 if (ret != state->ram_size)
612 return -EIO;
613
614 return 0;
615 }
616
os_read_ram_buf(const char * fname)617 int os_read_ram_buf(const char *fname)
618 {
619 struct sandbox_state *state = state_get_current();
620 int fd, ret;
621 loff_t size;
622
623 ret = os_get_filesize(fname, &size);
624 if (ret < 0)
625 return ret;
626 if (size != state->ram_size)
627 return -ENOSPC;
628 fd = open(fname, O_RDONLY);
629 if (fd < 0)
630 return -ENOENT;
631
632 ret = read(fd, state->ram_buf, state->ram_size);
633 close(fd);
634 if (ret != state->ram_size)
635 return -EIO;
636
637 return 0;
638 }
639
make_exec(char * fname,const void * data,int size)640 static int make_exec(char *fname, const void *data, int size)
641 {
642 int fd;
643
644 strcpy(fname, "/tmp/u-boot.jump.XXXXXX");
645 fd = mkstemp(fname);
646 if (fd < 0)
647 return -ENOENT;
648 if (write(fd, data, size) < 0)
649 return -EIO;
650 close(fd);
651 if (chmod(fname, 0777))
652 return -ENOEXEC;
653
654 return 0;
655 }
656
657 /**
658 * add_args() - Allocate a new argv with the given args
659 *
660 * This is used to create a new argv array with all the old arguments and some
661 * new ones that are passed in
662 *
663 * @argvp: Returns newly allocated args list
664 * @add_args: Arguments to add, each a string
665 * @count: Number of arguments in @add_args
666 * @return 0 if OK, -ENOMEM if out of memory
667 */
add_args(char *** argvp,char * add_args[],int count)668 static int add_args(char ***argvp, char *add_args[], int count)
669 {
670 char **argv, **ap;
671 int argc;
672
673 for (argc = 0; (*argvp)[argc]; argc++)
674 ;
675
676 argv = os_malloc((argc + count + 1) * sizeof(char *));
677 if (!argv) {
678 printf("Out of memory for %d argv\n", count);
679 return -ENOMEM;
680 }
681 for (ap = *argvp, argc = 0; *ap; ap++) {
682 char *arg = *ap;
683
684 /* Drop args that we don't want to propagate */
685 if (*arg == '-' && strlen(arg) == 2) {
686 switch (arg[1]) {
687 case 'j':
688 case 'm':
689 ap++;
690 continue;
691 }
692 } else if (!strcmp(arg, "--rm_memory")) {
693 ap++;
694 continue;
695 }
696 argv[argc++] = arg;
697 }
698
699 memcpy(argv + argc, add_args, count * sizeof(char *));
700 argv[argc + count] = NULL;
701
702 *argvp = argv;
703 return 0;
704 }
705
706 /**
707 * os_jump_to_file() - Jump to a new program
708 *
709 * This saves the memory buffer, sets up arguments to the new process, then
710 * execs it.
711 *
712 * @fname: Filename to exec
713 * @return does not return on success, any return value is an error
714 */
os_jump_to_file(const char * fname,bool delete_it)715 static int os_jump_to_file(const char *fname, bool delete_it)
716 {
717 struct sandbox_state *state = state_get_current();
718 char mem_fname[30];
719 int fd, err;
720 char *extra_args[5];
721 char **argv = state->argv;
722 int argc;
723 #ifdef DEBUG
724 int i;
725 #endif
726
727 strcpy(mem_fname, "/tmp/u-boot.mem.XXXXXX");
728 fd = mkstemp(mem_fname);
729 if (fd < 0)
730 return -ENOENT;
731 close(fd);
732 err = os_write_ram_buf(mem_fname);
733 if (err)
734 return err;
735
736 os_fd_restore();
737
738 argc = 0;
739 if (delete_it) {
740 extra_args[argc++] = "-j";
741 extra_args[argc++] = (char *)fname;
742 }
743 extra_args[argc++] = "-m";
744 extra_args[argc++] = mem_fname;
745 if (state->ram_buf_rm)
746 extra_args[argc++] = "--rm_memory";
747 err = add_args(&argv, extra_args, argc);
748 if (err)
749 return err;
750 argv[0] = (char *)fname;
751
752 #ifdef DEBUG
753 for (i = 0; argv[i]; i++)
754 printf("%d %s\n", i, argv[i]);
755 #endif
756
757 if (state_uninit())
758 os_exit(2);
759
760 err = execv(fname, argv);
761 os_free(argv);
762 if (err) {
763 perror("Unable to run image");
764 printf("Image filename '%s'\n", fname);
765 return err;
766 }
767
768 if (delete_it)
769 return unlink(fname);
770
771 return -EFAULT;
772 }
773
os_jump_to_image(const void * dest,int size)774 int os_jump_to_image(const void *dest, int size)
775 {
776 char fname[30];
777 int err;
778
779 err = make_exec(fname, dest, size);
780 if (err)
781 return err;
782
783 return os_jump_to_file(fname, true);
784 }
785
os_find_u_boot(char * fname,int maxlen,bool use_img)786 int os_find_u_boot(char *fname, int maxlen, bool use_img)
787 {
788 struct sandbox_state *state = state_get_current();
789 const char *progname = state->argv[0];
790 int len = strlen(progname);
791 const char *suffix;
792 char *p;
793 int fd;
794
795 if (len >= maxlen || len < 4)
796 return -ENOSPC;
797
798 strcpy(fname, progname);
799 suffix = fname + len - 4;
800
801 /* If we are TPL, boot to SPL */
802 if (!strcmp(suffix, "-tpl")) {
803 fname[len - 3] = 's';
804 fd = os_open(fname, O_RDONLY);
805 if (fd >= 0) {
806 close(fd);
807 return 0;
808 }
809
810 /* Look for 'u-boot-spl' in the spl/ directory */
811 p = strstr(fname, "/spl/");
812 if (p) {
813 p[1] = 's';
814 fd = os_open(fname, O_RDONLY);
815 if (fd >= 0) {
816 close(fd);
817 return 0;
818 }
819 }
820 return -ENOENT;
821 }
822
823 /* Look for 'u-boot' in the same directory as 'u-boot-spl' */
824 if (!strcmp(suffix, "-spl")) {
825 fname[len - 4] = '\0';
826 fd = os_open(fname, O_RDONLY);
827 if (fd >= 0) {
828 close(fd);
829 return 0;
830 }
831 }
832
833 /* Look for 'u-boot' in the parent directory of spl/ */
834 p = strstr(fname, "spl/");
835 if (p) {
836 /* Remove the "spl" characters */
837 memmove(p, p + 4, strlen(p + 4) + 1);
838 if (use_img)
839 strcat(p, ".img");
840 fd = os_open(fname, O_RDONLY);
841 if (fd >= 0) {
842 close(fd);
843 return 0;
844 }
845 }
846
847 return -ENOENT;
848 }
849
os_spl_to_uboot(const char * fname)850 int os_spl_to_uboot(const char *fname)
851 {
852 struct sandbox_state *state = state_get_current();
853
854 /* U-Boot will delete ram buffer after read: "--rm_memory"*/
855 state->ram_buf_rm = true;
856
857 return os_jump_to_file(fname, false);
858 }
859
os_get_time_offset(void)860 long os_get_time_offset(void)
861 {
862 const char *offset;
863
864 offset = getenv(ENV_TIME_OFFSET);
865 if (offset)
866 return strtol(offset, NULL, 0);
867 return 0;
868 }
869
os_set_time_offset(long offset)870 void os_set_time_offset(long offset)
871 {
872 char buf[21];
873 int ret;
874
875 snprintf(buf, sizeof(buf), "%ld", offset);
876 ret = setenv(ENV_TIME_OFFSET, buf, true);
877 if (ret)
878 printf("Could not set environment variable %s\n",
879 ENV_TIME_OFFSET);
880 }
881
os_localtime(struct rtc_time * rt)882 void os_localtime(struct rtc_time *rt)
883 {
884 time_t t = time(NULL);
885 struct tm *tm;
886
887 tm = localtime(&t);
888 rt->tm_sec = tm->tm_sec;
889 rt->tm_min = tm->tm_min;
890 rt->tm_hour = tm->tm_hour;
891 rt->tm_mday = tm->tm_mday;
892 rt->tm_mon = tm->tm_mon + 1;
893 rt->tm_year = tm->tm_year + 1900;
894 rt->tm_wday = tm->tm_wday;
895 rt->tm_yday = tm->tm_yday;
896 rt->tm_isdst = tm->tm_isdst;
897 }
898
os_abort(void)899 void os_abort(void)
900 {
901 abort();
902 }
903
os_mprotect_allow(void * start,size_t len)904 int os_mprotect_allow(void *start, size_t len)
905 {
906 int page_size = getpagesize();
907
908 /* Move start to the start of a page, len to the end */
909 start = (void *)(((ulong)start) & ~(page_size - 1));
910 len = (len + page_size * 2) & ~(page_size - 1);
911
912 return mprotect(start, len, PROT_READ | PROT_WRITE);
913 }
914
os_find_text_base(void)915 void *os_find_text_base(void)
916 {
917 char line[500];
918 void *base = NULL;
919 int len;
920 int fd;
921
922 /*
923 * This code assumes that the first line of /proc/self/maps holds
924 * information about the text, for example:
925 *
926 * 5622d9907000-5622d9a55000 r-xp 00000000 08:01 15067168 u-boot
927 *
928 * The first hex value is assumed to be the address.
929 *
930 * This is tested in Linux 4.15.
931 */
932 fd = open("/proc/self/maps", O_RDONLY);
933 if (fd == -1)
934 return NULL;
935 len = read(fd, line, sizeof(line));
936 if (len > 0) {
937 char *end = memchr(line, '-', len);
938
939 if (end) {
940 uintptr_t addr;
941
942 *end = '\0';
943 if (sscanf(line, "%zx", &addr) == 1)
944 base = (void *)addr;
945 }
946 }
947 close(fd);
948
949 return base;
950 }
951
os_relaunch(char * argv[])952 void os_relaunch(char *argv[])
953 {
954 execv(argv[0], argv);
955 os_exit(1);
956 }
957