unit-test: make "test -e" test independent of $CWD

[karo-tx-uboot.git] / arch / sandbox / cpu / os.c

diff --git a/arch/sandbox/cpu/os.c b/arch/sandbox/cpu/os.c
index 541e450bf602d684f22c0876b531e5a6fc586be4..98f565eaaf8cfd2d19fb0c011983bb2198d6dce6 100644 (file)
--- a/arch/sandbox/cpu/os.c
+++ b/arch/sandbox/cpu/os.c
@@ -1,22 +1,6 @@
 /*
  * Copyright (c) 2011 The Chromium OS Authors.
- * See file CREDITS for list of people who contributed to this
- * project.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of
- * the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
- * MA 02111-1307 USA
+ * SPDX-License-Identifier:    GPL-2.0+
  */
 
 #include <dirent.h>
@@ -24,6 +8,7 @@
 #include <fcntl.h>
 #include <getopt.h>
 #include <stdio.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 #include <termios.h>
@@ -42,6 +27,10 @@
 
 /* Operating System Interface */
 
+struct os_mem_hdr {
+       size_t length;          /* number of bytes in the block */
+};
+
 ssize_t os_read(int fd, void *buf, size_t count)
 {
        return read(fd, buf, count);
@@ -103,6 +92,11 @@ int os_close(int fd)
        return close(fd);
 }
 
+int os_unlink(const char *pathname)
+{
+       return unlink(pathname);
+}
+
 void os_exit(int exit_code)
 {
        exit(exit_code);
@@ -143,8 +137,45 @@ void os_tty_raw(int fd)
 
 void *os_malloc(size_t length)
 {
-       return mmap(NULL, length, PROT_READ | PROT_WRITE,
-                       MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+       struct os_mem_hdr *hdr;
+
+       hdr = mmap(NULL, length + sizeof(*hdr), PROT_READ | PROT_WRITE,
+                  MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+       if (hdr == MAP_FAILED)
+               return NULL;
+       hdr->length = length;
+
+       return hdr + 1;
+}
+
+void os_free(void *ptr)
+{
+       struct os_mem_hdr *hdr = ptr;
+
+       hdr--;
+       if (ptr)
+               munmap(hdr, hdr->length + sizeof(*hdr));
+}
+
+void *os_realloc(void *ptr, size_t length)
+{
+       struct os_mem_hdr *hdr = ptr;
+       void *buf = NULL;
+
+       hdr--;
+       if (length != 0) {
+               buf = os_malloc(length);
+               if (!buf)
+                       return buf;
+               if (ptr) {
+                       if (length > hdr->length)
+                               length = hdr->length;
+                       memcpy(buf, ptr, length);
+               }
+       }
+       os_free(ptr);
+
+       return buf;
 }
 
 void os_usleep(unsigned long usec)
@@ -152,7 +183,7 @@ void os_usleep(unsigned long usec)
        usleep(usec);
 }
 
-u64 __attribute__((no_instrument_function)) os_get_nsec(void)
+uint64_t __attribute__((no_instrument_function)) os_get_nsec(void)
 {
 #if defined(CLOCK_MONOTONIC) && defined(_POSIX_MONOTONIC_CLOCK)
        struct timespec tp;
@@ -176,7 +207,7 @@ static struct option *long_opts;
 
 int os_parse_args(struct sandbox_state *state, int argc, char *argv[])
 {
-       struct sb_cmdline_option **sb_opt = __u_boot_sandbox_option_start;
+       struct sandbox_cmdline_option **sb_opt = __u_boot_sandbox_option_start;
        size_t num_options = __u_boot_sandbox_option_count();
        size_t i;
 
@@ -362,3 +393,53 @@ ssize_t os_get_filesize(const char *fname)
                return ret;
        return buf.st_size;
 }
+
+void os_putc(int ch)
+{
+       putchar(ch);
+}
+
+void os_puts(const char *str)
+{
+       while (*str)
+               os_putc(*str++);
+}
+
+int os_write_ram_buf(const char *fname)
+{
+       struct sandbox_state *state = state_get_current();
+       int fd, ret;
+
+       fd = open(fname, O_CREAT | O_WRONLY, 0777);
+       if (fd < 0)
+               return -ENOENT;
+       ret = write(fd, state->ram_buf, state->ram_size);
+       close(fd);
+       if (ret != state->ram_size)
+               return -EIO;
+
+       return 0;
+}
+
+int os_read_ram_buf(const char *fname)
+{
+       struct sandbox_state *state = state_get_current();
+       int fd, ret;
+       int size;
+
+       size = os_get_filesize(fname);
+       if (size < 0)
+               return -ENOENT;
+       if (size != state->ram_size)
+               return -ENOSPC;
+       fd = open(fname, O_RDONLY);
+       if (fd < 0)
+               return -ENOENT;
+
+       ret = read(fd, state->ram_buf, state->ram_size);
+       close(fd);
+       if (ret != state->ram_size)
+               return -EIO;
+
+       return 0;
+}