LXR uboot/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
  11int 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
  20int 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
  57int 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
  84int 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
 101int 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
 110int sandbox_fs_size(const char *filename, loff_t *size)
 111{
 112        return os_get_filesize(filename, size);
 113}
 114
 115void sandbox_fs_close(void)
 116{
 117}
 118
 119int 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
 131int 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}
 142