arch/sandbox/cpu/os.c

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