I/O Multiplexing

FD is non-blocking. A per-FD flag is the simplest way to track this across all. Why it matters: Every read/write syscall path must be able to check whether the. Focus on `nonblock` and `FdEntry` in `kernel/src/process/mod.rs` while you trace the snippet.

/// A single open-file entry in the per-process FD table.
#[derive(Clone)]
pub struct FdEntry {
    pub backend: FdBackend,
    pub offset: usize,
    /// True if the file was opened for reading.
    pub readable: bool,
    /// True if the file was opened for writing.
    pub writable: bool,
    /// Close-on-exec flag (FD_CLOEXEC).
    pub cloexec: bool,
    /// Non-blocking I/O flag (O_NONBLOCK). When set, read/write return
    /// `-EAGAIN` instead of blocking when no data is available (Phase 37).
    pub nonblock: bool,
}

View on GitHub

Userspace relies on fcntl(fd, F_SETFL, O_NONBLOCK) to toggle non-blocking mode,. Why it matters: The current F_GETFL/F_SETFL handlers are stubs that return 0. Focus on `fcntl(F_GETFL)` and `fcntl(F_SETFL)` in `kernel/src/arch/x86_64/syscall.rs` while you trace the snippet.

/// Minimal fcntl: F_DUPFD, F_GETFD, F_SETFD, F_GETFL, F_SETFL.
fn sys_fcntl(fd: u64, cmd: u64, arg: u64) -> u64 {
    const F_DUPFD: u64 = 0;
    const F_GETFD: u64 = 1;
    const F_SETFD: u64 = 2;
    const F_GETFL: u64 = 3;
    const F_SETFL: u64 = 4;
    const F_DUPFD_CLOEXEC: u64 = 1030;

    match cmd {
        F_DUPFD | F_DUPFD_CLOEXEC => {
            // Find the next free fd >= arg, duplicate oldfd into it.
            let set_cloexec = cmd == F_DUPFD_CLOEXEC;
            let oldfd = fd as usize;
            let min_fd = arg as usize;
            if oldfd >= MAX_FDS {
                return NEG_EBADF;
            }
            if min_fd >= MAX_FDS {
                return NEG_EINVAL;
            }
            let mut entry = match current_fd_entry(oldfd) {
                Some(e) => e,
                None => return NEG_EBADF,

View on GitHub

blocked in poll on the read end must be woken. A per-pipe wait queue provides. Why it matters: When data is written to a pipe (or a writer closes), tasks. Focus on `PIPES` and `WaitQueue` in `kernel/src/pipe.rs` while you trace the snippet.

/// Write to a pipe. Returns:
///   - `Ok(n)` — n bytes written
///   - `Err(false)` — reader closed (EPIPE)
///   - `Err(true)` — buffer full but reader still open (would block)
pub fn pipe_write(pipe_id: usize, src: &[u8]) -> Result<usize, bool> {
    let mut table = PIPE_TABLE.lock();
    let pipe = match table.get_mut(pipe_id).and_then(|p| p.as_mut()) {
        Some(p) => p,
        None => return Err(false),
    };

    if !pipe.has_reader() {
        return Err(false); // EPIPE
    }

    if pipe.is_full() {
        return Err(true); // would block
    }

    let n = pipe.write(src);
    drop(table);
    // Wake readers that may be waiting for data.
    wake_pipe(pipe_id);
    Ok(n)

View on GitHub