unit-test: make "test -e" test independent of $CWD
[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
108 static void os_fd_restore(void)
109 {
110         tcsetattr(0, TCSANOW, &orig_term);
111 }
112
113 /* Put tty into raw mode so <tab> and <ctrl+c> work */
114 void os_tty_raw(int fd)
115 {
116         static int setup = 0;
117         struct termios term;
118
119         if (setup)
120                 return;
121         setup = 1;
122
123         /* If not a tty, don't complain */
124         if (tcgetattr(fd, &orig_term))
125                 return;
126
127         term = orig_term;
128         term.c_iflag = IGNBRK | IGNPAR;
129         term.c_oflag = OPOST | ONLCR;
130         term.c_cflag = CS8 | CREAD | CLOCAL;
131         term.c_lflag = 0;
132         if (tcsetattr(fd, TCSANOW, &term))
133                 return;
134
135         atexit(os_fd_restore);
136 }
137
138 void *os_malloc(size_t length)
139 {
140         struct os_mem_hdr *hdr;
141
142         hdr = mmap(NULL, length + sizeof(*hdr), PROT_READ | PROT_WRITE,
143                    MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
144         if (hdr == MAP_FAILED)
145                 return NULL;
146         hdr->length = length;
147
148         return hdr + 1;
149 }
150
151 void os_free(void *ptr)
152 {
153         struct os_mem_hdr *hdr = ptr;
154
155         hdr--;
156         if (ptr)
157                 munmap(hdr, hdr->length + sizeof(*hdr));
158 }
159
160 void *os_realloc(void *ptr, size_t length)
161 {
162         struct os_mem_hdr *hdr = ptr;
163         void *buf = NULL;
164
165         hdr--;
166         if (length != 0) {
167                 buf = os_malloc(length);
168                 if (!buf)
169                         return buf;
170                 if (ptr) {
171                         if (length > hdr->length)
172                                 length = hdr->length;
173                         memcpy(buf, ptr, length);
174                 }
175         }
176         os_free(ptr);
177
178         return buf;
179 }
180
181 void os_usleep(unsigned long usec)
182 {
183         usleep(usec);
184 }
185
186 uint64_t __attribute__((no_instrument_function)) os_get_nsec(void)
187 {
188 #if defined(CLOCK_MONOTONIC) && defined(_POSIX_MONOTONIC_CLOCK)
189         struct timespec tp;
190         if (EINVAL == clock_gettime(CLOCK_MONOTONIC, &tp)) {
191                 struct timeval tv;
192
193                 gettimeofday(&tv, NULL);
194                 tp.tv_sec = tv.tv_sec;
195                 tp.tv_nsec = tv.tv_usec * 1000;
196         }
197         return tp.tv_sec * 1000000000ULL + tp.tv_nsec;
198 #else
199         struct timeval tv;
200         gettimeofday(&tv, NULL);
201         return tv.tv_sec * 1000000000ULL + tv.tv_usec * 1000;
202 #endif
203 }
204
205 static char *short_opts;
206 static struct option *long_opts;
207
208 int os_parse_args(struct sandbox_state *state, int argc, char *argv[])
209 {
210         struct sandbox_cmdline_option **sb_opt = __u_boot_sandbox_option_start;
211         size_t num_options = __u_boot_sandbox_option_count();
212         size_t i;
213
214         int hidden_short_opt;
215         size_t si;
216
217         int c;
218
219         if (short_opts || long_opts)
220                 return 1;
221
222         state->argc = argc;
223         state->argv = argv;
224
225         /* dynamically construct the arguments to the system getopt_long */
226         short_opts = os_malloc(sizeof(*short_opts) * num_options * 2 + 1);
227         long_opts = os_malloc(sizeof(*long_opts) * num_options);
228         if (!short_opts || !long_opts)
229                 return 1;
230
231         /*
232          * getopt_long requires "val" to be unique (since that is what the
233          * func returns), so generate unique values automatically for flags
234          * that don't have a short option.  pick 0x100 as that is above the
235          * single byte range (where ASCII/ISO-XXXX-X charsets live).
236          */
237         hidden_short_opt = 0x100;
238         si = 0;
239         for (i = 0; i < num_options; ++i) {
240                 long_opts[i].name = sb_opt[i]->flag;
241                 long_opts[i].has_arg = sb_opt[i]->has_arg ?
242                         required_argument : no_argument;
243                 long_opts[i].flag = NULL;
244
245                 if (sb_opt[i]->flag_short) {
246                         short_opts[si++] = long_opts[i].val = sb_opt[i]->flag_short;
247                         if (long_opts[i].has_arg == required_argument)
248                                 short_opts[si++] = ':';
249                 } else
250                         long_opts[i].val = sb_opt[i]->flag_short = hidden_short_opt++;
251         }
252         short_opts[si] = '\0';
253
254         /* we need to handle output ourselves since u-boot provides printf */
255         opterr = 0;
256
257         /*
258          * walk all of the options the user gave us on the command line,
259          * figure out what u-boot option structure they belong to (via
260          * the unique short val key), and call the appropriate callback.
261          */
262         while ((c = getopt_long(argc, argv, short_opts, long_opts, NULL)) != -1) {
263                 for (i = 0; i < num_options; ++i) {
264                         if (sb_opt[i]->flag_short == c) {
265                                 if (sb_opt[i]->callback(state, optarg)) {
266                                         state->parse_err = sb_opt[i]->flag;
267                                         return 0;
268                                 }
269                                 break;
270                         }
271                 }
272                 if (i == num_options) {
273                         /*
274                          * store the faulting flag for later display.  we have to
275                          * store the flag itself as the getopt parsing itself is
276                          * tricky: need to handle the following flags (assume all
277                          * of the below are unknown):
278                          *   -a        optopt='a' optind=<next>
279                          *   -abbbb    optopt='a' optind=<this>
280                          *   -aaaaa    optopt='a' optind=<this>
281                          *   --a       optopt=0   optind=<this>
282                          * as you can see, it is impossible to determine the exact
283                          * faulting flag without doing the parsing ourselves, so
284                          * we just report the specific flag that failed.
285                          */
286                         if (optopt) {
287                                 static char parse_err[3] = { '-', 0, '\0', };
288                                 parse_err[1] = optopt;
289                                 state->parse_err = parse_err;
290                         } else
291                                 state->parse_err = argv[optind - 1];
292                         break;
293                 }
294         }
295
296         return 0;
297 }
298
299 void os_dirent_free(struct os_dirent_node *node)
300 {
301         struct os_dirent_node *next;
302
303         while (node) {
304                 next = node->next;
305                 free(node);
306                 node = next;
307         }
308 }
309
310 int os_dirent_ls(const char *dirname, struct os_dirent_node **headp)
311 {
312         struct dirent entry, *result;
313         struct os_dirent_node *head, *node, *next;
314         struct stat buf;
315         DIR *dir;
316         int ret;
317         char *fname;
318         int len;
319
320         *headp = NULL;
321         dir = opendir(dirname);
322         if (!dir)
323                 return -1;
324
325         /* Create a buffer for the maximum filename length */
326         len = sizeof(entry.d_name) + strlen(dirname) + 2;
327         fname = malloc(len);
328         if (!fname) {
329                 ret = -ENOMEM;
330                 goto done;
331         }
332
333         for (node = head = NULL;; node = next) {
334                 ret = readdir_r(dir, &entry, &result);
335                 if (ret || !result)
336                         break;
337                 next = malloc(sizeof(*node) + strlen(entry.d_name) + 1);
338                 if (!next) {
339                         os_dirent_free(head);
340                         ret = -ENOMEM;
341                         goto done;
342                 }
343                 strcpy(next->name, entry.d_name);
344                 switch (entry.d_type) {
345                 case DT_REG:
346                         next->type = OS_FILET_REG;
347                         break;
348                 case DT_DIR:
349                         next->type = OS_FILET_DIR;
350                         break;
351                 case DT_LNK:
352                         next->type = OS_FILET_LNK;
353                         break;
354                 }
355                 next->size = 0;
356                 snprintf(fname, len, "%s/%s", dirname, next->name);
357                 if (!stat(fname, &buf))
358                         next->size = buf.st_size;
359                 if (node)
360                         node->next = next;
361                 if (!head)
362                         head = node;
363         }
364         *headp = head;
365
366 done:
367         closedir(dir);
368         return ret;
369 }
370
371 const char *os_dirent_typename[OS_FILET_COUNT] = {
372         "   ",
373         "SYM",
374         "DIR",
375         "???",
376 };
377
378 const char *os_dirent_get_typename(enum os_dirent_t type)
379 {
380         if (type >= 0 && type < OS_FILET_COUNT)
381                 return os_dirent_typename[type];
382
383         return os_dirent_typename[OS_FILET_UNKNOWN];
384 }
385
386 ssize_t os_get_filesize(const char *fname)
387 {
388         struct stat buf;
389         int ret;
390
391         ret = stat(fname, &buf);
392         if (ret)
393                 return ret;
394         return buf.st_size;
395 }
396
397 void os_putc(int ch)
398 {
399         putchar(ch);
400 }
401
402 void os_puts(const char *str)
403 {
404         while (*str)
405                 os_putc(*str++);
406 }
407
408 int os_write_ram_buf(const char *fname)
409 {
410         struct sandbox_state *state = state_get_current();
411         int fd, ret;
412
413         fd = open(fname, O_CREAT | O_WRONLY, 0777);
414         if (fd < 0)
415                 return -ENOENT;
416         ret = write(fd, state->ram_buf, state->ram_size);
417         close(fd);
418         if (ret != state->ram_size)
419                 return -EIO;
420
421         return 0;
422 }
423
424 int os_read_ram_buf(const char *fname)
425 {
426         struct sandbox_state *state = state_get_current();
427         int fd, ret;
428         int size;
429
430         size = os_get_filesize(fname);
431         if (size < 0)
432                 return -ENOENT;
433         if (size != state->ram_size)
434                 return -ENOSPC;
435         fd = open(fname, O_RDONLY);
436         if (fd < 0)
437                 return -ENOENT;
438
439         ret = read(fd, state->ram_buf, state->ram_size);
440         close(fd);
441         if (ret != state->ram_size)
442                 return -EIO;
443
444         return 0;
445 }