LXR uboot/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
  10int 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
  19int 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
  56int 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
  83int 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        }
  96out:
  97        os_dirent_free(head);
  98
  99        return ret;
 100}
 101
 102int 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
 111int sandbox_fs_size(const char *filename, loff_t *size)
 112{
 113        return os_get_filesize(filename, size);
 114}
 115
 116void sandbox_fs_close(void)
 117{
 118}
 119
 120int 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
 132int 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}
 143