feat(syscall): add inotify syscalls

LHHL7 · LHHL7 · commit 63cc59c55bd1 · 2025-12-09T11:52:57.000+08:00
diff --git a/api/src/file/inotify.rs b/api/src/file/inotify.rs
@@ -0,0 +1,283 @@
+use alloc::{
+    borrow::Cow,
+    collections::{BTreeMap, VecDeque},
+    string::String,
+    sync::Arc,
+    vec::Vec,
+};
+use core::{
+    any::Any,
+    mem::size_of,
+    sync::atomic::{AtomicBool, Ordering},
+};
+
+use axerrno::{AxError, AxResult};
+use axio::{BufMut, Write};
+use axpoll::{IoEvents, PollSet, Pollable};
+use axsync::Mutex;
+use axtask::future::{block_on, poll_io};
+use bitflags::bitflags;
+
+use crate::{
+    alloc::string::ToString,
+    file::{FileLike, Kstat, SealedBuf, SealedBufMut},
+};
+
+/// ========== Inotify event flags ==========
+pub const IN_ACCESS: u32 = 0x00000001; // File was accessed
+pub const IN_MODIFY: u32 = 0x00000002; // File was modified
+pub const IN_ATTRIB: u32 = 0x00000004; // Metadata changed
+pub const IN_CLOSE_WRITE: u32 = 0x00000008; // Writtable file was closed
+pub const IN_CLOSE_NOWRITE: u32 = 0x00000010; // Unwrittable file closed
+pub const IN_OPEN: u32 = 0x00000020; // File was opened
+pub const IN_MOVED_FROM: u32 = 0x00000040; // File was moved from X
+pub const IN_MOVED_TO: u32 = 0x00000080; // File was moved to Y
+pub const IN_CREATE: u32 = 0x00000100; // Subfile was created
+pub const IN_DELETE: u32 = 0x00000200; // Subfile was deleted
+pub const IN_DELETE_SELF: u32 = 0x00000400; // Self was deleted
+pub const IN_MOVE_SELF: u32 = 0x00000800; // Self was moved
+
+// only set by the kernel
+pub const IN_UNMOUNT: u32 = 0x00002000; // Backing fs was unmounted
+pub const IN_Q_OVERFLOW: u32 = 0x00004000; // Event queued overflowed
+pub const IN_IGNORED: u32 = 0x00008000; // File was ignored
+
+/// ==========  Flags for inotify_init1()==========
+pub const IN_CLOEXEC: u32 = 0o2000000; // 02000000, Set FD_CLOEXEC
+pub const IN_NONBLOCK: u32 = 0o0004000; // 00004000, Set O_NONBLOCK
+
+/// ========== Special flags for inotify_add_watch()）==========
+pub const IN_DONT_FOLLOW: u32 = 0x02000000; // Don't follow a sym link
+pub const IN_EXCL_UNLINK: u32 = 0x04000000; // Exclude events on unlinked objects
+pub const IN_MASK_CREATE: u32 = 0x10000000; // Only create watches
+pub const IN_MASK_ADD: u32 = 0x20000000; // Add to the mask of an already existing watch
+pub const IN_ONLYDIR: u32 = 0x01000000; // Only watch the path if it is a directory
+
+/// ========== Auxiliary flags==========
+pub const IN_CLOSE: u32 = IN_CLOSE_WRITE | IN_CLOSE_NOWRITE; // close
+pub const IN_MOVE: u32 = IN_MOVED_FROM | IN_MOVED_TO; // moves
+pub const IN_ISDIR: u32 = 0x40000000; // event occurred against dir
+pub const IN_ONESHOT: u32 = 0x80000000; // only send event once
+
+// Combination flags (not required, but recommended)
+pub const IN_ALL_EVENTS: u32 = 0x00000fff; // Combination of the first 12 events
+
+// flags for inotify_syscalls
+bitflags! {
+    #[derive(Debug, Clone, Copy, Default)]
+    pub struct InotifyFlags: u32 {
+        /// Create a file descriptor that is closed on `exec`.
+        const CLOEXEC = IN_CLOEXEC;
+        /// Create a non-blocking inotify instance.
+        const NONBLOCK = IN_NONBLOCK;
+    }
+}
+
+/// inotifyEvent(Memory layout fully compatible with Linux)
+#[repr(C)]
+#[derive(Debug, Clone, Copy)]
+pub struct InotifyEvent {
+    pub wd: i32,     // Watch descriptor
+    pub mask: u32,   // Mask describing event
+    pub cookie: u32, // Unique cookie associating related events
+    pub len: u32,    /* Size of name field  (including null terminator)
+                      * attention:The name field is a variable-length array, which does not contain */
+}
+
+/// inotify instance
+pub struct InotifyInstance {
+    // event_queue:save serialized event data
+    event_queue: Mutex<VecDeque<Vec<u8>>>,
+
+    // watches: wd -> (path, event mask)
+    watches: Mutex<BTreeMap<i32, (String, u32)>>,
+    next_wd: Mutex<i32>,
+
+    // blocking/non-blocking mode
+    non_blocking: AtomicBool,
+
+    // poll support
+    poll_set: PollSet,
+}
+
+impl InotifyInstance {
+    /// create new instance
+    pub fn new(flags: i32) -> AxResult<Arc<Self>> {
+        let flags = flags as u32;
+        // verify flags
+        let valid_flags = IN_NONBLOCK | IN_CLOEXEC;
+        if flags & !valid_flags != 0 {
+            return Err(AxError::InvalidInput);
+        }
+
+        let non_blocking = (flags & IN_NONBLOCK) != 0;
+
+        Ok(Arc::new(Self {
+            event_queue: Mutex::new(VecDeque::new()),
+            watches: Mutex::new(BTreeMap::new()),
+            next_wd: Mutex::new(1),
+            non_blocking: AtomicBool::new(non_blocking),
+            poll_set: PollSet::new(),
+        }))
+    }
+
+    /// Serialized events are in binary format for users to read with char[]
+    fn serialize_event(event: &InotifyEvent, name: Option<&str>) -> Vec<u8> {
+        // +1 for null terminator
+        let name_len = name.map(|s| s.len() + 1).unwrap_or(0);
+        let total_len = size_of::<InotifyEvent>() + name_len;
+
+        // Linux requires events to be 4-byte aligned
+        let aligned_len = (total_len + 3) & !3;
+
+        let mut buf = Vec::with_capacity(aligned_len);
+
+        // Write event header (native byte order, matching architecture)
+        buf.extend_from_slice(&event.wd.to_ne_bytes());
+        buf.extend_from_slice(&event.mask.to_ne_bytes());
+        buf.extend_from_slice(&event.cookie.to_ne_bytes());
+        buf.extend_from_slice(&(name_len as u32).to_ne_bytes());
+
+        // Write filename (if any)
+        if let Some(name) = name {
+            buf.extend_from_slice(name.as_bytes());
+            buf.push(0); // null terminator
+
+            // Padding for alignment (using null bytes)
+            let padding = aligned_len - total_len;
+            buf.resize(buf.len() + padding, 0);
+        }
+
+        buf
+    }
+
+    /// add watch for a path
+    /// Returns watch descriptor (wd)
+    pub fn add_watch(&self, path: &str, mask: u32) -> AxResult<i32> {
+        let mut watches = self.watches.lock();
+
+        // Check if a watch for this path already exists
+        for (&existing_wd, (existing_path, _existing_mask)) in watches.iter() {
+            if existing_path == path {
+                // Overwrite existing watch (Linux default behavior)
+                // Note: return the same wd
+                watches.insert(existing_wd, (path.to_string(), mask));
+                return Ok(existing_wd);
+            }
+        }
+
+        // Generate a new watch descriptor
+        let mut next_wd = self.next_wd.lock();
+        let wd = *next_wd;
+        *next_wd += 1;
+
+        watches.insert(wd, (path.to_string(), mask));
+        Ok(wd)
+    }
+
+    /// remove watch (generate IN_IGNORED event)
+    pub fn remove_watch(&self, wd: i32) -> AxResult<()> {
+        let mut watches = self.watches.lock();
+
+        if watches.remove(&wd).is_some() {
+            // Generate IN_IGNORED event (required by Linux)
+            let event = InotifyEvent {
+                wd,
+                mask: IN_IGNORED,
+                cookie: 0,
+                len: 0,
+            };
+
+            let event_data = Self::serialize_event(&event, None);
+            self.push_event(event_data);
+
+            Ok(())
+        } else {
+            Err(AxError::InvalidInput)
+        }
+    }
+
+    /// Push event to queue
+    fn push_event(&self, event_data: Vec<u8>) {
+        let mut queue = self.event_queue.lock();
+        queue.push_back(event_data);
+        self.poll_set.wake();
+    }
+}
+
+impl FileLike for InotifyInstance {
+    fn read(&self, dst: &mut SealedBufMut) -> axio::Result<usize> {
+        block_on(poll_io(self, IoEvents::IN, self.nonblocking(), || {
+            let mut queue = self.event_queue.lock();
+
+            if queue.is_empty() {
+                return Err(AxError::WouldBlock);
+            }
+
+            let mut bytes_written = 0;
+
+            // Write as many events as possible without exceeding the buffer
+            while let Some(event_data) = queue.front() {
+                if dst.remaining_mut() < event_data.len() {
+                    break;
+                }
+
+                dst.write(event_data)?;
+                bytes_written += event_data.len();
+                queue.pop_front();
+            }
+
+            if bytes_written > 0 {
+                Ok(bytes_written)
+            } else {
+                // Buffer too small to write a complete event
+                Err(AxError::InvalidInput)
+            }
+        }))
+    }
+
+    fn write(&self, _src: &mut SealedBuf) -> axio::Result<usize> {
+        Err(AxError::BadFileDescriptor)
+    }
+
+    fn stat(&self) -> axio::Result<Kstat> {
+        Ok(Kstat::default())
+    }
+
+    fn nonblocking(&self) -> bool {
+        self.non_blocking.load(Ordering::Acquire)
+    }
+
+    fn set_nonblocking(&self, non_blocking: bool) -> axio::Result {
+        self.non_blocking.store(non_blocking, Ordering::Release);
+        Ok(())
+    }
+
+    fn path(&self) -> Cow<str> {
+        "anon_inode:[inotify]".into()
+    }
+
+    fn into_any(self: Arc<Self>) -> Arc<dyn Any + Send + Sync> {
+        self
+    }
+}
+
+impl Pollable for InotifyInstance {
+    fn poll(&self) -> IoEvents {
+        let mut events = IoEvents::empty();
+        let queue = self.event_queue.lock();
+
+        // Events available to read
+        events.set(IoEvents::IN, !queue.is_empty());
+        // inotify file is not writable
+        events.set(IoEvents::OUT, false);
+
+        events
+    }
+
+    fn register(&self, context: &mut core::task::Context<'_>, events: IoEvents) {
+        if events.contains(IoEvents::IN) {
+            self.poll_set.register(context.waker());
+        }
+    }
+}
diff --git a/api/src/file/mod.rs b/api/src/file/mod.rs
@@ -1,6 +1,7 @@
 pub mod epoll;
 pub mod event;
 mod fs;
