sandbox: Add options to clean up temporary files
[karo-tx-uboot.git] / 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                 strcpy(next->name, entry.d_name);
345                 switch (entry.d_type) {
346                 case DT_REG:
347                         next->type = OS_FILET_REG;
348                         break;
349                 case DT_DIR:
350                         next->type = OS_FILET_DIR;
351                         break;
352                 case DT_LNK:
353                         next->type = OS_FILET_LNK;
354                         break;
355                 }
356                 next->size = 0;
357                 snprintf(fname, len, "%s/%s", dirname, next->name);
358                 if (!stat(fname, &buf))
359                         next->size = buf.st_size;
360                 if (node)
361                         node->next = next;
362                 if (!head)
363                         head = node;
364         }
365         *headp = head;
366
367 done:
368         closedir(dir);
369         return ret;
370 }
371
372 const char *os_dirent_typename[OS_FILET_COUNT] = {
373         "   ",
374         "SYM",
375         "DIR",
376         "???",
377 };
378
379 const char *os_dirent_get_typename(enum os_dirent_t type)
380 {
381         if (type >= 0 && type < OS_FILET_COUNT)
382                 return os_dirent_typename[type];
383
384         return os_dirent_typename[OS_FILET_UNKNOWN];
385 }
386
387 ssize_t os_get_filesize(const char *fname)
388 {
389         struct stat buf;
390         int ret;
391
392         ret = stat(fname, &buf);
393         if (ret)
394                 return ret;
395         return buf.st_size;
396 }
397
398 void os_putc(int ch)
399 {
400         putchar(ch);
401 }
402
403 void os_puts(const char *str)
404 {
405         while (*str)
406                 os_putc(*str++);
407 }
408
409 int os_write_ram_buf(const char *fname)
410 {
411         struct sandbox_state *state = state_get_current();
412         int fd, ret;
413
414         fd = open(fname, O_CREAT | O_WRONLY, 0777);
415         if (fd < 0)
416                 return -ENOENT;
417         ret = write(fd, state->ram_buf, state->ram_size);
418         close(fd);
419         if (ret != state->ram_size)
420                 return -EIO;
421
422         return 0;
423 }
424
425 int os_read_ram_buf(const char *fname)
426 {
427         struct sandbox_state *state = state_get_current();
428         int fd, ret;
429         int size;
430
431         size = os_get_filesize(fname);
432         if (size < 0)
433                 return -ENOENT;
434         if (size != state->ram_size)
435                 return -ENOSPC;
436         fd = open(fname, O_RDONLY);
437         if (fd < 0)
438                 return -ENOENT;
439
440         ret = read(fd, state->ram_buf, state->ram_size);
441         close(fd);
442         if (ret != state->ram_size)
443                 return -EIO;
444
445         return 0;
446 }
447
448 static int make_exec(char *fname, const void *data, int size)
449 {
450         int fd;
451
452         strcpy(fname, "/tmp/u-boot.jump.XXXXXX");
453         fd = mkstemp(fname);
454         if (fd < 0)
455                 return -ENOENT;
456         if (write(fd, data, size) < 0)
457                 return -EIO;
458         close(fd);
459         if (chmod(fname, 0777))
460                 return -ENOEXEC;
461
462         return 0;
463 }
464
465 static int add_args(char ***argvp, const char *add_args[], int count)
466 {
467         char **argv;
468         int argc;
469
470         for (argv = *argvp, argc = 0; (*argvp)[argc]; argc++)
471                 ;
472
473         argv = malloc((argc + count + 1) * sizeof(char *));
474         if (!argv) {
475                 printf("Out of memory for %d argv\n", count);
476                 return -ENOMEM;
477         }
478         memcpy(argv, *argvp, argc * sizeof(char *));
479         memcpy(argv + argc, add_args, count * sizeof(char *));
480         argv[argc + count] = NULL;
481
482         *argvp = argv;
483         return 0;
484 }
485
486 int os_jump_to_image(const void *dest, int size)
487 {
488         struct sandbox_state *state = state_get_current();
489         char fname[30], mem_fname[30];
490         int fd, err;
491         const char *extra_args[5];
492         char **argv = state->argv;
493 #ifdef DEBUG
494         int argc, i;
495 #endif
496
497         err = make_exec(fname, dest, size);
498         if (err)
499                 return err;
500
501         strcpy(mem_fname, "/tmp/u-boot.mem.XXXXXX");
502         fd = mkstemp(mem_fname);
503         if (fd < 0)
504                 return -ENOENT;
505         close(fd);
506         err = os_write_ram_buf(mem_fname);
507         if (err)
508                 return err;
509
510         os_fd_restore();
511
512         extra_args[0] = "-j";
513         extra_args[1] = fname;
514         extra_args[2] = "-m";
515         extra_args[3] = mem_fname;
516         extra_args[4] = "--rm_memory";
517         err = add_args(&argv, extra_args,
518                        sizeof(extra_args) / sizeof(extra_args[0]));
519         if (err)
520                 return err;
521
522 #ifdef DEBUG
523         for (i = 0; argv[i]; i++)
524                 printf("%d %s\n", i, argv[i]);
525 #endif
526
527         if (state_uninit())
528                 os_exit(2);
529
530         err = execv(fname, argv);
531         free(argv);
532         if (err)
533                 return err;
534
535         return unlink(fname);
536 }