Merge pull request #234 from Freax13/enhancement/misc-2026-02-17

a few small fixes

Author: Freax13

tee/kernel/src/fs/fd/stream_buffer.rs

@@ -675,6 +675,10 @@ impl WriteHalf {
         guard.write_shutdown = true;
         self.notify().notify();
     }
+
+    pub fn is_either_reset(&self) -> bool {
+        self.data.buffer.lock().ty.is_either_reset()
+    }
 }
 
 impl Drop for WriteHalf {

tee/kernel/src/fs/fd/unix_socket/dgram.rs

@@ -469,7 +469,7 @@ impl OpenFileDescription for DgramUnixSocket {
         }
         drop(cmsg_builder);
 
-        Ok(len)
+        Ok(written)
     }
 
     fn write(&self, buf: &dyn WriteBuf, ctx: &FileAccessContext) -> Result<usize> {

tee/kernel/src/net/tcp.rs

@@ -487,14 +487,16 @@ impl OpenFileDescription for TcpSocket {
         let Mode::Passive(passive) = mode else {
             bail!(Inval);
         };
-        let active = passive
-            .internal
-            .lock()
-            .queue
-            .pop_front()
-            .ok_or(err!(Again))?;
+        let mut guard = passive.internal.lock();
+        let active = guard.queue.pop_front().ok_or(err!(Again))?;
+        let now_empty = guard.queue.is_empty();
+        drop(guard);
         let remote_addr = active.remote_addr;
 
+        if now_empty {
+            passive.notify.notify();
+        }
+
         let mut internal = self.internal.lock().clone();
         internal
             .flags
@@ -862,6 +864,7 @@ impl OpenFileDescription for TcpSocket {
                 active.read_half.write_shutdown();
             }
         }
+        ensure!(!active.write_half.is_either_reset(), NotConn);
         Ok(())
     }
 

tee/kernel/src/user/exec.rs

@@ -1,5 +1,5 @@
 use alloc::{borrow::ToOwned, ffi::CString, vec};
-use core::{ffi::CStr, iter::from_fn};
+use core::{cmp, ffi::CStr, iter::from_fn};
 
 use bytemuck::{Zeroable, bytes_of_mut};
 use usize_conversions::FromUsize;
