feat(syscall): add clone3 support (#122)

Co-authored-by: WyZ0125 <iewyzhu@163.com>
Co-authored-by: 朝倉水希 <asakuramizu111@gmail.com>

Author: 3 people

kernel/src/file/pidfd.rs

@@ -2,39 +2,84 @@ use alloc::{
     borrow::Cow,
     sync::{Arc, Weak},
 };
-use core::task::Context;
+use core::{
+    sync::atomic::{AtomicBool, Ordering},
+    task::Context,
+};
 
 use axerrno::{AxError, AxResult};
 use axpoll::{IoEvents, PollSet, Pollable};
 
-use crate::{file::FileLike, task::ProcessData};
+use crate::{
+    file::FileLike,
+    task::{ProcessData, Thread},
+};
 
 pub struct PidFd {
     proc_data: Weak<ProcessData>,
     exit_event: Arc<PollSet>,
+    thread_exit: Option<Arc<AtomicBool>>,
+
+    non_blocking: AtomicBool,
 }
 impl PidFd {
-    pub fn new(proc_data: &Arc<ProcessData>) -> Self {
+    pub fn new_process(proc_data: &Arc<ProcessData>) -> Self {
         Self {
             proc_data: Arc::downgrade(proc_data),
             exit_event: proc_data.exit_event.clone(),
+            thread_exit: None,
+
+            non_blocking: AtomicBool::new(false),
+        }
+    }
+
+    pub fn new_thread(thread: &Thread) -> Self {
+        Self {
+            proc_data: Arc::downgrade(&thread.proc_data),
+            exit_event: thread.exit_event.clone(),
+            thread_exit: Some(thread.exit.clone()),
+
+            non_blocking: AtomicBool::new(false),
         }
     }
 
     pub fn process_data(&self) -> AxResult<Arc<ProcessData>> {
+        // For threads, the pidfd is invalid once the thread exits, even if its
+        // process is still alive.
+        if let Some(thread_exit) = &self.thread_exit
+            && thread_exit.load(Ordering::Acquire)
+        {
+            return Err(AxError::NoSuchProcess);
+        }
         self.proc_data.upgrade().ok_or(AxError::NoSuchProcess)
     }
 }
 impl FileLike for PidFd {
     fn path(&self) -> Cow<'_, str> {
         "anon_inode:[pidfd]".into()
     }
+
+    fn set_nonblocking(&self, nonblocking: bool) -> AxResult {
+        self.non_blocking.store(nonblocking, Ordering::Release);
+        Ok(())
+    }
+
+    fn nonblocking(&self) -> bool {
+        self.non_blocking.load(Ordering::Acquire)
+    }
 }
 
 impl Pollable for PidFd {
     fn poll(&self) -> IoEvents {
         let mut events = IoEvents::empty();
-        events.set(IoEvents::IN, self.proc_data.strong_count() > 0);
+        events.set(
+            IoEvents::IN,
+            self.proc_data.strong_count() > 0
+                && self
+                    .thread_exit
+                    .as_ref()
+                    .is_none_or(|it| !it.load(Ordering::Acquire)),
+        );
         events
     }
 

kernel/src/syscall/fs/pidfd.rs

@@ -1,21 +1,34 @@
 use axerrno::{AxError, AxResult};
+use bitflags::bitflags;
 use starry_signal::SignalInfo;
 
 use crate::{
     file::{FD_TABLE, FileLike, PidFd, add_file_like},
     syscall::signal::make_queue_signal_info,
-    task::{get_process_data, send_signal_to_process},
+    task::{AsThread, get_process_data, get_task, send_signal_to_process},
 };
 
+bitflags! {
+    #[derive(Debug, Clone, Copy, Default)]
+    pub struct PidFdFlags: u32 {
+        const NONBLOCK = 2048;
+        const THREAD = 128;
+    }
+}
+
 pub fn sys_pidfd_open(pid: u32, flags: u32) -> AxResult<isize> {
     debug!("sys_pidfd_open <= pid: {pid}, flags: {flags}");
 
-    if flags != 0 {
-        return Err(AxError::InvalidInput);
-    }
+    let flags = PidFdFlags::from_bits(flags).ok_or(AxError::InvalidInput)?;
 
-    let task = get_process_data(pid)?;
-    let fd = PidFd::new(&task);
+    let fd = if flags.contains(PidFdFlags::THREAD) {
+        PidFd::new_thread(get_task(pid)?.as_thread())
+    } else {
+        PidFd::new_process(&get_process_data(pid)?)
+    };
+    if flags.contains(PidFdFlags::NONBLOCK) {
+        fd.set_nonblocking(true)?;
+    }
 
     fd.add_to_fd_table(true).map(|fd| fd as _)
 }

kernel/src/syscall/mod.rs

@@ -429,6 +429,11 @@ pub fn handle_syscall(uctx: &mut UserContext) {
             uctx.arg3(),
             uctx.arg4(),
         ),
+        Sysno::clone3 => sys_clone3(
+            uctx,
+            uctx.arg0() as _, // args_ptr
+            uctx.arg1() as _, // args_size
+        ),
         #[cfg(target_arch = "x86_64")]
         Sysno::fork => sys_fork(uctx),
         Sysno::exit => sys_exit(uctx.arg0() as _),