base: apply Red Bear patches on latest upstream/main

251 files: init, acpid, ipcd, netcfg, ihdgd, virtio-gpud, scheme-utils,
inputd, block driver, ptyd, ramfs, randd, initfs bootstrap, path deps,
version +rb0.3.1, author attribution

bootstrap/src/initfs.rs

@@ -6,15 +6,16 @@ use core::str;
 use alloc::string::String;
 
 use hashbrown::HashMap;
-use redox_initfs::{InitFs, Inode, InodeDir, InodeKind, InodeStruct};
+use redox_initfs::{InitFs, Inode, InodeDir, InodeKind, InodeStruct, types::Timespec};
 
 use redox_rt::proc::FdGuard;
 use redox_scheme::{
-    scheme::{SchemeState, SchemeSync},
     CallerCtx, OpenResult, RequestKind,
+    scheme::{SchemeState, SchemeSync},
 };
 
 use redox_scheme::{SignalBehavior, Socket};
+use syscall::PAGE_SIZE;
 use syscall::data::Stat;
 use syscall::dirent::DirEntry;
 use syscall::dirent::DirentBuf;
@@ -22,7 +23,6 @@ use syscall::dirent::DirentKind;
 use syscall::error::*;
 use syscall::flag::*;
 use syscall::schemev2::NewFdFlags;