+pub mod inotify;
 mod net;
 mod pidfd;
 mod pipe;
@@ -23,6 +24,7 @@ use starry_core::{resources::AX_FILE_LIMIT, task::AsThread};
 
 pub use self::{
     fs::{Directory, File, ResolveAtResult, metadata_to_kstat, resolve_at, with_fs},
+    inotify::InotifyInstance,
     net::Socket,
     pidfd::PidFd,
     pipe::Pipe,
diff --git a/api/src/syscall/fs/inotify.rs b/api/src/syscall/fs/inotify.rs
@@ -0,0 +1,79 @@
+use core::ffi::c_char;
+
+use axerrno::{AxError, AxResult};
+
+use crate::{
+    file::{
+        add_file_like, get_file_like,
+        inotify::{InotifyFlags, InotifyInstance},
+    },
+    mm::vm_load_string,
+};
+pub fn sys_inotify_init1(flags: i32) -> AxResult<isize> {
+    let instance = InotifyInstance::new(flags)?;
+
+    // Use add_file_like to add file descriptor
+    let cloexec = (flags as u32) & InotifyFlags::CLOEXEC.bits() != 0;
+    add_file_like(instance, cloexec).map(|fd| {
+        debug!("sys_inotify_init1: allocated fd {fd}");
+        fd as isize
+    })
+}
+
+pub fn sys_inotify_add_watch(fd: i32, pathname: *const c_char, mask: u32) -> AxResult<isize> {
+    debug!("inotify_add_watch called: fd={fd}, mask={mask:#x}");
+
+    // Load pathname (using vm_load_string, same as sys_open)
+    let path = vm_load_string(pathname)?;
+    // Get file corresponding to file descriptor
+    let file = get_file_like(fd)?;
+    // Convert to inotify instance
+    let inotify = match file.clone().into_any().downcast::<InotifyInstance>() {
+        Ok(inst) => inst,
+        Err(_) => {
+            warn!("inotify_add_watch: fd {fd} is not an inotify instance");
+            return Err(AxError::InvalidInput);
+        }
+    };
+    // Get current process information (for permission checks)
+    // let curr = current();
+    // let proc_data = &curr.as_thread().proc_data;
+
+    // Add watch
+    let wd = inotify.add_watch(&path, mask)?;
+
+    info!("inotify watch added: fd={fd}, path={path}, wd={wd}");
+    Ok(wd as isize)
+}
+
+pub fn sys_inotify_rm_watch(fd: i32, wd: i32) -> AxResult<isize> {
+    debug!("sys_inotify_rm_watch: fd={fd}, wd={wd}");
+
+    // Get file
+    let file = get_file_like(fd)?;
+    // let file = match get_file_like(fd) {
+    //     Ok(f) => f,
+    //     Err(AxError::BadFileDescriptor) => {
+    //         warn!("inotify_rm_watch: bad file descriptor {}", fd);
+    //         return Err(AxError::BadFileDescriptor);
+    //     }
+    //     Err(e) => {
+    //         warn!("inotify_rm_watch: get_file_like failed: {:?}", e);
+    //         return Err(AxError::InvalidInput);
+    //     }
+    // };
+
+    // Convert to inotify instance
+    let inotify = match file.clone().into_any().downcast::<InotifyInstance>() {
+        Ok(inst) => inst,
+        Err(_) => {
+            warn!("inotify_rm_watch: fd {fd} is not an inotify instance");
+            return Err(AxError::InvalidInput);
+        }
+    };
+
+    // Remove watch
+    inotify.remove_watch(wd)?;
+    info!("inotify_rm_watch: removed watch wd={wd} from fd={fd}");
+    Ok(0)
+}
diff --git a/api/src/syscall/fs/mod.rs b/api/src/syscall/fs/mod.rs
@@ -1,6 +1,7 @@
 mod ctl;
 mod event;
 mod fd_ops;
+mod inotify;
 mod io;
 mod memfd;
 mod mount;
@@ -10,5 +11,6 @@ mod signalfd;
 mod stat;
 
 pub use self::{
-    ctl::*, event::*, fd_ops::*, io::*, memfd::*, mount::*, pidfd::*, pipe::*, signalfd::*, stat::*,
+    ctl::*, event::*, fd_ops::*, inotify::*, io::*, memfd::*, mount::*, pidfd::*, pipe::*,
+    signalfd::*, stat::*,
 };
diff --git a/api/src/syscall/mod.rs b/api/src/syscall/mod.rs
