os.c 12 KB

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