fs/sandbox/sandboxfs.c

   1 /*
   2  * Copyright (c) 2012, Google Inc.
   3  *
   4  * SPDX-License-Identifier:     GPL-2.0+
   5  */
   6
   7 #include <common.h>
   8 #include <fs.h>
   9 #include <os.h>
  10
  11 int sandbox_fs_set_blk_dev(struct blk_desc *rbdd, disk_partition_t *info)
  12 {
  13         /*
  14          * Only accept a NULL struct blk_desc for the sandbox, which is when
  15          * hostfs interface is used
  16          */
  17         return rbdd != NULL;
  18 }
  19
  20 int sandbox_fs_read_at(const char *filename, loff_t pos, void *buffer,
  21                        loff_t maxsize, loff_t *actread)
  22 {
  23         loff_t size;
  24         int fd, ret;
  25
  26         fd = os_open(filename, OS_O_RDONLY);
  27         if (fd < 0)
  28                 return fd;
  29         ret = os_lseek(fd, pos, OS_SEEK_SET);
  30         if (ret == -1) {
  31                 os_close(fd);
  32                 return ret;
  33         }
  34         if (!maxsize) {
  35                 ret = os_get_filesize(filename, &size);
  36                 if (ret) {
  37                         os_close(fd);
  38                         return ret;
  39                 }
  40
  41                 maxsize = size;
  42         }
  43
  44         size = os_read(fd, buffer, maxsize);
  45         os_close(fd);
  46
  47         if (size < 0) {
  48                 ret = -1;
  49         } else {
  50                 ret = 0;
  51                 *actread = size;
  52         }
  53
  54         return ret;
  55 }
  56
  57 int sandbox_fs_write_at(const char *filename, loff_t pos, void *buffer,
  58                         loff_t towrite, loff_t *actwrite)
  59 {
  60         ssize_t size;
  61         int fd, ret;
  62
  63         fd = os_open(filename, OS_O_RDWR | OS_O_CREAT);
  64         if (fd < 0)
  65                 return fd;
  66         ret = os_lseek(fd, pos, OS_SEEK_SET);
  67         if (ret == -1) {
  68                 os_close(fd);
  69                 return ret;
  70         }
  71         size = os_write(fd, buffer, towrite);
  72         os_close(fd);
  73
  74         if (size == -1) {
  75                 ret = -1;
  76         } else {
  77                 ret = 0;
  78                 *actwrite = size;
  79         }
  80
  81         return ret;
  82 }
  83
  84 int sandbox_fs_ls(const char *dirname)
  85 {
  86         struct os_dirent_node *head, *node;
  87         int ret;
  88
  89         ret = os_dirent_ls(dirname, &head);
  90         if (ret)
  91                 return ret;
  92
  93         for (node = head; node; node = node->next) {
  94                 printf("%s %10lu %s\n", os_dirent_get_typename(node->type),
  95                        node->size, node->name);
  96         }
  97         os_dirent_free(head);
  98
  99         return 0;
 100 }
 101
 102 int sandbox_fs_exists(const char *filename)
 103 {
 104         loff_t size;
 105         int ret;
 106
 107         ret = os_get_filesize(filename, &size);
 108         return ret == 0;
 109 }
 110
 111 int sandbox_fs_size(const char *filename, loff_t *size)
 112 {
 113         return os_get_filesize(filename, size);
 114 }
 115
 116 void sandbox_fs_close(void)
 117 {
 118 }
 119
 120 int fs_read_sandbox(const char *filename, void *buf, loff_t offset, loff_t len,
 121                     loff_t *actread)
 122 {
 123         int ret;
 124
 125         ret = sandbox_fs_read_at(filename, offset, buf, len, actread);
 126         if (ret)
 127                 printf("** Unable to read file %s **\n", filename);
 128
 129         return ret;
 130 }
 131
 132 int fs_write_sandbox(const char *filename, void *buf, loff_t offset,
 133                      loff_t len, loff_t *actwrite)
 134 {
 135         int ret;
 136
 137         ret = sandbox_fs_write_at(filename, offset, buf, len, actwrite);
 138         if (ret)
 139                 printf("** Unable to write file %s **\n", filename);
 140
 141         return ret;
 142 }