-use syscall::PAGE_SIZE;
 
 enum Handle {
     Node(Node),
@@ -135,7 +135,7 @@ impl SchemeSync for InitFsScheme {
             // filter out double slashes (e.g. /usr//bin/...)
             .filter(|c| !c.is_empty());
 
-        let mut current_inode = self.fs.root_inode();
+        let mut current_inode = InitFs::ROOT_INODE;
 
         while let Some(component) = components.next() {
             match component {
@@ -315,6 +315,8 @@ impl SchemeSync for InitFsScheme {
     fn fstat(&mut self, id: usize, stat: &mut Stat, _ctx: &CallerCtx) -> Result<()> {
         let handle = self.handles.get(&id).ok_or(Error::new(EBADF))?.as_node()?;
 
+        let Timespec { sec, nsec } = self.fs.image_creation_time();
+
         let inode = Self::get_inode(&self.fs, handle.inode)?;
 
         stat.st_ino = inode.id();
@@ -329,10 +331,10 @@ impl SchemeSync for InitFsScheme {
         stat.st_gid = 0;
         stat.st_size = u64::try_from(inode_len(inode)?).unwrap_or(u64::MAX);
 
-        stat.st_ctime = 0;
-        stat.st_ctime_nsec = 0;
-        stat.st_mtime = 0;
-        stat.st_mtime_nsec = 0;
+        stat.st_ctime = sec.get();
+        stat.st_ctime_nsec = nsec.get();
+        stat.st_mtime = sec.get();
+        stat.st_mtime_nsec = nsec.get();
 
         Ok(())
     }
@@ -391,9 +393,9 @@ pub fn run(bytes: &'static [u8], sync_pipe: FdGuard, socket: Socket) -> ! {
     let cap_fd = socket
         .create_this_scheme_fd(0, new_id, 0, 0)
         .expect("failed to issue initfs root fd");
-    let _ = redox_rt::sys::sys_call_wo(
+    let _ = syscall::call_rw(
         sync_pipe.as_raw_fd(),
-        &cap_fd.to_ne_bytes(),
+        &mut cap_fd.to_ne_bytes(),
         CallFlags::FD,
         &[],
     );
@@ -444,21 +446,72 @@ pub unsafe extern "C" fn redox_write_v1(fd: usize, ptr: *const u8, len: usize) -
     })) as isize
 }
 
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn redox_openat_v1(
+    fd: usize,
+    buf: *const u8,
+    path_len: usize,
+    flags: u32,
+    fcntl_flags: u32,
+) -> isize {
+    let path = unsafe { core::slice::from_raw_parts(buf, path_len) };
+    let path_str = match core::str::from_utf8(path) {
+        Ok(s) => s,
+        Err(_) => return -(syscall::EINVAL as isize),
+    };
+    Error::mux(syscall::openat(fd, path_str, flags as usize, fcntl_flags as usize)) as isize
+}
+
 #[unsafe(no_mangle)]
 pub unsafe fn redox_dup_v1(fd: usize, buf: *const u8, len: usize) -> isize {
-    Error::mux(redox_rt::sys::dup(fd, unsafe {
+    Error::mux(syscall::dup(fd, unsafe {
         core::slice::from_raw_parts(buf, len)
     })) as isize
 }
 
 #[unsafe(no_mangle)]
-pub unsafe fn redox_fcntl_v0(fd: usize, cmd: usize, arg: usize) -> isize {
-    Error::mux(redox_rt::sys::fcntl(fd, cmd, arg)) as isize
+pub extern "C" fn redox_close_v1(fd: usize) -> isize {
+    Error::mux(syscall::close(fd)) as isize
 }
 
 #[unsafe(no_mangle)]
-pub extern "C" fn redox_close_v1(fd: usize) -> isize {
-    Error::mux(redox_rt::sys::close(fd)) as isize
+pub extern "C" fn redox_fcntl_v0(fd: usize, cmd: usize, arg: usize) -> isize {
+    Error::mux(syscall::fcntl(fd, cmd, arg)) as isize
+}
+
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn redox_strerror_v1(
+    dst: *mut u8,
+    dst_len: *mut usize,
+    error: u32,
+) -> isize {
+    let msg = match error {
+        x if x == syscall::EPERM as u32 => "Operation not permitted",
+        x if x == syscall::ENOENT as u32 => "No such file or directory",
+        x if x == syscall::EINTR as u32 => "Interrupted system call",
+        x if x == syscall::EIO as u32 => "I/O error",
+        x if x == syscall::EBADF as u32 => "Bad file descriptor",
+        x if x == syscall::EAGAIN as u32 => "Resource temporarily unavailable",
+        x if x == syscall::ENOMEM as u32 => "Cannot allocate memory",
+        x if x == syscall::EACCES as u32 => "Permission denied",
+        x if x == syscall::EFAULT as u32 => "Bad address",
+        x if x == syscall::EBUSY as u32 => "Device or resource busy",
+        x if x == syscall::EEXIST as u32 => "File exists",
+        x if x == syscall::ENOTDIR as u32 => "Not a directory",
+        x if x == syscall::EISDIR as u32 => "Is a directory",
+        x if x == syscall::EINVAL as u32 => "Invalid argument",
+        x if x == syscall::ENOSYS as u32 => "Function not implemented",
+        x if x == syscall::ENOTEMPTY as u32 => "Directory not empty",
+        _ => "Unknown error",
+    };
+    let msg_bytes = msg.as_bytes();
+    unsafe {
+        let avail = *dst_len;
+        let copy_len = avail.min(msg_bytes.len());
+        core::ptr::copy_nonoverlapping(msg_bytes.as_ptr(), dst, copy_len);
+        *dst_len = copy_len;
+        copy_len as isize
+    }
 }
 
 #[unsafe(no_mangle)]
@@ -471,15 +524,20 @@ pub unsafe extern "C" fn redox_sys_call_v0(
     metadata_len: usize,
 ) -> isize {
     let flags = CallFlags::from_bits_retain(flags);
-    let read = flags.contains(syscall::CallFlags::READ);
-    let write = flags.contains(syscall::CallFlags::WRITE);
-    let payload = unsafe { core::slice::from_raw_parts_mut(payload, payload_len) };
+
     let metadata = unsafe { core::slice::from_raw_parts(metadata, metadata_len) };
 
-    Error::mux(match (read, write) {
-        (true, true) => redox_rt::sys::sys_call_rw(fd, payload, flags, metadata),
-        (true, false) => redox_rt::sys::sys_call_ro(fd, payload, flags, metadata),
-        (false, true) => redox_rt::sys::sys_call_wo(fd, payload, flags, metadata),
-        (false, false) => redox_rt::sys::sys_call(fd, payload, flags, metadata),
-    }) as isize
+    let result = if flags.contains(CallFlags::READ) {
+        let payload = unsafe { core::slice::from_raw_parts_mut(payload, payload_len) };
+        if flags.contains(CallFlags::WRITE) {
+            syscall::call_rw(fd, payload, flags, metadata)
+        } else {
+            syscall::call_ro(fd, payload, flags, metadata)
+        }
+    } else {
+        let payload = unsafe { core::slice::from_raw_parts(payload, payload_len) };
+        syscall::call_wo(fd, payload, flags, metadata)
+    };
+
+    Error::mux(result) as isize
 }