git.sur5r.net Git - u-boot/blob - fs/sandbox/sandboxfs.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (c) 2012, Google Inc.
   4  */
   5
   6 #include <common.h>
   7 #include <fs.h>
   8 #include <os.h>
   9
  10 int sandbox_fs_set_blk_dev(struct blk_desc *rbdd, disk_partition_t *info)
  11 {
  12         /*
  13          * Only accept a NULL struct blk_desc for the sandbox, which is when
  14          * hostfs interface is used
  15          */
  16         return rbdd != NULL;
  17 }
  18
  19 int sandbox_fs_read_at(const char *filename, loff_t pos, void *buffer,
  20                        loff_t maxsize, loff_t *actread)
  21 {
  22         loff_t size;
  23         int fd, ret;
  24
  25         fd = os_open(filename, OS_O_RDONLY);
  26         if (fd < 0)
  27                 return fd;
  28         ret = os_lseek(fd, pos, OS_SEEK_SET);
  29         if (ret == -1) {
  30                 os_close(fd);
  31                 return ret;
  32         }
  33         if (!maxsize) {
  34                 ret = os_get_filesize(filename, &size);
  35                 if (ret) {
  36                         os_close(fd);
  37                         return ret;
  38                 }
  39
  40                 maxsize = size;
  41         }
  42
  43         size = os_read(fd, buffer, maxsize);
  44         os_close(fd);
  45
  46         if (size < 0) {
  47                 ret = -1;
  48         } else {
  49                 ret = 0;
  50                 *actread = size;
  51         }
  52
  53         return ret;
  54 }
  55
  56 int sandbox_fs_write_at(const char *filename, loff_t pos, void *buffer,
  57                         loff_t towrite, loff_t *actwrite)
  58 {
  59         ssize_t size;
  60         int fd, ret;
  61
  62         fd = os_open(filename, OS_O_RDWR | OS_O_CREAT);
  63         if (fd < 0)
  64                 return fd;
  65         ret = os_lseek(fd, pos, OS_SEEK_SET);
  66         if (ret == -1) {
  67                 os_close(fd);
  68                 return ret;
  69         }
  70         size = os_write(fd, buffer, towrite);
  71         os_close(fd);
  72
  73         if (size == -1) {
  74                 ret = -1;
  75         } else {
  76                 ret = 0;
  77                 *actwrite = size;
  78         }
  79
  80         return ret;
  81 }
  82
  83 int sandbox_fs_ls(const char *dirname)
  84 {
  85         struct os_dirent_node *head, *node;
  86         int ret;
  87
  88         ret = os_dirent_ls(dirname, &head);
  89         if (ret)
  90                 goto out;
  91
  92         for (node = head; node; node = node->next) {
  93                 printf("%s %10lu %s\n", os_dirent_get_typename(node->type),
  94                        node->size, node->name);
  95         }
  96 out:
  97         os_dirent_free(head);
  98
  99         return ret;
 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 }