ehmry/genode
ehmry
/
genode
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

vfs: use 64bit for file offset and size 

Fixes #1246
This commit is contained in:
Alexander Boettcher 2014-09-09 14:32:31 +02:00 committed by Christian Helmuth
parent 289cfa5fcf
commit 8b8c2713ae
30 changed files with 213 additions and 172 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
repos/libports/lib/mk/libc-common.inc
View File

@ -22,6 +22,7 @@ INC_DIR += $(LIBC_DIR)/contrib/gdtoa
# the imported source code to improve build aesthetics # the imported source code to improve build aesthetics
# #
CC_WARN = CC_WARN =
CC_CXX_OPT += -Wall
# #
# Generate position independent code to allow linking of static libc code into # Generate position independent code to allow linking of static libc code into

4
repos/libports/src/lib/libc/fd_alloc.cc
View File

@ -45,11 +45,11 @@ File_descriptor *File_descriptor_allocator::alloc(Plugin *plugin,
int libc_fd) int libc_fd)
{ {
/* we use addresses returned by the allocator as file descriptors */ /* we use addresses returned by the allocator as file descriptors */
addr_t addr = (libc_fd == ANY_FD ? ANY_FD : libc_fd); addr_t addr = (libc_fd <= ANY_FD ? ANY_FD : libc_fd);
/* allocate fresh fd if the default value for 'libc_fd' was specified */ /* allocate fresh fd if the default value for 'libc_fd' was specified */
bool alloc_ok = false; bool alloc_ok = false;
if (addr == ANY_FD) if (libc_fd <= ANY_FD)
alloc_ok = Allocator_avl_base::alloc(1, reinterpret_cast<void**>(&addr)); alloc_ok = Allocator_avl_base::alloc(1, reinterpret_cast<void**>(&addr));
else else
alloc_ok = (Allocator_avl_base::alloc_addr(1, addr).is_ok()); alloc_ok = (Allocator_avl_base::alloc_addr(1, addr).is_ok());

2
repos/libports/src/lib/libc/file_operations.cc
View File

@ -627,7 +627,7 @@ extern "C" int _open(const char *pathname, int flags, ::mode_t mode)
plugin = plugin_registry()->get_plugin_for_open(resolved_path.base(), flags); plugin = plugin_registry()->get_plugin_for_open(resolved_path.base(), flags);
if (!plugin) { if (!plugin) {
PERR("no plugin found for open(\"%s\", int)", pathname, flags); PERR("no plugin found for open(\"%s\", %d)", pathname, flags);
return -1; return -1;
} }

2
repos/libports/src/lib/libc/libc_debug.h
View File

@ -28,7 +28,7 @@ extern "C" int raw_write_str(const char *s);
/* /*
* Discard external references to 'raw_write_str' * Discard external references to 'raw_write_str'
*/ */
static inline int raw_write_str(const char *s) { } static inline int raw_write_str(const char *s) { return 0; }
#endif /* LIBC_DEBUG == 1 */ #endif /* LIBC_DEBUG == 1 */

9
repos/libports/src/lib/libc/malloc.cc
View File

@ -21,7 +21,10 @@
#include <util/misc_math.h> #include <util/misc_math.h>
/* libc includes */ /* libc includes */
extern "C" {
#include <string.h> #include <string.h>
#include <stdlib.h>
}
typedef unsigned long Block_header; typedef unsigned long Block_header;
@ -171,14 +174,14 @@ static Genode::Allocator *allocator()
} }
extern "C" void *malloc(unsigned size) extern "C" void *malloc(size_t size)
{ {
void *addr; void *addr;
return allocator()->alloc(size, &addr) ? addr : 0; return allocator()->alloc(size, &addr) ? addr : 0;
} }
extern "C" void *calloc(unsigned nmemb, unsigned size) extern "C" void *calloc(size_t nmemb, size_t size)
{ {
void *addr = malloc(nmemb*size); void *addr = malloc(nmemb*size);
Genode::memset(addr, 0, nmemb*size); Genode::memset(addr, 0, nmemb*size);
@ -194,7 +197,7 @@ extern "C" void free(void *ptr)
} }
extern "C" void *realloc(void *ptr, Genode::size_t size) extern "C" void *realloc(void *ptr, size_t size)
{ {
if (!ptr) if (!ptr)
return malloc(size); return malloc(size);

4
repos/libports/src/lib/libc/poll.cc
View File

@ -50,13 +50,13 @@ __attribute__((weak))
poll(struct pollfd fds[], nfds_t nfds, int timeout) poll(struct pollfd fds[], nfds_t nfds, int timeout)
{ {
nfds_t i; nfds_t i;
int saved_errno, ret, fd, maxfd = 0; int ret, fd, maxfd = 0;
fd_set readfds, writefds, exceptfds; fd_set readfds, writefds, exceptfds;
struct timeval tv, *tvp = NULL; struct timeval tv, *tvp = NULL;
for (i = 0; i < nfds; i++) { for (i = 0; i < nfds; i++) {
fd = fds[i].fd; fd = fds[i].fd;
if (fd >= FD_SETSIZE) { if (fd >= (int)FD_SETSIZE) {
/*errno = EINVAL;*/ /*errno = EINVAL;*/
return -1; return -1;
} }

2
repos/libports/src/lib/libc/select.cc
View File

@ -280,7 +280,7 @@ pselect(int nfds, fd_set *readfds, fd_set *writefds,
fd_set *exceptfds, const struct timespec *timeout, fd_set *exceptfds, const struct timespec *timeout,
const sigset_t *sigmask) const sigset_t *sigmask)
{ {
struct timeval tv, *tvp; struct timeval tv;
sigset_t origmask; sigset_t origmask;
int nready; int nready;

2
repos/libports/src/lib/libc/sysctl.cc
View File

@ -42,7 +42,7 @@ extern "C" int __sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp,
* the actual page size. * the actual page size.
*/ */
if (((name[0] == CTL_HW) && (name[1] == HW_PAGESIZE)) || if (((name[0] == CTL_HW) && (name[1] == HW_PAGESIZE)) ||
(name[0] == CTL_P1003_1B) && (name[1] == CTL_P1003_1B_PAGESIZE)) { ((name[0] == CTL_P1003_1B) && (name[1] == CTL_P1003_1B_PAGESIZE))) {
int result = 4096; int result = 4096;
if (oldp) { if (oldp) {
if (*oldlenp >= sizeof(result)) { if (*oldlenp >= sizeof(result)) {

6
repos/libports/src/lib/libc/vfs_plugin.cc
View File

@ -513,7 +513,7 @@ ssize_t Libc::Vfs_plugin::write(Libc::File_descriptor *fd, const void *buf,
Vfs::Vfs_handle *handle = vfs_handle(fd); Vfs::Vfs_handle *handle = vfs_handle(fd);
size_t out_count = 0; Vfs::file_size out_count = 0;
switch (handle->fs().write(handle, (char const *)buf, count, out_count)) { switch (handle->fs().write(handle, (char const *)buf, count, out_count)) {
case Result::WRITE_ERR_AGAIN: errno = EAGAIN; return -1; case Result::WRITE_ERR_AGAIN: errno = EAGAIN; return -1;
@ -537,7 +537,7 @@ ssize_t Libc::Vfs_plugin::read(Libc::File_descriptor *fd, void *buf,
Vfs::Vfs_handle *handle = vfs_handle(fd); Vfs::Vfs_handle *handle = vfs_handle(fd);
Genode::size_t out_count = 0; Vfs::file_size out_count = 0;
switch (handle->fs().read(handle, (char *)buf, count, out_count)) { switch (handle->fs().read(handle, (char *)buf, count, out_count)) {
case Result::READ_ERR_AGAIN: errno = EAGAIN; PERR("A1"); return -1; case Result::READ_ERR_AGAIN: errno = EAGAIN; PERR("A1"); return -1;
@ -852,7 +852,7 @@ ssize_t Libc::Vfs_plugin::readlink(const char *path, char *buf, size_t buf_size)
{ {
typedef Vfs::Directory_service::Readlink_result Result; typedef Vfs::Directory_service::Readlink_result Result;
size_t out_len = 0; Vfs::file_size out_len = 0;
switch (_root_dir.readlink(path, buf, buf_size, out_len)) { switch (_root_dir.readlink(path, buf, buf_size, out_len)) {
case Result::READLINK_ERR_NO_ENTRY: errno = ENOENT; return -1; case Result::READLINK_ERR_NO_ENTRY: errno = ENOENT; return -1;

10
repos/libports/src/lib/vfs/jitterentropy/vfs_jitterentropy.h
View File

@ -70,14 +70,16 @@ class Jitterentropy_file_system : public Vfs::Single_file_system
** File I/O service interface ** ** File I/O service interface **
********************************/ ********************************/
Write_result write(Vfs::Vfs_handle *, char const *, Genode::size_t count, Write_result write(Vfs::Vfs_handle *, char const *,
Genode::size_t &count_out) override Vfs::file_size count,
Vfs::file_size &count_out) override
{ {
return WRITE_ERR_IO; return WRITE_ERR_IO;
} }
Read_result read(Vfs::Vfs_handle *vfs_handle, char *dst, Genode::size_t count, Read_result read(Vfs::Vfs_handle *vfs_handle, char *dst,
Genode::size_t &out_count) override Vfs::file_size count,
Vfs::file_size &out_count) override
{ {
if (!_initialized) if (!_initialized)
return READ_ERR_IO; return READ_ERR_IO;

63
repos/os/include/vfs/block_file_system.h
View File

@ -49,7 +49,7 @@ class Vfs::Block_file_system : public Single_file_system
Genode::Allocator_avl _tx_block_alloc; Genode::Allocator_avl _tx_block_alloc;
Block::Connection _block; Block::Connection _block;
size_t _block_size; Genode::size_t _block_size;
Block::sector_t _block_count; Block::sector_t _block_count;
Block::Session::Operations _block_ops; Block::Session::Operations _block_ops;
Block::Session::Tx::Source *_tx_source; Block::Session::Tx::Source *_tx_source;
@ -57,15 +57,16 @@ class Vfs::Block_file_system : public Single_file_system
bool _readable; bool _readable;
bool _writeable; bool _writeable;
size_t _block_io(size_t nr, void *buf, size_t sz, bool write, bool bulk = false) file_size _block_io(file_size nr, void *buf, file_size sz,
bool write, bool bulk = false)
{ {
Lock::Guard guard(_lock); Lock::Guard guard(_lock);
Block::Packet_descriptor::Opcode op; Block::Packet_descriptor::Opcode op;
op = write ? Block::Packet_descriptor::WRITE : Block::Packet_descriptor::READ; op = write ? Block::Packet_descriptor::WRITE : Block::Packet_descriptor::READ;
size_t packet_size = bulk ? sz : _block_size; file_size packet_size = bulk ? sz : _block_size;
size_t packet_count = bulk ? (sz / _block_size) : 1; file_size packet_count = bulk ? (sz / _block_size) : 1;
/* sanity check */ /* sanity check */
if (packet_count > _block_buffer_count) { if (packet_count > _block_buffer_count) {
@ -135,7 +136,7 @@ class Vfs::Block_file_system : public Single_file_system
Stat_result stat(char const *path, Stat &out) override Stat_result stat(char const *path, Stat &out) override
{ {
Stat_result const result = Single_file_system::stat(path, out); Stat_result const result = Single_file_system::stat(path, out);
out.size = _block_size*_block_count; out.size = _block_count * _block_size;
return result; return result;
} }
@ -144,22 +145,22 @@ class Vfs::Block_file_system : public Single_file_system
** File I/O service interface ** ** File I/O service interface **
********************************/ ********************************/
Write_result write(Vfs_handle *vfs_handle, char const *buf, size_t count, Write_result write(Vfs_handle *vfs_handle, char const *buf,
size_t &out_count) override file_size count, file_size &out_count) override
{ {
if (!_writeable) { if (!_writeable) {
PERR("block device is not writeable"); PERR("block device is not writeable");
return WRITE_ERR_INVALID; return WRITE_ERR_INVALID;
} }
size_t seek_offset = vfs_handle->seek(); file_size seek_offset = vfs_handle->seek();
size_t written = 0; file_size written = 0;
while (count > 0) { while (count > 0) {
size_t displ = 0; file_size displ = 0;
size_t length = 0; file_size length = 0;
size_t nbytes = 0; file_size nbytes = 0;
size_t blk_nr = seek_offset / _block_size; file_size blk_nr = seek_offset / _block_size;
displ = seek_offset % _block_size; displ = seek_offset % _block_size;
@ -178,12 +179,12 @@ class Vfs::Block_file_system : public Single_file_system
* blocks at the end. * blocks at the end.
*/ */
if (displ == 0 && (count % _block_size) >= 0 && !(count < _block_size)) { if (displ == 0 && (count % _block_size) >= 0 && !(count < _block_size)) {
size_t bytes_left = count - (count % _block_size); file_size bytes_left = count - (count % _block_size);
nbytes = _block_io(blk_nr, (void*)(buf + written), nbytes = _block_io(blk_nr, (void*)(buf + written),
bytes_left, true, true); bytes_left, true, true);
if (nbytes == 0) { if (nbytes == 0) {
PERR("error while write block:%zu from block device", PERR("error while write block:%llu from block device",
blk_nr); blk_nr);
return WRITE_ERR_INVALID; return WRITE_ERR_INVALID;
} }
@ -202,7 +203,7 @@ class Vfs::Block_file_system : public Single_file_system
* than block size, we also have to read the block first. * than block size, we also have to read the block first.
*/ */
if (displ > 0 || length < _block_size) { if (displ > 0 || length < _block_size) {
PWRN("offset:%zd block_size:%zd displacement:%zd length:%zu", PWRN("offset:%llu block_size:%zd displacement:%llu length:%llu",
seek_offset, _block_size, displ, length); seek_offset, _block_size, displ, length);
_block_io(blk_nr, _block_buffer, _block_size, false); _block_io(blk_nr, _block_buffer, _block_size, false);
@ -214,7 +215,7 @@ class Vfs::Block_file_system : public Single_file_system
nbytes = _block_io(blk_nr, _block_buffer, _block_size, true); nbytes = _block_io(blk_nr, _block_buffer, _block_size, true);
if ((unsigned)nbytes != _block_size) { if ((unsigned)nbytes != _block_size) {
PERR("error while writing block:%zu from Block_device", PERR("error while writing block:%llu from Block_device",
blk_nr); blk_nr);
return WRITE_ERR_INVALID; return WRITE_ERR_INVALID;
} }
@ -228,22 +229,22 @@ class Vfs::Block_file_system : public Single_file_system
return WRITE_OK; return WRITE_OK;
} }
Read_result read(Vfs_handle *vfs_handle, char *dst, size_t count, Read_result read(Vfs_handle *vfs_handle, char *dst, file_size count,
size_t &out_count) override file_size &out_count) override
{ {
if (!_readable) { if (!_readable) {
PERR("block device is not readable"); PERR("block device is not readable");
return READ_ERR_INVALID; return READ_ERR_INVALID;
} }
size_t seek_offset = vfs_handle->seek(); file_size seek_offset = vfs_handle->seek();
size_t read = 0; file_size read = 0;
while (count > 0) { while (count > 0) {
size_t displ = 0; file_size displ = 0;
size_t length = 0; file_size length = 0;
size_t nbytes = 0; file_size nbytes = 0;
size_t blk_nr = seek_offset / _block_size; file_size blk_nr = seek_offset / _block_size;
displ = seek_offset % _block_size; displ = seek_offset % _block_size;
@ -262,11 +263,11 @@ class Vfs::Block_file_system : public Single_file_system
* blocks at the end. * blocks at the end.
*/ */
if (displ == 0 && (count % _block_size) >= 0 && !(count < _block_size)) { if (displ == 0 && (count % _block_size) >= 0 && !(count < _block_size)) {
size_t bytes_left = count - (count % _block_size); file_size bytes_left = count - (count % _block_size);
nbytes = _block_io(blk_nr, dst + read, bytes_left, false, true); nbytes = _block_io(blk_nr, dst + read, bytes_left, false, true);
if (nbytes == 0) { if (nbytes == 0) {
PERR("error while reading block:%zu from block device", PERR("error while reading block:%llu from block device",
blk_nr); blk_nr);
return READ_ERR_INVALID; return READ_ERR_INVALID;
} }
@ -278,13 +279,13 @@ class Vfs::Block_file_system : public Single_file_system
} }
if (displ > 0) if (displ > 0)
PWRN("offset:%zd is not aligned to block_size:%zu" PWRN("offset:%llu is not aligned to block_size:%zu"
" displacement:%zu", seek_offset, _block_size, " displacement:%llu", seek_offset, _block_size,
displ); displ);
nbytes = _block_io(blk_nr, _block_buffer, _block_size, false); nbytes = _block_io(blk_nr, _block_buffer, _block_size, false);
if ((unsigned)nbytes != _block_size) { if ((unsigned)nbytes != _block_size) {
PERR("error while reading block:%zu from block device", PERR("error while reading block:%llu from block device",
blk_nr); blk_nr);
return READ_ERR_INVALID; return READ_ERR_INVALID;
} }
@ -300,7 +301,7 @@ class Vfs::Block_file_system : public Single_file_system
return READ_OK; return READ_OK;
} }
Ftruncate_result ftruncate(Vfs_handle *vfs_handle, size_t) override Ftruncate_result ftruncate(Vfs_handle *vfs_handle, file_size) override
{ {
return FTRUNCATE_OK; return FTRUNCATE_OK;
} }

25
repos/os/include/vfs/dir_file_system.h
View File

@ -128,7 +128,7 @@ class Vfs::Dir_file_system : public File_system
if (path[0] == '/') if (path[0] == '/')
path++; path++;
size_t const name_len = strlen(_name); Genode::size_t const name_len = strlen(_name);
if (strcmp(path, _name, name_len) != 0) if (strcmp(path, _name, name_len) != 0)
return 0; return 0;
path += name_len; path += name_len;
@ -147,7 +147,7 @@ class Vfs::Dir_file_system : public File_system
/** /**
* The 'path' is relative to the child file systems. * The 'path' is relative to the child file systems.
*/ */
Dirent_result _dirent_of_file_systems(char const *path, off_t index, Dirent &out) Dirent_result _dirent_of_file_systems(char const *path, file_offset index, Dirent &out)
{ {
int base = 0; int base = 0;
for (File_system *fs = _first_file_system; fs; fs = fs->next) { for (File_system *fs = _first_file_system; fs; fs = fs->next) {
@ -177,7 +177,7 @@ class Vfs::Dir_file_system : public File_system
return DIRENT_OK; return DIRENT_OK;
} }
void _dirent_of_this_dir_node(off_t index, Dirent &out) void _dirent_of_this_dir_node(file_offset index, Dirent &out)
{ {
if (index == 0) { if (index == 0) {
strncpy(out.name, _name, sizeof(out.name)); strncpy(out.name, _name, sizeof(out.name));
@ -193,9 +193,9 @@ class Vfs::Dir_file_system : public File_system
* Accumulate number of directory entries that match in any of * Accumulate number of directory entries that match in any of
* our sub file systems. * our sub file systems.
*/ */
size_t _sum_dirents_of_file_systems(char const *path) file_size _sum_dirents_of_file_systems(char const *path)
{ {
size_t cnt = 0; file_size cnt = 0;
for (File_system *fs = _first_file_system; fs; fs = fs->next) { for (File_system *fs = _first_file_system; fs; fs = fs->next) {
cnt += fs->num_dirent(path); cnt += fs->num_dirent(path);
} }
@ -311,7 +311,7 @@ class Vfs::Dir_file_system : public File_system
return STAT_ERR_NO_ENTRY; return STAT_ERR_NO_ENTRY;
} }
Dirent_result dirent(char const *path, off_t index, Dirent &out) override Dirent_result dirent(char const *path, file_offset index, Dirent &out) override
{ {
if (_is_root()) if (_is_root())
return _dirent_of_file_systems(path, index, out); return _dirent_of_file_systems(path, index, out);
@ -333,7 +333,7 @@ class Vfs::Dir_file_system : public File_system
return _dirent_of_file_systems(path, index, out); return _dirent_of_file_systems(path, index, out);
} }
size_t num_dirent(char const *path) override file_size num_dirent(char const *path) override
{ {
if (_is_root()) { if (_is_root()) {
return _sum_dirents_of_file_systems(path); return _sum_dirents_of_file_systems(path);
@ -447,8 +447,8 @@ class Vfs::Dir_file_system : public File_system
path, unlink_fn); path, unlink_fn);
} }
Readlink_result readlink(char const *path, char *buf, size_t buf_size, Readlink_result readlink(char const *path, char *buf, file_size buf_size,
size_t &out_len) override file_size &out_len) override
{ {
auto readlink_fn = [&] (File_system &fs, char const *path) auto readlink_fn = [&] (File_system &fs, char const *path)
{ {
@ -521,17 +521,18 @@ class Vfs::Dir_file_system : public File_system
** File I/O service interface ** ** File I/O service interface **
********************************/ ********************************/
Write_result write(Vfs_handle *handle, char const *, size_t, size_t &) override Write_result write(Vfs_handle *handle, char const *, file_size,
file_size &) override
{ {
return WRITE_ERR_INVALID; return WRITE_ERR_INVALID;
} }
Read_result read(Vfs_handle *, char *, size_t, size_t &) override Read_result read(Vfs_handle *, char *, file_size, file_size &) override
{ {
return READ_ERR_INVALID; return READ_ERR_INVALID;
} }
Ftruncate_result ftruncate(Vfs_handle *, size_t) override Ftruncate_result ftruncate(Vfs_handle *, file_size) override
{ {
return FTRUNCATE_ERR_NO_PERM; return FTRUNCATE_ERR_NO_PERM;
} }

10
repos/os/include/vfs/directory_service.h
View File

@ -74,7 +74,7 @@ struct Vfs::Directory_service
struct Stat struct Stat
{ {
size_t size; file_size size;
unsigned mode; unsigned mode;
unsigned uid; unsigned uid;
unsigned gid; unsigned gid;
@ -112,7 +112,7 @@ struct Vfs::Directory_service
char name[DIRENT_MAX_NAME_LEN]; char name[DIRENT_MAX_NAME_LEN];
}; };
virtual Dirent_result dirent(char const *path, off_t index, Dirent &) = 0; virtual Dirent_result dirent(char const *path, file_offset index, Dirent &) = 0;
/************ /************
@ -130,8 +130,8 @@ struct Vfs::Directory_service
enum Readlink_result { READLINK_ERR_NO_ENTRY, READLINK_OK }; enum Readlink_result { READLINK_ERR_NO_ENTRY, READLINK_OK };
virtual Readlink_result readlink(char const *path, char *buf, size_t buf_size, virtual Readlink_result readlink(char const *path, char *buf,
size_t &out_len) = 0; file_size buf_size, file_size &out_len) = 0;
/************ /************
@ -169,7 +169,7 @@ struct Vfs::Directory_service
/** /**
* Return number of directory entries located at given path * Return number of directory entries located at given path
*/ */
virtual size_t num_dirent(char const *path) = 0; virtual file_size num_dirent(char const *path) = 0;
virtual bool is_directory(char const *path) = 0; virtual bool is_directory(char const *path) = 0;

10
repos/os/include/vfs/file_io_service.h
View File

@ -34,8 +34,8 @@ struct Vfs::File_io_service
WRITE_ERR_INTERRUPT, WRITE_OK }; WRITE_ERR_INTERRUPT, WRITE_OK };
virtual Write_result write(Vfs_handle *vfs_handle, virtual Write_result write(Vfs_handle *vfs_handle,
char const *buf, size_t buf_size, char const *buf, file_size buf_size,
size_t &out_count) = 0; file_size &out_count) = 0;
/********** /**********
@ -46,8 +46,8 @@ struct Vfs::File_io_service
READ_ERR_INVALID, READ_ERR_IO, READ_ERR_INVALID, READ_ERR_IO,
READ_ERR_INTERRUPT, READ_OK }; READ_ERR_INTERRUPT, READ_OK };
virtual Read_result read(Vfs_handle *vfs_handle, char *dst, size_t count, virtual Read_result read(Vfs_handle *vfs_handle, char *dst, file_size count,
size_t &out_count) = 0; file_size &out_count) = 0;
/*************** /***************
@ -57,7 +57,7 @@ struct Vfs::File_io_service
enum Ftruncate_result { FTRUNCATE_ERR_NO_PERM = NUM_GENERAL_ERRORS, enum Ftruncate_result { FTRUNCATE_ERR_NO_PERM = NUM_GENERAL_ERRORS,
FTRUNCATE_ERR_INTERRUPT, FTRUNCATE_OK }; FTRUNCATE_ERR_INTERRUPT, FTRUNCATE_OK };
virtual Ftruncate_result ftruncate(Vfs_handle *vfs_handle, size_t len) = 0; virtual Ftruncate_result ftruncate(Vfs_handle *vfs_handle, file_size len) = 0;
/*********** /***********

47
repos/os/include/vfs/fs_file_system.h
View File

@ -90,13 +90,13 @@ class Vfs::Fs_file_system : public File_system
~Fs_handle_guard() { _fs.close(_handle); } ~Fs_handle_guard() { _fs.close(_handle); }
}; };
size_t _read(::File_system::Node_handle node_handle, void *buf, file_size _read(::File_system::Node_handle node_handle, void *buf,
size_t const count, size_t const seek_offset) file_size const count, file_size const seek_offset)
{ {
::File_system::Session::Tx::Source &source = *_fs.tx(); ::File_system::Session::Tx::Source &source = *_fs.tx();
size_t const max_packet_size = source.bulk_buffer_size() / 2; file_size const max_packet_size = source.bulk_buffer_size() / 2;
size_t const clipped_count = min(max_packet_size, count); file_size const clipped_count = min(max_packet_size, count);
::File_system::Packet_descriptor const ::File_system::Packet_descriptor const
packet_in(source.alloc_packet(clipped_count), packet_in(source.alloc_packet(clipped_count),
@ -113,7 +113,7 @@ class Vfs::Fs_file_system : public File_system
::File_system::Packet_descriptor const ::File_system::Packet_descriptor const
packet_out = source.get_acked_packet(); packet_out = source.get_acked_packet();
size_t const read_num_bytes = min(packet_out.length(), count); file_size const read_num_bytes = min(packet_out.length(), count);
memcpy(buf, source.packet_content(packet_out), read_num_bytes); memcpy(buf, source.packet_content(packet_out), read_num_bytes);
@ -127,12 +127,12 @@ class Vfs::Fs_file_system : public File_system
return read_num_bytes; return read_num_bytes;
} }
size_t _write(::File_system::Node_handle node_handle, file_size _write(::File_system::Node_handle node_handle,
const char *buf, size_t count, size_t seek_offset) const char *buf, file_size count, file_size seek_offset)
{ {
::File_system::Session::Tx::Source &source = *_fs.tx(); ::File_system::Session::Tx::Source &source = *_fs.tx();
size_t const max_packet_size = source.bulk_buffer_size() / 2; file_size const max_packet_size = source.bulk_buffer_size() / 2;
count = min(max_packet_size, count); count = min(max_packet_size, count);
::File_system::Packet_descriptor ::File_system::Packet_descriptor
@ -207,12 +207,13 @@ class Vfs::Fs_file_system : public File_system
local_addr = env()->rm_session()->attach(ds_cap); local_addr = env()->rm_session()->attach(ds_cap);
::File_system::Session::Tx::Source &source = *_fs.tx(); ::File_system::Session::Tx::Source &source = *_fs.tx();
size_t const max_packet_size = source.bulk_buffer_size() / 2; file_size const max_packet_size = source.bulk_buffer_size() / 2;
for (size_t seek_offset = 0; seek_offset < status.size; for (file_size seek_offset = 0; seek_offset < status.size;
seek_offset += max_packet_size) { seek_offset += max_packet_size) {
size_t const count = min(max_packet_size, status.size - seek_offset); file_size const count = min(max_packet_size, status.size -
seek_offset);
::File_system::Packet_descriptor ::File_system::Packet_descriptor
packet(source.alloc_packet(count), packet(source.alloc_packet(count),
@ -281,7 +282,7 @@ class Vfs::Fs_file_system : public File_system
return STAT_OK; return STAT_OK;
} }
Dirent_result dirent(char const *path, off_t index, Dirent &out) override Dirent_result dirent(char const *path, file_offset index, Dirent &out) override
{ {
Lock::Guard guard(_lock); Lock::Guard guard(_lock);
@ -362,8 +363,8 @@ class Vfs::Fs_file_system : public File_system
return UNLINK_OK; return UNLINK_OK;
} }
Readlink_result readlink(char const *path, char *buf, size_t buf_size, Readlink_result readlink(char const *path, char *buf, file_size buf_size,
size_t &out_len) override file_size &out_len) override
{ {
/* /*
* Canonicalize path (i.e., path must start with '/') * Canonicalize path (i.e., path must start with '/')
@ -477,7 +478,7 @@ class Vfs::Fs_file_system : public File_system
return SYMLINK_ERR_NO_ENTRY; return SYMLINK_ERR_NO_ENTRY;
} }
size_t num_dirent(char const *path) override file_size num_dirent(char const *path) override
{ {
if (strcmp(path, "") == 0) if (strcmp(path, "") == 0)
path = "/"; path = "/";
@ -581,8 +582,8 @@ class Vfs::Fs_file_system : public File_system
** File I/O service interface ** ** File I/O service interface **
********************************/ ********************************/
Write_result write(Vfs_handle *vfs_handle, char const *buf, size_t buf_size, Write_result write(Vfs_handle *vfs_handle, char const *buf,
size_t &out_count) override file_size buf_size, file_size &out_count) override
{ {
Lock::Guard guard(_lock); Lock::Guard guard(_lock);
@ -593,18 +594,18 @@ class Vfs::Fs_file_system : public File_system
return WRITE_OK; return WRITE_OK;
} }
Read_result read(Vfs_handle *vfs_handle, char *dst, size_t count, Read_result read(Vfs_handle *vfs_handle, char *dst, file_size count,
size_t &out_count) override file_size &out_count) override
{ {
Lock::Guard guard(_lock); Lock::Guard guard(_lock);
Fs_vfs_handle const *handle = static_cast<Fs_vfs_handle *>(vfs_handle); Fs_vfs_handle const *handle = static_cast<Fs_vfs_handle *>(vfs_handle);
::File_system::Status status = _fs.status(handle->file_handle()); ::File_system::Status status = _fs.status(handle->file_handle());
size_t const file_size = status.size; file_size const size_of_file = status.size;
size_t const file_bytes_left = file_size >= handle->seek() file_size const file_bytes_left = size_of_file >= handle->seek()
? file_size - handle->seek() : 0; ? size_of_file - handle->seek() : 0;
count = min(count, file_bytes_left); count = min(count, file_bytes_left);
@ -613,7 +614,7 @@ class Vfs::Fs_file_system : public File_system
return READ_OK; return READ_OK;
} }
Ftruncate_result ftruncate(Vfs_handle *vfs_handle, size_t len) override Ftruncate_result ftruncate(Vfs_handle *vfs_handle, file_size len) override
{ {
Fs_vfs_handle const *handle = static_cast<Fs_vfs_handle *>(vfs_handle); Fs_vfs_handle const *handle = static_cast<Fs_vfs_handle *>(vfs_handle);

17
repos/os/include/vfs/inline_file_system.h
View File

@ -27,7 +27,7 @@ class Vfs::Inline_file_system : public Single_file_system
private: private:
char const * const _base; char const * const _base;
size_t const _size; file_size const _size;
public: public:
@ -57,23 +57,24 @@ class Vfs::Inline_file_system : public Single_file_system
** File I/O service interface ** ** File I/O service interface **
********************************/ ********************************/
Write_result write(Vfs_handle *, char const *, size_t, size_t &count_out) override Write_result write(Vfs_handle *, char const *, file_size,
file_size &count_out) override
{ {
count_out = 0; count_out = 0;
return WRITE_ERR_INVALID; return WRITE_ERR_INVALID;
} }
Read_result read(Vfs_handle *vfs_handle, char *dst, size_t count, Read_result read(Vfs_handle *vfs_handle, char *dst, file_size count,
size_t &out_count) override file_size &out_count) override
{ {
/* file read limit is the size of the dataspace */ /* file read limit is the size of the dataspace */
size_t const max_size = _size; file_size const max_size = _size;
/* current read offset */ /* current read offset */
size_t const read_offset = vfs_handle->seek(); file_size const read_offset = vfs_handle->seek();
/* maximum read offset, clamped to dataspace size */ /* maximum read offset, clamped to dataspace size */
size_t const end_offset = min(count + read_offset, max_size); file_size const end_offset = min(count + read_offset, max_size);
/* source address within the dataspace */ /* source address within the dataspace */
char const *src = _base + read_offset; char const *src = _base + read_offset;
@ -85,7 +86,7 @@ class Vfs::Inline_file_system : public Single_file_system
} }
/* copy-out bytes from ROM dataspace */ /* copy-out bytes from ROM dataspace */
size_t const num_bytes = end_offset - read_offset; file_size const num_bytes = end_offset - read_offset;
memcpy(dst, src, num_bytes); memcpy(dst, src, num_bytes);

6
repos/os/include/vfs/log_file_system.h
View File

@ -40,7 +40,8 @@ class Vfs::Log_file_system : public Single_file_system
** File I/O service interface ** ** File I/O service interface **
********************************/ ********************************/
Write_result write(Vfs_handle *, char const *src, size_t count, size_t &out_count) override Write_result write(Vfs_handle *, char const *src, file_size count,
file_size &out_count) override
{ {
out_count = count; out_count = count;
@ -58,7 +59,8 @@ class Vfs::Log_file_system : public Single_file_system
return WRITE_OK; return WRITE_OK;
} }
Read_result read(Vfs_handle *, char *dst, size_t count, size_t &out_count) override Read_result read(Vfs_handle *, char *, file_size,
file_size &out_count) override
{ {
out_count = 0; out_count = 0;
return READ_OK; return READ_OK;

8
repos/os/include/vfs/null_file_system.h
View File

@ -34,21 +34,23 @@ struct Vfs::Null_file_system : Single_file_system
** File I/O service interface ** ** File I/O service interface **
********************************/ ********************************/
Write_result write(Vfs_handle *handle, char const *, size_t count, size_t &out_count) override Write_result write(Vfs_handle *handle, char const *, file_size count,
file_size &out_count) override
{ {
out_count = count; out_count = count;
return WRITE_OK; return WRITE_OK;
} }
Read_result read(Vfs_handle *vfs_handle, char *, size_t, size_t &out_count) override Read_result read(Vfs_handle *vfs_handle, char *, file_size,
file_size &out_count) override
{ {
out_count = 0; out_count = 0;
return READ_OK; return READ_OK;
} }
Ftruncate_result ftruncate(Vfs_handle *vfs_handle, size_t) override Ftruncate_result ftruncate(Vfs_handle *vfs_handle, file_size) override
{ {
return FTRUNCATE_OK; return FTRUNCATE_OK;
} }

15
repos/os/include/vfs/rom_file_system.h
View File

@ -74,23 +74,24 @@ class Vfs::Rom_file_system : public Single_file_system
** File I/O service interface ** ** File I/O service interface **
********************************/ ********************************/
Write_result write(Vfs_handle *, char const *, size_t, size_t &count_out) override Write_result write(Vfs_handle *, char const *, file_size,
file_size &count_out) override
{ {
count_out = 0; count_out = 0;
return WRITE_ERR_INVALID; return WRITE_ERR_INVALID;
} }
Read_result read(Vfs_handle *vfs_handle, char *dst, size_t count, Read_result read(Vfs_handle *vfs_handle, char *dst, file_size count,
size_t &out_count) override file_size &out_count) override
{ {
/* file read limit is the size of the dataspace */ /* file read limit is the size of the dataspace */
size_t const max_size = _rom.size(); file_size const max_size = _rom.size();
/* current read offset */ /* current read offset */
size_t const read_offset = vfs_handle->seek(); file_size const read_offset = vfs_handle->seek();
/* maximum read offset, clamped to dataspace size */ /* maximum read offset, clamped to dataspace size */
size_t const end_offset = min(count + read_offset, max_size); file_size const end_offset = min(count + read_offset, max_size);
/* source address within the dataspace */ /* source address within the dataspace */
char const *src = _rom.local_addr<char>() + read_offset; char const *src = _rom.local_addr<char>() + read_offset;
@ -102,7 +103,7 @@ class Vfs::Rom_file_system : public Single_file_system
} }
/* copy-out bytes from ROM dataspace */ /* copy-out bytes from ROM dataspace */
size_t const num_bytes = end_offset - read_offset; file_size const num_bytes = end_offset - read_offset;
memcpy(dst, src, num_bytes); memcpy(dst, src, num_bytes);

8
repos/os/include/vfs/rtc_file_system.h
View File

@ -44,7 +44,8 @@ class Vfs::Rtc_file_system : public Single_file_system
** File I/O service interface ** ** File I/O service interface **
********************************/ ********************************/
Write_result write(Vfs_handle *, char const *, size_t count, size_t &count_out) override Write_result write(Vfs_handle *, char const *, file_size,
file_size &) override
{ {
return WRITE_ERR_IO; return WRITE_ERR_IO;
} }
@ -55,7 +56,8 @@ class Vfs::Rtc_file_system : public Single_file_system
* On each read the current time is queried and afterwards formated * On each read the current time is queried and afterwards formated
* as '%Y-%m-%d %H:%M\n'. * as '%Y-%m-%d %H:%M\n'.
*/ */
Read_result read(Vfs_handle *vfs_handle, char *dst, size_t count, size_t &out_count) override Read_result read(Vfs_handle *vfs_handle, char *dst, file_size count,
file_size &out_count) override
{ {
time_t t = _rtc.get_current_time() / 1000000ULL; time_t t = _rtc.get_current_time() / 1000000ULL;
@ -67,7 +69,7 @@ class Vfs::Rtc_file_system : public Single_file_system
1 + tm->tm_mon, /* months since January [0-11] */ 1 + tm->tm_mon, /* months since January [0-11] */
tm->tm_mday, tm->tm_hour, tm->tm_min); tm->tm_mday, tm->tm_hour, tm->tm_min);
size_t len = count > sizeof(buf) ? sizeof(buf) : count; file_size len = count > sizeof(buf) ? sizeof(buf) : count;
Genode::memcpy(dst, buf, len); Genode::memcpy(dst, buf, len);
out_count = len; out_count = len;

12
repos/os/include/vfs/single_file_system.h
View File

@ -87,7 +87,7 @@ class Vfs::Single_file_system : public File_system
return STAT_OK; return STAT_OK;
} }
Dirent_result dirent(char const *path, off_t index, Dirent &out) override Dirent_result dirent(char const *path, file_offset index, Dirent &out) override
{ {
if (!_is_root(path)) if (!_is_root(path))
return DIRENT_ERR_INVALID_PATH; return DIRENT_ERR_INVALID_PATH;
@ -106,7 +106,7 @@ class Vfs::Single_file_system : public File_system
return DIRENT_OK; return DIRENT_OK;
} }
size_t num_dirent(char const *path) override file_size num_dirent(char const *path) override
{ {
if (_is_root(path)) if (_is_root(path))
return 1; return 1;
@ -127,7 +127,8 @@ class Vfs::Single_file_system : public File_system
return path; return path;
} }
Open_result open(char const *path, unsigned, Vfs_handle **out_handle) override Open_result open(char const *path, unsigned,
Vfs_handle **out_handle) override
{ {
if (!_is_single_file(path)) if (!_is_single_file(path))
return OPEN_ERR_UNACCESSIBLE; return OPEN_ERR_UNACCESSIBLE;
@ -141,7 +142,8 @@ class Vfs::Single_file_system : public File_system
return UNLINK_ERR_NO_PERM; return UNLINK_ERR_NO_PERM;
} }
Readlink_result readlink(char const *, char *, size_t, size_t &) override Readlink_result readlink(char const *, char *, file_size,
file_size &) override
{ {
return READLINK_ERR_NO_ENTRY; return READLINK_ERR_NO_ENTRY;
} }
@ -166,7 +168,7 @@ class Vfs::Single_file_system : public File_system
** File I/O service interface ** ** File I/O service interface **
********************************/ ********************************/
Ftruncate_result ftruncate(Vfs_handle *vfs_handle, size_t) override Ftruncate_result ftruncate(Vfs_handle *vfs_handle, file_size) override
{ {
return FTRUNCATE_ERR_NO_PERM; return FTRUNCATE_ERR_NO_PERM;
} }

49
repos/os/include/vfs/tar_file_system.h
View File

@ -38,7 +38,7 @@ class Vfs::Tar_file_system : public File_system
Genode::Rom_connection _rom; Genode::Rom_connection _rom;
char *_tar_base; char *_tar_base;
size_t _tar_size; file_size _tar_size;
class Record class Record
{ {
@ -81,7 +81,7 @@ class Vfs::Tar_file_system : public File_system
enum { TYPE_FILE = 0, TYPE_HARDLINK = 1, enum { TYPE_FILE = 0, TYPE_HARDLINK = 1,
TYPE_SYMLINK = 2, TYPE_DIR = 5 }; TYPE_SYMLINK = 2, TYPE_DIR = 5 };
size_t size() const { return _read(_size); } file_size size() const { return _read(_size); }
unsigned uid() const { return _read(_uid); } unsigned uid() const { return _read(_uid); }
unsigned gid() const { return _read(_gid); } unsigned gid() const { return _read(_gid); }
unsigned mode() const { return _read(_mode); } unsigned mode() const { return _read(_mode); }
@ -186,9 +186,9 @@ class Vfs::Tar_file_system : public File_system
} }
size_t num_dirent() file_size num_dirent()
{ {
size_t count = 0; file_size count = 0;
for (Node *child_node = first(); child_node; child_node = child_node->next(), count++) ; for (Node *child_node = first(); child_node; child_node = child_node->next(), count++) ;
return count; return count;
} }
@ -261,7 +261,7 @@ class Vfs::Tar_file_system : public File_system
* and use the location in the record as name * and use the location in the record as name
* pointer to save some memory * pointer to save some memory
*/ */
size_t name_size = strlen(path_element) + 1; Genode::size_t name_size = strlen(path_element) + 1;
char *name = (char*)env()->heap()->alloc(name_size); char *name = (char*)env()->heap()->alloc(name_size);
strncpy(name, path_element, name_size); strncpy(name, path_element, name_size);
child_node = new (env()->heap()) Node(name, record); child_node = new (env()->heap()) Node(name, record);
@ -271,7 +271,7 @@ class Vfs::Tar_file_system : public File_system
PDBG("creating node without record for %s", path_element); PDBG("creating node without record for %s", path_element);
/* create a directory node without record */ /* create a directory node without record */
size_t name_size = strlen(path_element) + 1; Genode::size_t name_size = strlen(path_element) + 1;
char *name = (char*)env()->heap()->alloc(name_size); char *name = (char*)env()->heap()->alloc(name_size);
strncpy(name, path_element, name_size); strncpy(name, path_element, name_size);
child_node = new (env()->heap()) Node(name, 0); child_node = new (env()->heap()) Node(name, 0);
@ -299,13 +299,13 @@ class Vfs::Tar_file_system : public File_system
tar_record_action(record); tar_record_action(record);
size_t file_size = record->size(); file_size size = record->size();
/* some datablocks */ /* one metablock */ /* some datablocks */ /* one metablock */
block_id = block_id + (file_size / Record::BLOCK_LEN) + 1; block_id = block_id + (size / Record::BLOCK_LEN) + 1;
/* round up */ /* round up */
if (file_size % Record::BLOCK_LEN != 0) block_id++; if (size % Record::BLOCK_LEN != 0) block_id++;
/* check for end of tar archive */ /* check for end of tar archive */
if (block_id*Record::BLOCK_LEN >= _tar_size) if (block_id*Record::BLOCK_LEN >= _tar_size)
@ -325,12 +325,12 @@ class Vfs::Tar_file_system : public File_system
Node &root_node; Node &root_node;
bool valid; /* true after first lookup */ bool valid; /* true after first lookup */
char key[256]; /* key used for lookup */ char key[256]; /* key used for lookup */
size_t cached_num_dirent; /* cached value */ file_size cached_num_dirent; /* cached value */
Num_dirent_cache(Node &root_node) Num_dirent_cache(Node &root_node)
: root_node(root_node), valid(false), cached_num_dirent(0) { } : root_node(root_node), valid(false), cached_num_dirent(0) { }
size_t num_dirent(char const *path) file_size num_dirent(char const *path)
{ {
Lock::Guard guard(lock); Lock::Guard guard(lock);
@ -358,7 +358,7 @@ class Vfs::Tar_file_system : public File_system
_root_node("", 0), _root_node("", 0),
_cached_num_dirent(_root_node) _cached_num_dirent(_root_node)
{ {
PINF("tar archive '%s' local at %p, size is %zd", PINF("tar archive '%s' local at %p, size is %llu",
_rom_name.name, _tar_base, _tar_size); _rom_name.name, _tar_base, _tar_size);
_for_each_tar_record_do(Add_node_action(_root_node)); _for_each_tar_record_do(Add_node_action(_root_node));
@ -479,7 +479,7 @@ class Vfs::Tar_file_system : public File_system
return STAT_OK; return STAT_OK;
} }
Dirent_result dirent(char const *path, off_t index, Dirent &out) override Dirent_result dirent(char const *path, file_offset index, Dirent &out) override
{ {
Node *node = _root_node.lookup(path); Node *node = _root_node.lookup(path);
@ -516,8 +516,8 @@ class Vfs::Tar_file_system : public File_system
Unlink_result unlink(char const *) override { return UNLINK_ERR_NO_PERM; } Unlink_result unlink(char const *) override { return UNLINK_ERR_NO_PERM; }
Readlink_result readlink(char const *path, char *buf, size_t buf_size, Readlink_result readlink(char const *path, char *buf, file_size buf_size,
size_t &out_len) override file_size &out_len) override
{ {
Node *node = _root_node.lookup(path); Node *node = _root_node.lookup(path);
Record const *record = node ? node->record : 0; Record const *record = node ? node->record : 0;
@ -525,7 +525,7 @@ class Vfs::Tar_file_system : public File_system
if (!record || (record->type() != Record::TYPE_SYMLINK)) if (!record || (record->type() != Record::TYPE_SYMLINK))
return READLINK_ERR_NO_ENTRY; return READLINK_ERR_NO_ENTRY;
size_t const count = min(buf_size, (size_t)100); file_size const count = min(buf_size, 100ULL);
memcpy(buf, record->linked_name(), count); memcpy(buf, record->linked_name(), count);
@ -549,7 +549,7 @@ class Vfs::Tar_file_system : public File_system
return SYMLINK_ERR_NO_ENTRY; return SYMLINK_ERR_NO_ENTRY;
} }
size_t num_dirent(char const *path) override file_size num_dirent(char const *path) override
{ {
return _cached_num_dirent.num_dirent(path); return _cached_num_dirent.num_dirent(path);
} }
@ -602,21 +602,22 @@ class Vfs::Tar_file_system : public File_system
** File I/O service interface ** ** File I/O service interface **
********************************/ ********************************/
Write_result write(Vfs_handle *, char const *, size_t, size_t &) override Write_result write(Vfs_handle *, char const *, file_size,
file_size &) override
{ {
PDBG("called\n"); PDBG("called\n");
return WRITE_ERR_INVALID; return WRITE_ERR_INVALID;
} }
Read_result read(Vfs_handle *vfs_handle, char *dst, size_t count, Read_result read(Vfs_handle *vfs_handle, char *dst, file_size count,
size_t &out_count) override file_size &out_count) override
{ {
Tar_vfs_handle const *handle = static_cast<Tar_vfs_handle *>(vfs_handle); Tar_vfs_handle const *handle = static_cast<Tar_vfs_handle *>(vfs_handle);
size_t const record_size = handle->record()->size(); file_size const record_size = handle->record()->size();
size_t const record_bytes_left = record_size >= handle->seek() file_size const record_bytes_left = record_size >= handle->seek()
? record_size - handle->seek() : 0; ? record_size - handle->seek() : 0;
count = min(record_bytes_left, count); count = min(record_bytes_left, count);
@ -628,7 +629,7 @@ class Vfs::Tar_file_system : public File_system
return READ_OK; return READ_OK;
} }
Ftruncate_result ftruncate(Vfs_handle *handle, size_t) override Ftruncate_result ftruncate(Vfs_handle *handle, file_size) override
{ {
PDBG("called\n"); PDBG("called\n");
return FTRUNCATE_ERR_NO_PERM; return FTRUNCATE_ERR_NO_PERM;

8
repos/os/include/vfs/terminal_file_system.h
View File

@ -72,19 +72,21 @@ class Vfs::Terminal_file_system : public Single_file_system
** File I/O service interface ** ** File I/O service interface **
********************************/ ********************************/
Write_result write(Vfs_handle *, char const *buf, size_t buf_size, size_t &out_count) override Write_result write(Vfs_handle *, char const *buf, file_size buf_size,
file_size &out_count) override
{ {
out_count = _terminal.write(buf, buf_size); out_count = _terminal.write(buf, buf_size);
return WRITE_OK; return WRITE_OK;
} }
Read_result read(Vfs_handle *, char *dst, size_t count, size_t &out_count) override Read_result read(Vfs_handle *, char *dst, file_size count,
file_size &out_count) override
{ {
out_count = _terminal.read(dst, count); out_count = _terminal.read(dst, count);
return READ_OK; return READ_OK;
} }
Ftruncate_result ftruncate(Vfs_handle *vfs_handle, size_t) override Ftruncate_result ftruncate(Vfs_handle *vfs_handle, file_size) override
{ {
return FTRUNCATE_OK; return FTRUNCATE_OK;
} }

4
repos/os/include/vfs/types.h
View File

@ -38,10 +38,10 @@ namespace Vfs {
using Genode::strncpy; using Genode::strncpy;
using Genode::strcmp; using Genode::strcmp;
using Genode::strlen; using Genode::strlen;
using Genode::off_t; typedef long long file_offset;
using Genode::memcpy; using Genode::memcpy;
using Genode::memset; using Genode::memset;
using Genode::size_t; typedef unsigned long long file_size;
using Genode::Lock; using Genode::Lock;
using Genode::List; using Genode::List;
using Genode::Xml_node; using Genode::Xml_node;

8
repos/os/include/vfs/vfs_handle.h
View File

@ -27,7 +27,7 @@ class Vfs::Vfs_handle
Directory_service &_ds; Directory_service &_ds;
File_io_service &_fs; File_io_service &_fs;
int _status_flags; int _status_flags;
size_t _seek; file_size _seek;
public: public:
@ -48,17 +48,17 @@ class Vfs::Vfs_handle
/** /**
* Return seek offset in bytes * Return seek offset in bytes
*/ */
size_t seek() const { return _seek; } file_size seek() const { return _seek; }
/** /**
* Set seek offset in bytes * Set seek offset in bytes
*/ */
void seek(off_t seek) { _seek = seek; } void seek(file_offset seek) { _seek = seek; }
/** /**
* Advance seek offset by 'incr' bytes * Advance seek offset by 'incr' bytes
*/ */
void advance_seek(size_t incr) { _seek += incr; } void advance_seek(file_size incr) { _seek += incr; }
}; };
#endif /* _INCLUDE__VFS__VFS_HANDLE_H_ */ #endif /* _INCLUDE__VFS__VFS_HANDLE_H_ */

6
repos/os/include/vfs/zero_file_system.h
View File

@ -34,14 +34,16 @@ struct Vfs::Zero_file_system : Single_file_system
** File I/O service interface ** ** File I/O service interface **
********************************/ ********************************/
Write_result write(Vfs_handle *, char const *, size_t count, size_t &count_out) override Write_result write(Vfs_handle *, char const *, file_size count,
file_size &count_out) override
{ {
count_out = count; count_out = count;
return WRITE_OK; return WRITE_OK;
} }
Read_result read(Vfs_handle *vfs_handle, char *dst, size_t count, size_t &out_count) override Read_result read(Vfs_handle *vfs_handle, char *dst, file_size count,
file_size &out_count) override
{ {
memset(dst, 0, count); memset(dst, 0, count);
out_count = count; out_count = count;

7
repos/ports/src/noux/main.cc
View File

@ -689,15 +689,20 @@ bool Noux::Child::syscall(Noux::Session::Syscall sc)
break; break;
case SYSCALL_READLINK: case SYSCALL_READLINK:
{
Vfs::file_size out_count = 0;
_sysio->error.readlink = root_dir()->readlink(_sysio->readlink_in.path, _sysio->error.readlink = root_dir()->readlink(_sysio->readlink_in.path,
_sysio->readlink_out.chunk, _sysio->readlink_out.chunk,
min(_sysio->readlink_in.bufsiz, min(_sysio->readlink_in.bufsiz,
sizeof(_sysio->readlink_out.chunk)), sizeof(_sysio->readlink_out.chunk)),
_sysio->readlink_out.count); out_count);
_sysio->readlink_out.count = out_count;
result = (_sysio->error.readlink == Vfs::Directory_service::READLINK_OK); result = (_sysio->error.readlink == Vfs::Directory_service::READLINK_OK);
break; break;
}
case SYSCALL_RENAME: case SYSCALL_RENAME:

16
repos/ports/src/noux/random_file_system.h
View File

@ -177,7 +177,7 @@ namespace Noux {
num = 2000; num = 2000;
} }
void buf(void *buf_, size_t len) void buf(void *buf_, unsigned long long len)
{ {
size_t chunk; size_t chunk;
uint8_t *buf = (uint8_t *)buf_; uint8_t *buf = (uint8_t *)buf_;
@ -222,7 +222,7 @@ namespace Noux {
memset(S, 0, 256); memset(S, 0, 256);
} }
void get(void *_buf, size_t len) void get(void *_buf, unsigned long long len)
{ {
buf(_buf, len); buf(_buf, len);
} }
@ -250,15 +250,18 @@ namespace Noux {
** File I/O service interface ** ** File I/O service interface **
********************************/ ********************************/
Write_result write(Vfs::Vfs_handle *, char const *, size_t buf_size, size_t &out_count) override Write_result write(Vfs::Vfs_handle *, char const *,
Vfs::file_size buf_size,
Vfs::file_size &out_count) override
{ {
out_count = buf_size; out_count = buf_size;
return WRITE_OK; return WRITE_OK;
} }
Read_result read(Vfs::Vfs_handle *vfs_handle, char *dst, size_t count, Read_result read(Vfs::Vfs_handle *vfs_handle, char *dst,
size_t &out_count) override Vfs::file_size count,
Vfs::file_size &out_count) override
{ {
_arc4random.get(dst, count); _arc4random.get(dst, count);
out_count = count; out_count = count;
@ -266,7 +269,8 @@ namespace Noux {
return READ_OK; return READ_OK;
} }
Ftruncate_result ftruncate(Vfs::Vfs_handle *, size_t) override Ftruncate_result ftruncate(Vfs::Vfs_handle *,
Vfs::file_size) override
{ {
return FTRUNCATE_OK; return FTRUNCATE_OK;
} }

16
repos/ports/src/noux/stdio_file_system.h
View File

@ -49,16 +49,23 @@ namespace Noux {
** File I/O service interface ** ** File I/O service interface **
********************************/ ********************************/
Write_result write(Vfs::Vfs_handle *, char const *buf, size_t buf_size, Write_result write(Vfs::Vfs_handle *, char const *buf,
size_t &out_count) override Vfs::file_size buf_size,
Vfs::file_size &out_count) override
{ {
buf_size = buf_size > 0xFFFFFFFFULL ? ~0UL : buf_size;
out_count = _terminal->write(buf, buf_size); out_count = _terminal->write(buf, buf_size);
return WRITE_OK; return WRITE_OK;
} }
Read_result read(Vfs::Vfs_handle *, char *dst, size_t count, size_t &out_count) override Read_result read(Vfs::Vfs_handle *, char *dst,
Vfs::file_size count,
Vfs::file_size &out_count) override
{ {
count = count > 0xFFFFFFFFULL ? ~0UL : count;
out_count = _terminal->read(dst, count); out_count = _terminal->read(dst, count);
if (_echo) if (_echo)
@ -67,7 +74,8 @@ namespace Noux {
return READ_OK; return READ_OK;
} }
Ftruncate_result ftruncate(Vfs::Vfs_handle *, size_t) override Ftruncate_result ftruncate(Vfs::Vfs_handle *,
Vfs::file_size) override
{ {
return FTRUNCATE_OK; return FTRUNCATE_OK;
} }

8
repos/ports/src/noux/vfs_io_channel.h
View File

@ -46,12 +46,12 @@ namespace Noux {
bool write(Sysio *sysio, size_t &offset) override bool write(Sysio *sysio, size_t &offset) override
{ {
size_t out_count = 0; Vfs::file_size out_count = 0;
sysio->error.write = _fh->fs().write(_fh, sysio->write_in.chunk, sysio->error.write = _fh->fs().write(_fh, sysio->write_in.chunk,
sysio->write_in.count, out_count); sysio->write_in.count, out_count);
if (sysio->error.write != Vfs::File_io_service::WRITE_OK) if (sysio->error.write != Vfs::File_io_service::WRITE_OK)
return false; return false;
_fh->advance_seek(out_count); _fh->advance_seek(out_count);
@ -65,7 +65,7 @@ namespace Noux {
{ {
size_t count = min(sysio->read_in.count, sizeof(sysio->read_out.chunk)); size_t count = min(sysio->read_in.count, sizeof(sysio->read_out.chunk));
size_t out_count = 0; Vfs::file_size out_count = 0;
sysio->error.read = _fh->fs().read(_fh, sysio->read_out.chunk, count, out_count); sysio->error.read = _fh->fs().read(_fh, sysio->read_out.chunk, count, out_count);