arch/sandbox/cpu/os.c

   1 /*
   2  * Copyright (c) 2011 The Chromium OS Authors.
   3  * SPDX-License-Identifier:     GPL-2.0+
   4  */
   5
   6 #include <dirent.h>
   7 #include <errno.h>
   8 #include <fcntl.h>
   9 #include <getopt.h>
  10 #include <stdio.h>
  11 #include <stdint.h>
  12 #include <stdlib.h>
  13 #include <string.h>
  14 #include <termios.h>
  15 #include <time.h>
  16 #include <unistd.h>
  17 #include <sys/mman.h>
  18 #include <sys/stat.h>
  19 #include <sys/time.h>
  20 #include <sys/types.h>
  21 #include <linux/types.h>
  22
  23 #include <asm/getopt.h>
  24 #include <asm/sections.h>
  25 #include <asm/state.h>
  26 #include <os.h>
  27
  28 /* Operating System Interface */
  29
  30 struct os_mem_hdr {
  31         size_t length;          /* number of bytes in the block */
  32 };
  33
  34 ssize_t os_read(int fd, void *buf, size_t count)
  35 {
  36         return read(fd, buf, count);
  37 }
  38
  39 ssize_t os_read_no_block(int fd, void *buf, size_t count)
  40 {
  41         const int flags = fcntl(fd, F_GETFL, 0);
  42
  43         fcntl(fd, F_SETFL, flags | O_NONBLOCK);
  44         return os_read(fd, buf, count);
  45 }
  46
  47 ssize_t os_write(int fd, const void *buf, size_t count)
  48 {
  49         return write(fd, buf, count);
  50 }
  51
  52 off_t os_lseek(int fd, off_t offset, int whence)
  53 {
  54         if (whence == OS_SEEK_SET)
  55                 whence = SEEK_SET;
  56         else if (whence == OS_SEEK_CUR)
  57                 whence = SEEK_CUR;
  58         else if (whence == OS_SEEK_END)
  59                 whence = SEEK_END;
  60         else
  61                 os_exit(1);
  62         return lseek(fd, offset, whence);
  63 }
  64
  65 int os_open(const char *pathname, int os_flags)
  66 {
  67         int flags;
  68
  69         switch (os_flags & OS_O_MASK) {
  70         case OS_O_RDONLY:
  71         default:
  72                 flags = O_RDONLY;
  73                 break;
  74
  75         case OS_O_WRONLY:
  76                 flags = O_WRONLY;
  77                 break;
  78
  79         case OS_O_RDWR:
  80                 flags = O_RDWR;
  81                 break;
  82         }
  83
  84         if (os_flags & OS_O_CREAT)
  85                 flags |= O_CREAT;
  86
  87         return open(pathname, flags, 0777);
  88 }
  89
  90 int os_close(int fd)
  91 {
  92         return close(fd);
  93 }
  94
  95 int os_unlink(const char *pathname)
  96 {
  97         return unlink(pathname);
  98 }
  99
 100 void os_exit(int exit_code)
 101 {
 102         exit(exit_code);
 103 }
 104
 105 /* Restore tty state when we exit */
 106 static struct termios orig_term;
 107 static bool term_setup;
 108
 109 static void os_fd_restore(void)
 110 {
 111         if (term_setup)
 112                 tcsetattr(0, TCSANOW, &orig_term);
 113 }
 114
 115 /* Put tty into raw mode so <tab> and <ctrl+c> work */
 116 void os_tty_raw(int fd, bool allow_sigs)
 117 {
 118         struct termios term;
 119
 120         if (term_setup)
 121                 return;
 122         term_setup = true;
 123
 124         /* If not a tty, don't complain */
 125         if (tcgetattr(fd, &orig_term))
 126                 return;
 127
 128         term = orig_term;
 129         term.c_iflag = IGNBRK | IGNPAR;
 130         term.c_oflag = OPOST | ONLCR;
 131         term.c_cflag = CS8 | CREAD | CLOCAL;
 132         term.c_lflag = allow_sigs ? ISIG : 0;
 133         if (tcsetattr(fd, TCSANOW, &term))
 134                 return;
 135
 136         atexit(os_fd_restore);
 137 }
 138
 139 void *os_malloc(size_t length)
 140 {
 141         struct os_mem_hdr *hdr;
 142
 143         hdr = mmap(NULL, length + sizeof(*hdr), PROT_READ | PROT_WRITE,
 144                    MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
 145         if (hdr == MAP_FAILED)
 146                 return NULL;
 147         hdr->length = length;
 148
 149         return hdr + 1;
 150 }
 151
 152 void os_free(void *ptr)
 153 {
 154         struct os_mem_hdr *hdr = ptr;
 155
 156         hdr--;
 157         if (ptr)
 158                 munmap(hdr, hdr->length + sizeof(*hdr));
 159 }
 160
 161 void *os_realloc(void *ptr, size_t length)
 162 {
 163         struct os_mem_hdr *hdr = ptr;
 164         void *buf = NULL;
 165
 166         hdr--;
 167         if (length != 0) {
 168                 buf = os_malloc(length);
 169                 if (!buf)
 170                         return buf;
 171                 if (ptr) {
 172                         if (length > hdr->length)
 173                                 length = hdr->length;
 174                         memcpy(buf, ptr, length);
 175                 }
 176         }
 177         os_free(ptr);
 178
 179         return buf;
 180 }
 181
 182 void os_usleep(unsigned long usec)
 183 {
 184         usleep(usec);
 185 }
 186
 187 uint64_t __attribute__((no_instrument_function)) os_get_nsec(void)
 188 {
 189 #if defined(CLOCK_MONOTONIC) && defined(_POSIX_MONOTONIC_CLOCK)
 190         struct timespec tp;
 191         if (EINVAL == clock_gettime(CLOCK_MONOTONIC, &tp)) {
 192                 struct timeval tv;
 193
 194                 gettimeofday(&tv, NULL);
 195                 tp.tv_sec = tv.tv_sec;
 196                 tp.tv_nsec = tv.tv_usec * 1000;
 197         }
 198         return tp.tv_sec * 1000000000ULL + tp.tv_nsec;
 199 #else
 200         struct timeval tv;
 201         gettimeofday(&tv, NULL);
 202         return tv.tv_sec * 1000000000ULL + tv.tv_usec * 1000;
 203 #endif
 204 }
 205
 206 static char *short_opts;
 207 static struct option *long_opts;
 208
 209 int os_parse_args(struct sandbox_state *state, int argc, char *argv[])
 210 {
 211         struct sandbox_cmdline_option **sb_opt = __u_boot_sandbox_option_start;
 212         size_t num_options = __u_boot_sandbox_option_count();
 213         size_t i;
 214
 215         int hidden_short_opt;
 216         size_t si;
 217
 218         int c;
 219
 220         if (short_opts || long_opts)
 221                 return 1;
 222
 223         state->argc = argc;
 224         state->argv = argv;
 225
 226         /* dynamically construct the arguments to the system getopt_long */
 227         short_opts = os_malloc(sizeof(*short_opts) * num_options * 2 + 1);
 228         long_opts = os_malloc(sizeof(*long_opts) * num_options);
 229         if (!short_opts || !long_opts)
 230                 return 1;
 231
 232         /*
 233          * getopt_long requires "val" to be unique (since that is what the
 234          * func returns), so generate unique values automatically for flags
 235          * that don't have a short option.  pick 0x100 as that is above the
 236          * single byte range (where ASCII/ISO-XXXX-X charsets live).
 237          */
 238         hidden_short_opt = 0x100;
 239         si = 0;
 240         for (i = 0; i < num_options; ++i) {
 241                 long_opts[i].name = sb_opt[i]->flag;
 242                 long_opts[i].has_arg = sb_opt[i]->has_arg ?
 243                         required_argument : no_argument;
 244                 long_opts[i].flag = NULL;
 245
 246                 if (sb_opt[i]->flag_short) {
 247                         short_opts[si++] = long_opts[i].val = sb_opt[i]->flag_short;
 248                         if (long_opts[i].has_arg == required_argument)
 249                                 short_opts[si++] = ':';
 250                 } else
 251                         long_opts[i].val = sb_opt[i]->flag_short = hidden_short_opt++;
 252         }
 253         short_opts[si] = '\0';
 254
 255         /* we need to handle output ourselves since u-boot provides printf */
 256         opterr = 0;
 257
 258         /*
 259          * walk all of the options the user gave us on the command line,
 260          * figure out what u-boot option structure they belong to (via
 261          * the unique short val key), and call the appropriate callback.
 262          */
 263         while ((c = getopt_long(argc, argv, short_opts, long_opts, NULL)) != -1) {
 264                 for (i = 0; i < num_options; ++i) {
 265                         if (sb_opt[i]->flag_short == c) {
 266                                 if (sb_opt[i]->callback(state, optarg)) {
 267                                         state->parse_err = sb_opt[i]->flag;
 268                                         return 0;
 269                                 }
 270                                 break;
 271                         }
 272                 }
 273                 if (i == num_options) {
 274                         /*
 275                          * store the faulting flag for later display.  we have to
 276                          * store the flag itself as the getopt parsing itself is
 277                          * tricky: need to handle the following flags (assume all
 278                          * of the below are unknown):
 279                          *   -a        optopt='a' optind=<next>
 280                          *   -abbbb    optopt='a' optind=<this>
 281                          *   -aaaaa    optopt='a' optind=<this>
 282                          *   --a       optopt=0   optind=<this>
 283                          * as you can see, it is impossible to determine the exact
 284                          * faulting flag without doing the parsing ourselves, so
 285                          * we just report the specific flag that failed.
 286                          */
 287                         if (optopt) {
 288                                 static char parse_err[3] = { '-', 0, '\0', };
 289                                 parse_err[1] = optopt;
 290                                 state->parse_err = parse_err;
 291                         } else
 292                                 state->parse_err = argv[optind - 1];
 293                         break;
 294                 }
 295         }
 296
 297         return 0;
 298 }
 299
 300 void os_dirent_free(struct os_dirent_node *node)
 301 {
 302         struct os_dirent_node *next;
 303
 304         while (node) {
 305                 next = node->next;
 306                 free(node);
 307                 node = next;
 308         }
 309 }
 310
 311 int os_dirent_ls(const char *dirname, struct os_dirent_node **headp)
 312 {
 313         struct dirent entry, *result;
 314         struct os_dirent_node *head, *node, *next;
 315         struct stat buf;
 316         DIR *dir;
 317         int ret;
 318         char *fname;
 319         int len;
 320
 321         *headp = NULL;
 322         dir = opendir(dirname);
 323         if (!dir)
 324                 return -1;
 325
 326         /* Create a buffer for the maximum filename length */
 327         len = sizeof(entry.d_name) + strlen(dirname) + 2;
 328         fname = malloc(len);
 329         if (!fname) {
 330                 ret = -ENOMEM;
 331                 goto done;
 332         }
 333
 334         for (node = head = NULL;; node = next) {
 335                 ret = readdir_r(dir, &entry, &result);
 336                 if (ret || !result)
 337                         break;
 338                 next = malloc(sizeof(*node) + strlen(entry.d_name) + 1);
 339                 if (!next) {
 340                         os_dirent_free(head);
 341                         ret = -ENOMEM;
 342                         goto done;
 343                 }
 344                 next->next = NULL;
 345                 strcpy(next->name, entry.d_name);
 346                 switch (entry.d_type) {
 347                 case DT_REG:
 348                         next->type = OS_FILET_REG;
 349                         break;
 350                 case DT_DIR:
 351                         next->type = OS_FILET_DIR;
 352                         break;
 353                 case DT_LNK:
 354                         next->type = OS_FILET_LNK;
 355                         break;
 356                 }
 357                 next->size = 0;
 358                 snprintf(fname, len, "%s/%s", dirname, next->name);
 359                 if (!stat(fname, &buf))
 360                         next->size = buf.st_size;
 361                 if (node)
 362                         node->next = next;
 363                 if (!head)
 364                         head = node;
 365         }
 366         *headp = head;
 367
 368 done:
 369         closedir(dir);
 370         return ret;
 371 }
 372
 373 const char *os_dirent_typename[OS_FILET_COUNT] = {
 374         "   ",
 375         "SYM",
 376         "DIR",
 377         "???",
 378 };
 379
 380 const char *os_dirent_get_typename(enum os_dirent_t type)
 381 {
 382         if (type >= 0 && type < OS_FILET_COUNT)
 383                 return os_dirent_typename[type];
 384
 385         return os_dirent_typename[OS_FILET_UNKNOWN];
 386 }
 387
 388 ssize_t os_get_filesize(const char *fname)
 389 {
 390         struct stat buf;
 391         int ret;
 392
 393         ret = stat(fname, &buf);
 394         if (ret)
 395                 return ret;
 396         return buf.st_size;
 397 }
 398
 399 void os_putc(int ch)
 400 {
 401         putchar(ch);
 402 }
 403
 404 void os_puts(const char *str)
 405 {
 406         while (*str)
 407                 os_putc(*str++);
 408 }
 409
 410 int os_write_ram_buf(const char *fname)
 411 {
 412         struct sandbox_state *state = state_get_current();
 413         int fd, ret;
 414
 415         fd = open(fname, O_CREAT | O_WRONLY, 0777);
 416         if (fd < 0)
 417                 return -ENOENT;
 418         ret = write(fd, state->ram_buf, state->ram_size);
 419         close(fd);
 420         if (ret != state->ram_size)
 421                 return -EIO;
 422
 423         return 0;
 424 }
 425
 426 int os_read_ram_buf(const char *fname)
 427 {
 428         struct sandbox_state *state = state_get_current();
 429         int fd, ret;
 430         int size;
 431
 432         size = os_get_filesize(fname);
 433         if (size < 0)
 434                 return -ENOENT;
 435         if (size != state->ram_size)
 436                 return -ENOSPC;
 437         fd = open(fname, O_RDONLY);
 438         if (fd < 0)
 439                 return -ENOENT;
 440
 441         ret = read(fd, state->ram_buf, state->ram_size);
 442         close(fd);
 443         if (ret != state->ram_size)
 444                 return -EIO;
 445
 446         return 0;
 447 }
 448
 449 static int make_exec(char *fname, const void *data, int size)
 450 {
 451         int fd;
 452
 453         strcpy(fname, "/tmp/u-boot.jump.XXXXXX");
 454         fd = mkstemp(fname);
 455         if (fd < 0)
 456                 return -ENOENT;
 457         if (write(fd, data, size) < 0)
 458                 return -EIO;
 459         close(fd);
 460         if (chmod(fname, 0777))
 461                 return -ENOEXEC;
 462
 463         return 0;
 464 }
 465
 466 static int add_args(char ***argvp, const char *add_args[], int count)
 467 {
 468         char **argv;
 469         int argc;
 470
 471         for (argv = *argvp, argc = 0; (*argvp)[argc]; argc++)
 472                 ;
 473
 474         argv = malloc((argc + count + 1) * sizeof(char *));
 475         if (!argv) {
 476                 printf("Out of memory for %d argv\n", count);
 477                 return -ENOMEM;
 478         }
 479         memcpy(argv, *argvp, argc * sizeof(char *));
 480         memcpy(argv + argc, add_args, count * sizeof(char *));
 481         argv[argc + count] = NULL;
 482
 483         *argvp = argv;
 484         return 0;
 485 }
 486
 487 int os_jump_to_image(const void *dest, int size)
 488 {
 489         struct sandbox_state *state = state_get_current();
 490         char fname[30], mem_fname[30];
 491         int fd, err;
 492         const char *extra_args[5];
 493         char **argv = state->argv;
 494 #ifdef DEBUG
 495         int argc, i;
 496 #endif
 497
 498         err = make_exec(fname, dest, size);
 499         if (err)
 500                 return err;
 501
 502         strcpy(mem_fname, "/tmp/u-boot.mem.XXXXXX");
 503         fd = mkstemp(mem_fname);
 504         if (fd < 0)
 505                 return -ENOENT;
 506         close(fd);
 507         err = os_write_ram_buf(mem_fname);
 508         if (err)
 509                 return err;
 510
 511         os_fd_restore();
 512
 513         extra_args[0] = "-j";
 514         extra_args[1] = fname;
 515         extra_args[2] = "-m";
 516         extra_args[3] = mem_fname;
 517         extra_args[4] = "--rm_memory";
 518         err = add_args(&argv, extra_args,
 519                        sizeof(extra_args) / sizeof(extra_args[0]));
 520         if (err)
 521                 return err;
 522
 523 #ifdef DEBUG
 524         for (i = 0; argv[i]; i++)
 525                 printf("%d %s\n", i, argv[i]);
 526 #endif
 527
 528         if (state_uninit())
 529                 os_exit(2);
 530
 531         err = execv(fname, argv);
 532         free(argv);
 533         if (err)
 534                 return err;
 535
 536         return unlink(fname);
 537 }