@@ -133,15 +133,17 @@ impl VirtualMemory {
         self.modify().init_brk(brk_start);
 
         // Create stack.
+        const MIN_SIZE: u64 = 64 * 1024 * 1024;
         let len = stack_limit.get();
+        let allocation_size = cmp::max(MIN_SIZE, len);
         let bias = Bias::Dynamic {
             abi: E::ABI,
             map_32bit: false,
         };
-        let stack = self
-            .modify()
-            .allocate_stack(bias, len, CurrentAsLimit::INFINITE)?
-            + len;
+        let stack =
+            self.modify()
+                .allocate_stack(bias, allocation_size, CurrentAsLimit::INFINITE)?
+                + allocation_size;
 
         // Sum up the number of pointer-sized values that need to be placed in
         // a contigous chunk of memory.

tee/kernel/src/user/process/limits.rs

@@ -31,7 +31,7 @@ impl Limits {
                 rlim_max: RLimit::INFINITY,
             }),
             stack: AtomicRLimit::new(RLimit {
-                rlim_cur: 64 * 1024 * 1024,
+                rlim_cur: 8 * 1024 * 1024,
                 rlim_max: RLimit::INFINITY,
             }),
             core: AtomicRLimit::new(RLimit {

tee/kernel/src/user/syscall.rs

@@ -340,6 +340,7 @@ const SYSCALL_HANDLERS: SyscallHandlers = {
     handlers.register(SysOldGetrlimit);
     handlers.register(SysGetrusage);
     handlers.register(SysSysinfo);
+    handlers.register(SysTimes);
     handlers.register(SysPtrace);
     handlers.register(SysGetuid);
     handlers.register(SysGetgid);
@@ -3435,6 +3436,39 @@ fn sysinfo(
     Ok(0)
 }
 
+#[syscall(i386 = 43, amd64 = 100)]
+fn times(
+    abi: Abi,
+    thread: &Arc<Thread>,
+    #[state] virtual_memory: Arc<VirtualMemory>,
+    buf: Pointer<Tms>,
+) -> SyscallResult {
+    let process = thread.process();
+
+    let guard = process.self_usage.lock();
+    let utime = guard.utime;
+    let stime = guard.stime;
+    drop(guard);
+
+    let guard = process.children_usage.lock();
+    let cutime = guard.utime;
+    let cstime = guard.stime;
+    drop(guard);
+
+    let times = Tms {
+        utime: Clock::from(utime),
+        stime: Clock::from(stime),
+        cutime: Clock::from(cutime),
+        cstime: Clock::from(cstime),
+    };
+    virtual_memory.write_with_abi(buf, times, abi)?;
+
+    let monotonic = now(ClockId::Monotonic);
+    let monotonic = Timeval::from(monotonic);
+    let clock = Clock::from(monotonic);
+    Ok(clock.0)
+}
+
 #[syscall(i386 = 26, amd64 = 101)]
 fn ptrace(
     abi: Abi,

tee/kernel/src/user/syscall/args.rs

@@ -2853,3 +2853,24 @@ enum_arg! {
         Invalid = 0xffff_ffff,
     }
 }
+
+#[derive(Debug, Clone, Copy)]
+pub struct Clock(pub u64);
+
+impl From<Timeval> for Clock {
+    fn from(value: Timeval) -> Self {
+        Self(value.tv_sec as u64 * 1_000_000 + u64::from(value.tv_usec))
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct Tms {
+    /// user time
+    pub utime: Clock,
+    /// system time
+    pub stime: Clock,
+    /// user time of children
+    pub cutime: Clock,
+    /// system time of children
+    pub cstime: Clock,
+}

tee/kernel/src/user/syscall/args/pointee.rs

@@ -28,14 +28,14 @@ use crate::{
         memory::VirtualMemory,
         syscall::{
             args::{
-                CmsgHdr, ControlMode, Domain, FdNum, FileMode, Flock, FlockType, FlockWhence,
-                ITimerspec, ITimerval, InputMode, Iovec, IpMreq, IpMreqn, Ipv6Mreq, Linger,
-                LinuxDirent64, LocalMode, LongOffset, MMsgHdr, MsgHdr, MsgHdrFlags, Offset,
+                Clock, CmsgHdr, ControlMode, Domain, FdNum, FileMode, Flock, FlockType,
+                FlockWhence, ITimerspec, ITimerval, InputMode, Iovec, IpMreq, IpMreqn, Ipv6Mreq,
+                Linger, LinuxDirent64, LocalMode, LongOffset, MMsgHdr, MsgHdr, MsgHdrFlags, Offset,
                 OpenFlags, OpenHow, OutputMode, PSelectSigsetArg, PktInfo, PktInfo6, Pointer,
                 PtraceSyscallInfo, PtraceSyscallInfoValue, RLimit, ResolveFlags, Rusage,
                 SchedParam, SemInfo, SigEvent, SigEventData, SocketAddr, SocketAddrNetlink,
                 SocketAddrUnix, Stat, SysInfo, Termios, Time, TimerId, Timespec, Timeval, Timezone,
-                Ucred, UserCapData, UserCapHeader, UserRegs32, UserRegs64, WStatus, WinSize,
+                Tms, Ucred, UserCapData, UserCapHeader, UserRegs32, UserRegs64, WStatus, WinSize,
             },
             traits::Abi,
         },
@@ -3262,3 +3262,83 @@ impl From<PtraceSyscallInfo> for RawPtraceSyscallInfo {
 
 impl Pointee for SemInfo {}
 impl PrimitivePointee for SemInfo {}
+
+impl Pointee for Clock {}
+impl AbiDependentPointee for Clock {
+    type I386 = Clock32;
+    type Amd64 = Clock64;
+}
+
+#[derive(Debug, Clone, Copy, Pod, Zeroable)]
+#[repr(transparent)]
+pub struct Clock32(u32);
+
+#[derive(Debug, Clone, Copy, Pod, Zeroable)]
+#[repr(transparent)]
+pub struct Clock64(u64);
+
+impl From<Clock> for Clock32 {
+    fn from(value: Clock) -> Self {
+        Self(value.0 as u32)
+    }
+}
+
+impl From<Clock> for Clock64 {
+    fn from(value: Clock) -> Self {
+        Self(value.0)
+    }
+}
+
+impl Pointee for Tms {}
+impl AbiDependentPointee for Tms {
+    type I386 = Tms32;
+    type Amd64 = Tms64;
+}
+
+#[derive(Debug, Clone, Copy, Pod, Zeroable)]
+#[repr(C)]
+pub struct Tms32 {
+    /// user time
+    pub utime: Clock32,
+    /// system time
+    pub stime: Clock32,
+    /// user time of children
+    pub cutime: Clock32,
+    /// system time of children
+    pub cstime: Clock32,
+}
+
+#[derive(Debug, Clone, Copy, Pod, Zeroable)]
+#[repr(C)]
+pub struct Tms64 {
+    /// user time
+    pub utime: Clock64,
+    /// system time
+    pub stime: Clock64,
+    /// user time of children
+    pub cutime: Clock64,
+    /// system time of children
+    pub cstime: Clock64,
+}
+
+impl From<Tms> for Tms32 {
+    fn from(value: Tms) -> Self {
+        Self {
+            utime: value.utime.into(),
+            stime: value.stime.into(),
+            cutime: value.cutime.into(),
+            cstime: value.cstime.into(),
+        }
+    }
+}
+
+impl From<Tms> for Tms64 {
+    fn from(value: Tms) -> Self {
+        Self {
+            utime: value.utime.into(),
+            stime: value.stime.into(),
+            cutime: value.cutime.into(),
+            cstime: value.cstime.into(),
+        }
+    }
+}

tee/tests/src/net.rs

@@ -13,10 +13,10 @@ use nix::{
     poll::{PollFd, PollFlags, PollTimeout, poll},
     sys::{
         socket::{
-            self, AddressFamily, Backlog, ControlMessage, ControlMessageOwned, MsgFlags, SockFlag,
-            SockProtocol, SockType, SockaddrIn, SockaddrIn6, SockaddrLike, SockaddrStorage, accept,
-            connect, getpeername, getsockname, listen, recv, recvfrom, recvmsg, send, sendmsg,
-            sendto, setsockopt, shutdown, socket, socketpair,
+            self, AddressFamily, Backlog, ControlMessage, ControlMessageOwned, MsgFlags, Shutdown,
+            SockFlag, SockProtocol, SockType, SockaddrIn, SockaddrIn6, SockaddrLike,
+            SockaddrStorage, accept, connect, getpeername, getsockname, listen, recv, recvfrom,
+            recvmsg, send, sendmsg, sendto, setsockopt, shutdown, socket, socketpair,
             sockopt::{
                 Ipv4PacketInfo, Ipv4RecvTtl, Ipv6RecvHopLimit, Ipv6RecvPacketInfo, Ipv6RecvTClass,
                 Ipv6V6Only, Linger, ReceiveTimeout, ReuseAddr, ReusePort, TcpNoDelay,
@@ -2621,3 +2621,36 @@ fn tcp_close_write() {
         }
     }
 }
+
+#[test]
+fn tcp_close_write_shutdown_read() {
+    let (sock1, sock2) = tcp_socket_pair();
+    close(sock2).unwrap();
+    assert_eq!(nix::unistd::write(&sock1, b"A"), Ok(1));
+    assert_eq!(
+        shutdown(sock1.as_raw_fd(), Shutdown::Read),
+        Err(Errno::ENOTCONN)
+    );
+}
+
+#[test]
+fn tcp_close_write_shutdown_write() {
+    let (sock1, sock2) = tcp_socket_pair();
+    close(sock2).unwrap();
+    assert_eq!(nix::unistd::write(&sock1, b"A"), Ok(1));
+    assert_eq!(
+        shutdown(sock1.as_raw_fd(), Shutdown::Read),
+        Err(Errno::ENOTCONN)
+    );
+}
+
+#[test]
+fn tcp_close_write_shutdown_both() {
+    let (sock1, sock2) = tcp_socket_pair();
+    close(sock2).unwrap();
+    assert_eq!(nix::unistd::write(&sock1, b"A"), Ok(1));
+    assert_eq!(
+        shutdown(sock1.as_raw_fd(), Shutdown::Both),
+        Err(Errno::ENOTCONN)
+    );
+}