Use positioned IO scheme interface.

Cargo.lock

@@ -130,7 +130,7 @@ dependencies = [
 [[package]]
 name = "redox-scheme"
 version = "0.2.0"
-source = "git+https://gitlab.redox-os.org/4lDO2/redox-scheme.git?branch=schemev2#40c29c6f08e095e7b3739feae47a3c24f469c4d3"
+source = "git+https://gitlab.redox-os.org/4lDO2/redox-scheme.git?branch=schemev2plus#ca239589c873374a17715b637be1f9385345721c"
 dependencies = [
  "libredox",
  "redox_syscall",
@@ -139,7 +139,7 @@ dependencies = [
 [[package]]
 name = "redox_syscall"
 version = "0.5.1"
-source = "git+https://gitlab.redox-os.org/4lDO2/syscall.git?branch=schemev2#495a0adbd8333fd21fae2d97129b094607878ba7"
+source = "git+https://gitlab.redox-os.org/4lDO2/syscall.git?branch=schemev2plus#35600d6c9c46a4d54ec17d80c9ff5d17ef79a052"
 dependencies = [
  "bitflags",
 ]

Cargo.toml

@@ -16,7 +16,7 @@ redox-initfs = { git = "https://gitlab.redox-os.org/redox-os/redox-initfs.git",
 #redox-exec = { git = "https://gitlab.redox-os.org/redox-os/relibc.git" }
 redox-exec = { git = "https://gitlab.redox-os.org/redox-os/relibc.git" }
 redox_syscall = "0.5.1"
-redox-scheme = { git = "https://gitlab.redox-os.org/4lDO2/redox-scheme.git", branch = "schemev2" }
+redox-scheme = { git = "https://gitlab.redox-os.org/4lDO2/redox-scheme.git", branch = "schemev2plus" }
 
 [profile.release]
 panic = "abort"
@@ -26,4 +26,4 @@ lto = "fat"
 panic = "abort"
 
 [patch.crates-io]
-redox_syscall = { git = "https://gitlab.redox-os.org/4lDO2/syscall.git", branch = "schemev2" }
+redox_syscall = { git = "https://gitlab.redox-os.org/4lDO2/syscall.git", branch = "schemev2plus" }

src/initfs.rs

@@ -19,10 +19,10 @@ use redox_scheme::V2;
 use syscall::data::Stat;
 use syscall::error::*;
 use syscall::flag::*;
+use syscall::schemev2::NewFdFlags;
 
 struct Handle {
     inode: Inode,
-    seek: usize,
     // TODO: Any better way to implement fpath? Or maybe work around it, e.g. by giving paths such
     // as `initfs:__inodes__/<inode>`?
     filename: String,
@@ -140,21 +140,24 @@ impl SchemeMut for InitFsScheme {
         let id = self.next_id();
         let old = self.handles.insert(id, Handle {
             inode: current_inode,
-            seek: 0_usize,
             filename: path.into(),
         });
         assert!(old.is_none());
 
-        Ok(OpenResult::ThisScheme { number: id })
+        Ok(OpenResult::ThisScheme { number: id, flags: NewFdFlags::POSITIONED })
     }
 
-    fn read(&mut self, id: usize, mut buffer: &mut [u8]) -> Result<usize> {
+    fn read(&mut self, id: usize, mut buffer: &mut [u8], offset: u64, _fcntl_flags: u32) -> Result<usize> {
+        let Ok(offset) = usize::try_from(offset) else {
+            return Ok(0);
+        };
+
         let handle = self.handles.get_mut(&id).ok_or(Error::new(EBADF))?;
 
         match Self::get_inode(&self.fs, handle.inode)?.kind() {
             InodeKind::Dir(dir) => {
                 let mut bytes_read = 0;
-                let mut total_to_skip = handle.seek;
+                let mut total_to_skip = offset;
 
                 for entry_res in (Iter { dir, idx: 0 }) {
                     let entry = entry_res?;
@@ -179,31 +182,25 @@ impl SchemeMut for InitFsScheme {
                     total_to_skip -= to_skip;
                 }
 
-                handle.seek = handle.seek.saturating_add(bytes_read);
-
                 Ok(bytes_read)
             }
             InodeKind::File(file) => {
                 let data = file.data().map_err(|_| Error::new(EIO))?;
-                let src_buf = &data[core::cmp::min(handle.seek, data.len())..];
+                let src_buf = &data[core::cmp::min(offset, data.len())..];
 
                 let to_copy = core::cmp::min(src_buf.len(), buffer.len());
                 buffer[..to_copy].copy_from_slice(&src_buf[..to_copy]);
 
-                handle.seek = handle.seek.checked_add(to_copy).ok_or(Error::new(EOVERFLOW))?;
-
                 Ok(to_copy)
             }
             InodeKind::Unknown => return Err(Error::new(EIO)),
         }
     }
 
-    fn seek(&mut self, id: usize, pos: isize, whence: usize) -> Result<isize> {
+    fn fsize(&mut self, id: usize) -> Result<u64> {
         let handle = self.handles.get_mut(&id).ok_or(Error::new(EBADF))?;
 
-        let new_offset = redox_scheme::calc_seek_offset_usize(handle.seek, pos, whence, inode_len(Self::get_inode(&self.fs, handle.inode)?)?)?;
-        handle.seek = new_offset as usize;
-        Ok(new_offset)
+        Ok(inode_len(Self::get_inode(&self.fs, handle.inode)?)? as u64)
     }
 
     fn fcntl(&mut self, id: usize, _cmd: usize, _arg: usize) -> Result<usize> {