0.3.0: converge kernel onto upstream master

- Rebase all Red Bear kernel changes onto upstream master (4d5d36d4).
- Update version to 0.5.12+rb0.3.0 and add Red Bear author attribution.
- Switch redox_syscall direct dependency to local fork path (../syscall).
- Bump rust-toolchain.toml to nightly-2026-05-24.
- Regenerate Cargo.lock for +rb0.3.0 suffixes and path deps.

src/syscall/debug.rs

@@ -44,8 +44,8 @@ unsafe fn read_struct<T>(ptr: usize) -> Result<T> {
 //TODO: calling format_call with arguments from another process space will not work
 pub fn format_call(a: usize, b: usize, c: usize, d: usize, e: usize, f: usize, g: usize) -> String {
     match a {
-        SYS_OPENAT_INTO => format!(
-            "openat_into({} {:?}, {:#0x}, {}, out: {})",
+        SYS_OPENAT => format!(
+            "openat({} {:?}, {:#0x}, {}, {})",
             b,
             debug_path(c, d).as_ref().map(|p| ByteStr(p.as_bytes())),
             e,
@@ -61,11 +61,10 @@ pub fn format_call(a: usize, b: usize, c: usize, d: usize, e: usize, f: usize, g
             g,
         ),
         SYS_CLOSE => format!("close({})", b),
-        SYS_DUP_INTO => format!(
-            "dup_into({}, {:?}, out: {})",
+        SYS_DUP => format!(
+            "dup({}, {:?})",
             b,
             debug_buf(c, d).as_ref().map(|b| ByteStr(b)),
-            e,
         ),
         SYS_DUP2 => format!(
             "dup2({}, {}, {:?})",
@@ -73,6 +72,7 @@ pub fn format_call(a: usize, b: usize, c: usize, d: usize, e: usize, f: usize, g
             c,
             debug_buf(d, e).as_ref().map(|b| ByteStr(b)),
         ),
+        SYS_SENDFD => format!("sendfd({}, {}, {:#0x} {:#0x} {:#0x})", b, c, d, e, f,),
         SYS_READ => format!("read({}, {:#X}, {})", b, c, d),
         SYS_READ2 => format!(
             "read2({}, {:#X}, {}, {}, {:?})",
@@ -103,6 +103,7 @@ pub fn format_call(a: usize, b: usize, c: usize, d: usize, e: usize, f: usize, g
             },
             d
         ),
+        SYS_FCHMOD => format!("fchmod({}, {:#o})", b, c),
         SYS_FCHOWN => format!("fchown({}, {}, {})", b, c, d),
         SYS_FCNTL => format!(
             "fcntl({}, {} ({}), {:#X})",
@@ -113,6 +114,7 @@ pub fn format_call(a: usize, b: usize, c: usize, d: usize, e: usize, f: usize, g
                 F_SETFD => "F_SETFD",
                 F_SETFL => "F_SETFL",
                 F_GETFL => "F_GETFL",
+                F_DUPFD_CLOEXEC => "F_DUPFD_CLOEXEC",
                 _ => "UNKNOWN",
             },
             c,
@@ -132,7 +134,22 @@ pub fn format_call(a: usize, b: usize, c: usize, d: usize, e: usize, f: usize, g
             b,
             UserSlice::ro(c, d).and_then(|buf| unsafe { buf.read_exact::<Stat>() }),
         ),
+        SYS_FSTATVFS => format!("fstatvfs({}, {:#X}, {})", b, c, d),
         SYS_FSYNC => format!("fsync({})", b),
+        SYS_FTRUNCATE => format!("ftruncate({}, {})", b, c),
+        SYS_FUTIMENS => format!(
+            "futimens({}, {:?})",
+            b,
+            UserSlice::ro(c, d).and_then(|buf| {
+                let mut times = vec![unsafe { buf.read_exact::<TimeSpec>()? }];
+
+                // One or two timespecs
+                if let Some(second) = buf.advance(size_of::<TimeSpec>()) {
+                    times.push(unsafe { second.read_exact::<TimeSpec>()? });
+                }
+                Ok(times)
+            }),
+        ),
         SYS_CALL => format!(
             "call({b}, {c:x}+{d}, {:?}, {:0x?}",
             CallFlags::from_bits_retain(e & !0xff),
@@ -153,6 +170,15 @@ pub fn format_call(a: usize, b: usize, c: usize, d: usize, e: usize, f: usize, g
             e,
             f
         ),
+        SYS_MKNS => format!(
+            "mkns({:p} len: {})",
+            // TODO: Print out all scheme names?
+
+            // Simply printing out simply the pointers and lengths may not provide that much useful
+            // debugging information, so only print the raw args.
+            b as *const u8,
+            c,
+        ),
         SYS_MPROTECT => format!("mprotect({:#X}, {}, {:?})", b, c, MapFlags::from_bits(d)),
         SYS_MREMAP => format!("mremap({:#X}, {:#X}, {:#X}, {:#X}, {:#X})", b, c, d, e, f),
         SYS_NANOSLEEP => format!(
@@ -203,11 +229,12 @@ pub fn debug_start([a, b, c, d, e, f, g]: [usize; 7], token: &mut CleanLockToken
 
     #[expect(clippy::overly_complex_bool_expr)]
     #[expect(clippy::needless_bool)]
-    let do_debug = if true && {
-        let ctx = crate::context::current();
-        let guard = ctx.read(token.token());
-        guard.name.contains("init") || guard.name.contains("bootstrap")
-    } {
+    let do_debug = if false
+        && crate::context::current()
+            .read(token.token())
+            .name
+            .contains("init")
+    {
         if a == SYS_CLOCK_GETTIME || a == SYS_YIELD || a == SYS_FUTEX {
             false
         } else if (a == SYS_WRITE || a == SYS_FSYNC) && (b == 1 || b == 2) {