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(block_dev_desc_t *rbdd, disk_partition_t *info)
  12 {
  13         /*
  14          * Only accept a NULL block_dev_desc_t 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
  98         return 0;
  99 }
 100
 101 int sandbox_fs_exists(const char *filename)
 102 {
 103         loff_t size;
 104         int ret;
 105
 106         ret = os_get_filesize(filename, &size);
 107         return ret == 0;
 108 }
 109
 110 int sandbox_fs_size(const char *filename, loff_t *size)
 111 {
 112         return os_get_filesize(filename, size);
 113 }
 114
 115 void sandbox_fs_close(void)
 116 {
 117 }
 118
 119 int fs_read_sandbox(const char *filename, void *buf, loff_t offset, loff_t len,
 120                     loff_t *actread)
 121 {
 122         int ret;
 123
 124         ret = sandbox_fs_read_at(filename, offset, buf, len, actread);
 125         if (ret)
 126                 printf("** Unable to read file %s **\n", filename);
 127
 128         return ret;
 129 }
 130
 131 int fs_write_sandbox(const char *filename, void *buf, loff_t offset,
 132                      loff_t len, loff_t *actwrite)
 133 {
 134         int ret;
 135
 136         ret = sandbox_fs_write_at(filename, offset, buf, len, actwrite);
 137         if (ret)
 138                 printf("** Unable to write file %s **\n", filename);
 139
 140         return ret;
 141 }