Introduction

这章介绍了 I/O 重定向和管道的功能,管道可以被抽象为文件,除了管道机制,进程之间需要一种更快捷的通知机制——一种信号的事件通知机制,主动让进程响应发出通知的请求。

Standard I/O

File trait

标准输入输出需要被抽象成文件,在这里是实现 File trait,通过调用 RustSBI 的接口

// os/src/fs/stdio.rs

pub struct Stdin;
pub struct Stdout;

impl File for Stdin {
    fn readable(&self) -> bool {
        true
    }
    fn writable(&self) -> bool {
        false
    }
    fn read(&self, mut user_buf: UserBuffer) -> usize {
        assert_eq!(user_buf.len(), 1);
        // busy loop
        let mut c: usize;
        loop {
            c = console_getchar();
            if c == 0 {
                suspend_current_and_run_next();
                continue;
            } else {
                break;
            }
        }
        let ch = c as u8;
        unsafe {
            user_buf.buffers[0].as_mut_ptr().write_volatile(ch);
        }
        1
    }
    fn write(&self, _user_buf: UserBuffer) -> usize {
        panic!("Cannot write to stdin!");
    }
}

impl File for Stdout {
    fn readable(&self) -> bool {
        false
    }
    fn writable(&self) -> bool {
        true
    }
    fn read(&self, _user_buf: UserBuffer) -> usize {
        panic!("Cannot read from stdout!");
    }
    fn write(&self, user_buf: UserBuffer) -> usize {
        for buffer in user_buf.buffers.iter() {
            print!("{}", core::str::from_utf8(*buffer).unwrap());
        }
        user_buf.len()
    }
}

为新的进程创建标准 IO

当一个进程被创建的时候,内核会默认为其打开三个缺省就存在的文件:

  • 文件描述符为 0 的标准输入
  • 文件描述符为 1 的标准输出
  • 文件描述符为 2 的标准错误输出
// os/src/task/task.rs

impl TaskControlBlock {
    pub fn new(elf_data: &[u8]) -> Self {
        ...
        let task_control_block = Self {
            pid: pid_handle,
            kernel_stack,
            inner: Mutex::new(TaskControlBlockInner {
                trap_cx_ppn,
                base_size: user_sp,
                task_cx_ptr: task_cx_ptr as usize,
                task_status: TaskStatus::Ready,
                memory_set,
                parent: None,
                children: Vec::new(),
                exit_code: 0,
                fd_table: vec![
                    // 0 -> stdin
                    Some(Arc::new(Stdin)),
                    // 1 -> stdout
                    Some(Arc::new(Stdout)),
                    // 2 -> stderr
                    Some(Arc::new(Stdout)),
                ],
            }),
        };
        ...
    }
}

注意到标准错误流和标准输入流使用了同一个输出,相比之下在 xv6 中,init 和 shell 总共会启用三个 fd ,子进程会自动继承标准IO

// user/sh.c
int
main(void)
{
  static char buf[100];
  int fd;
  // Ensure that three file descriptors are open.
  while((fd = open("console", O_RDWR)) >= 0){
    if(fd >= 3){
      close(fd);
      break;
    }
  }
  ...
}

为子进程继承标准 IO

查看 fork 发现

impl TaskControlBlock {
    ...
    pub fn fork(self: &Arc<TaskControlBlock>) -> Arc<TaskControlBlock> {
        ...
        let mut new_fd_table: Vec<Option<Arc<dyn File + Send + Sync>>> = Vec::new();    // new_fd_table 会保存到新的 TCB 中
        for fd in parent_inner.fd_table.iter() {
            if let Some(file) = fd {
                new_fd_table.push(Some(file.clone()));
            } else {
                new_fd_table.push(None);
            }
        }
        ...
    }
}

读写文件

需要对标准 IO 进行读写时和前面一样,使用 read()/write() 系统调用即可

pub fn sys_read(fd: usize, buf: *const u8, len: usize) -> isize {
    let token = current_user_token();
    let task = current_task().unwrap();
    let inner = task.inner_exclusive_access();
    if fd >= inner.fd_table.len() {
        return -1;
    }
    if let Some(file) = &inner.fd_table[fd] {
        let file = file.clone();
        if !file.readable() {
            return -1;
        }
        // release current task TCB manually to avoid multi-borrow
        drop(inner);
        file.read(UserBuffer::new(translated_byte_buffer(token, buf, len))) as isize    // 实际调用的就是前面实现的 trait 的方法
    } else {
        -1
    }
}

Pipe

管道的使用方法有两种,一种是使用系统调用 pipe() 获取两个文件描述符(一个只读文件和一个只写文件)来进行通信(因为两端都被关闭才会释放资源,所以用不到的端口应及时关闭),另一种是在命令行通过 | 来实现程序之间的通信。

sys_pipe

/// 功能:为当前进程打开一个管道。
/// 参数:pipe 表示应用地址空间中的一个长度为 2 的 usize 数组的起始地址,内核需要按顺序将管道读端
/// 和写端的文件描述符写入到数组中。
/// 返回值:如果出现了错误则返回 -1,否则返回 0 。可能的错误原因是:传入的地址不合法。
/// syscall ID:59
pub fn sys_pipe(pipe: *mut usize) -> isize;

系统调用包装得到用户库函数

// user/src/syscall.rs
const SYSCALL_PIPE: usize = 59;

pub fn sys_pipe(pipe: &mut [usize]) -> isize {
    syscall(SYSCALL_PIPE, [pipe.as_mut_ptr() as usize, 0, 0])
}

// user/src/lib.rs
pub fn pipe(pipe_fd: &mut [usize]) -> isize { sys_pipe(pipe_fd) }

Tutorial-Book 给出了使用管道的 Rust 程序示例

// user/src/bin/pipetest.rs

#![no_std]
#![no_main]

#[macro_use]
extern crate user_lib;

use user_lib::{fork, close, pipe, read, write, wait};

static STR: &str = "Hello, world!";

#[unsafe(no_mangle)]
pub fn main() -> i32 {
    // create pipe
    let mut pipe_fd = [0usize; 2];  // 创建长度为 2 的 usize 数组 [0, 0]
    pipe(&mut pipe_fd);
    // read end
    assert_eq!(pipe_fd[0], 3);  // 由于已经有标准 io 了,所以新的 fd 会从 3 开始
    // write end
    assert_eq!(pipe_fd[1], 4);  // 下标 0 是读端,1 是写端
    if fork() == 0 {    // fork 之后会继承父进程的文件描述符
        // child process, read from parent
        // close write_end
        close(pipe_fd[1]);
        let mut buffer = [0u8; 32]; // 设置 32 字节缓冲区
        let len_read = read(pipe_fd[0], &mut buffer) as usize;
        // close read_end
        close(pipe_fd[0]);
        assert_eq!(core::str::from_utf8(&buffer[..len_read]).unwrap(), STR);
        println!("Read OK, child process exited!");
        0
    } else {
        // parent process, write to child
        // close read end
        close(pipe_fd[0]);
        assert_eq!(write(pipe_fd[1], STR.as_bytes()), STR.len() as isize);
        // close write end
        close(pipe_fd[1]);
        let mut child_exit_code: i32 = 0;
        wait(&mut child_exit_code); // 等待子进程退出
        assert_eq!(child_exit_code, 0);
        println!("pipetest passed!");
        0
    }
}

可以看到这种方式能够让父进程和子进程通信

实现 File trait 的 Pipe

先定义管道类型

// os/src/fs/pipe.rs

pub struct Pipe {
    readable: bool,
    writable: bool,
    buffer: Arc<Mutex<PipeRingBuffer>>, // 仓库使用的是 Arc<UPSafeCell<PipeRingBuffer>> 适用于单核情况
}

可以看到,管道类型需要保存自己是写端/读端的信息,还需要维护一个环形缓冲区 PipeRingBuffer

// os/src/fs/pipe.rs

const RING_BUFFER_SIZE: usize = 32;

#[derive(Copy, Clone, PartialEq)]   // 允许显式/隐式复制和比较是否相等
enum RingBufferStatus {
    FULL,
    EMPTY,
    NORMAL,
}

pub struct PipeRingBuffer {
    arr: [u8; RING_BUFFER_SIZE],
    head: usize,
    tail: usize,
    status: RingBufferStatus,
    write_end: Option<Weak<Pipe>>,
}

环形缓冲区需要维护自己的字节数组、头指针、尾指针、记录自己的状态,还需记录写端是否被关闭

在查看 Pipe 实现的方法之前,先查看环形缓冲区实现的方法

impl PipeRingBuffer {
    pub fn new() -> Self {
        Self {
            arr: [0; RING_BUFFER_SIZE],
            head: 0,
            tail: 0,
            status: RingBufferStatus::Empty,
            write_end: None,
        }
    }
    // 设置写端
    pub fn set_write_end(&mut self, write_end: &Arc<Pipe>) {
        self.write_end = Some(Arc::downgrade(write_end));   // 降级为弱指针
    }
    // 写入一个字节,tail 需要往后移动
    pub fn write_byte(&mut self, byte: u8) {
        self.status = RingBufferStatus::Normal;
        self.arr[self.tail] = byte;
        self.tail = (self.tail + 1) % RING_BUFFER_SIZE;
        if self.tail == self.head {
            self.status = RingBufferStatus::Full;
        }
    }
    // 读一个字节,head 往后移动
    pub fn read_byte(&mut self) -> u8 {
        self.status = RingBufferStatus::Normal;
        let c = self.arr[self.head];
        self.head = (self.head + 1) % RING_BUFFER_SIZE;
        if self.head == self.tail {
            self.status = RingBufferStatus::Empty;
        }
        c
    }
    // 返回能读的字节数量
    pub fn available_read(&self) -> usize {
        if self.status == RingBufferStatus::Empty {
            0
        } else if self.tail > self.head {
            self.tail - self.head
        } else {
            self.tail + RING_BUFFER_SIZE - self.head
        }
    }
    // 返回能写的字节数量
    pub fn available_write(&self) -> usize {
        if self.status == RingBufferStatus::Full {
            0
        } else {
            RING_BUFFER_SIZE - self.available_read()
        }
    }
    // 检查写端是否关闭,弱引用升级
    pub fn all_write_ends_closed(&self) -> bool {
        self.write_end.as_ref().unwrap().upgrade().is_none()
    }
}

然后看 Pipe 实现的方法,注意到 buffer 只是引用,没有引用的时候,PipeRingBuffer 会自动释放

impl Pipe {
    pub fn read_end_with_buffer(buffer: Arc<UPSafeCell<PipeRingBuffer>>) -> Self {
        Self {
            readable: true,
            writable: false,
            buffer,
        }
    }
    pub fn write_end_with_buffer(buffer: Arc<UPSafeCell<PipeRingBuffer>>) -> Self {
        Self {
            readable: false,
            writable: true,
            buffer,
        }
    }
}
impl File for Pipe {
    fn readable(&self) -> bool {
        self.readable
    }
    fn writable(&self) -> bool {
        self.writable
    }
    fn read(&self, buf: UserBuffer) -> usize {
        assert!(self.readable());
        let want_to_read = buf.len();
        let mut buf_iter = buf.into_iter();
        let mut already_read = 0usize;
        loop {
            let mut ring_buffer = self.buffer.exclusive_access();
            let loop_read = ring_buffer.available_read();
            if loop_read == 0 {
                // 没有要读的了!
                if ring_buffer.all_write_ends_closed() {
                    // 写端全部关闭了,直接返回
                    return already_read;
                }
                // 写端没有关闭,考虑放弃 CPU 资源
                drop(ring_buffer);  // 丢掉引用/锁
                suspend_current_and_run_next();
                continue;
            }
            // 从 buffer 中一个个字节复制
            for _ in 0..loop_read {
                if let Some(byte_ref) = buf_iter.next() {
                    unsafe {
                        *byte_ref = ring_buffer.read_byte();
                    }
                    already_read += 1;
                    if already_read == want_to_read {
                        return want_to_read;
                    }
                } else {
                    return already_read;    // buf_iter 读到边界了
                }
            }
        }
    }
    fn write(&self, buf: UserBuffer) -> usize {
        assert!(self.writable());
        let want_to_write = buf.len();
        let mut buf_iter = buf.into_iter();
        let mut already_write = 0usize;
        loop {
            let mut ring_buffer = self.buffer.exclusive_access();
            let loop_write = ring_buffer.available_write();
            if loop_write == 0 {
                drop(ring_buffer);
                suspend_current_and_run_next();
                continue;
            }
            // write at most loop_write bytes
            for _ in 0..loop_write {
                if let Some(byte_ref) = buf_iter.next() {
                    ring_buffer.write_byte(unsafe { *byte_ref });
                    already_write += 1;
                    if already_write == want_to_write {
                        return want_to_write;
                    }
                } else {
                    return already_write;
                }
            }
        }
    }
}

创建 Pipe

// os/src/fs/pipe.rs

/// Return (read_end, write_end)
pub fn make_pipe() -> (Arc<Pipe>, Arc<Pipe>) {
    let buffer = Arc::new(unsafe { UPSafeCell::new(PipeRingBuffer::new()) });
    let read_end = Arc::new(Pipe::read_end_with_buffer(buffer.clone()));
    let write_end = Arc::new(Pipe::write_end_with_buffer(buffer.clone()));
    buffer.exclusive_access().set_write_end(&write_end);
    (read_end, write_end)
}

前面注意到 buffer 是引用,而它的创建就在这里。

现在再看系统调用接口,sys_pipe 通过 make_pipe 获取两个 Arc<Pipe>,然后放入到 fd_table 中

pub fn sys_pipe(pipe: *mut usize) -> isize {
    let task = current_task().unwrap();
    let token = current_user_token();
    let mut inner = task.inner_exclusive_access();
    let (pipe_read, pipe_write) = make_pipe();
    let read_fd = inner.alloc_fd();
    inner.fd_table[read_fd] = Some(pipe_read);
    let write_fd = inner.alloc_fd();
    inner.fd_table[write_fd] = Some(pipe_write);
    // 将 fd 复制到数组中
    *translated_refmut(token, pipe) = read_fd;
    *translated_refmut(token, unsafe { pipe.add(1) }) = write_fd;
    0
}

关闭的时候,如果写端和读端都被关闭,那么缓冲区也会因为引用计数为 0 而释放

命令行参数与标准 I/O 重定向

命令行参数

exec 系统调用修改支持传递参数

在使用 shell 执行程序的时候,可以在程序名的后面添加内容,这些参数会被传给程序,通过 main(int argc, char *argv[])

// a.c
#include <stdio.h>

int main(int argc, char* argv[]) {
    printf("argc = %d\n", argc);
    for (int i = 0; i < argc; i++) {
        printf("argv[%d] = %s\n", i, argv[i]);
    }
    return 0;
}

在 RISC-V 的标准整数调用约定中,第一个参数 argc 会存在 a0 ,然后第二个参数 argv 会存在 a1,因此要让 exec 的程序的 main 能读到这两个参数,需要修改 sys_exec 并设置上下文

// user/src/syscall.rs
pub fn sys_exec(path: &str, args: &[*const u8]) -> isize {
    syscall(SYSCALL_EXEC, [path.as_ptr() as usize, args.as_ptr() as usize, 0])
}

// user/src/lib.rs
pub fn exec(path: &str, args: &[*const u8]) -> isize { sys_exec(path, args) }
// os/src/syscall/process.rs
pub fn sys_exec(path: *const u8, mut args: *const usize) -> isize {
    let token = current_user_token();
    let path = translated_str(token, path);
    let mut args_vec: Vec<String> = Vec::new();
    loop {
        // 根据 args (VA)获得物理地址
        let arg_str_ptr = *translated_ref(token, args);
        // 得到的地址为 0 说明没有更多字符串了
        if arg_str_ptr == 0 {
            break;
        }
        // 读取字符串加载到 args_vec 中
        args_vec.push(translated_str(token, arg_str_ptr as *const u8));
        // args 往后移动一个 usize
        unsafe {
            args = args.add(1); // add 是 unsafe 方法
        }
    }
    if let Some(app_inode) = open_file(path.as_str(), OpenFlags::RDONLY) {
        let all_data = app_inode.read_all();
        let task = current_task().unwrap();
        let argc = args_vec.len();
        // 将 ELF 数据和参数传入
        task.exec(all_data.as_slice(), args_vec);
        // argc 会作为 a0 返回
        argc as isize
    } else {
        -1
    }
}
impl TaskControlBlock {
    ...
    pub fn exec(&self, elf_data: &[u8], args: Vec<String>) {
        // 根据 ELF 数据建立地址空间
        let (memory_set, mut user_sp, entry_point) = MemorySet::from_elf(elf_data);
        let trap_cx_ppn = memory_set
            .translate(VirtAddr::from(TRAP_CONTEXT).into())
            .unwrap()
            .ppn();
        // 将参数塞入用户栈(一些指针)
        user_sp -= (args.len() + 1) * core::mem::size_of::<usize>();
        let argv_base = user_sp;
        let mut argv: Vec<_> = (0..=args.len()) // 得到实际映射的物理地址
            .map(|arg| {
                translated_refmut(
                    memory_set.token(),
                    (argv_base + arg * core::mem::size_of::<usize>()) as *mut usize,
                )
            })
            .collect();
        *argv[args.len()] = 0;  // 第 k+1 个指针为 0 表示没有更多字符串
        for i in 0..args.len() {
            // 将字符串塞入栈
            user_sp -= args[i].len() + 1;
            *argv[i] = user_sp;
            let mut p = user_sp;
            for c in args[i].as_bytes() {
                *translated_refmut(memory_set.token(), p as *mut u8) = *c;
                p += 1;
            }
            *translated_refmut(memory_set.token(), p as *mut u8) = 0;
        }
        // 对齐
        user_sp -= user_sp % core::mem::size_of::<usize>();

        let mut inner = self.inner_exclusive_access();
        inner.memory_set = memory_set;
        inner.trap_cx_ppn = trap_cx_ppn;
        let mut trap_cx = TrapContext::app_init_context(
            entry_point,
            user_sp,
            KERNEL_SPACE.exclusive_access().token(),
            self.kernel_stack.get_top(),
            linker_symbol_addr!(trap_handler),
        );
        // 设置 a0, a1
        trap_cx.x[10] = args.len();
        trap_cx.x[11] = argv_base;
        *inner.get_trap_cx() = trap_cx;
    }
    ...
}

内存布局大致是这样的

user stack

user_shell 修改

在此基础上,shell 只需要调用 exec 的时候将命令行参数传入即可,下面是书中给出的代码

// user/src/bin/user_shell.rs

let args: Vec<_> = line.as_str().split(' ').collect();  // 空格区分读取的 line 并收集起来
let mut args_copy: Vec<String> = args
.iter()
.map(|&arg| {
    let mut string = String::new();
    string.push_str(arg);
    string
})
.collect(); // 复制一份参数

args_copy
.iter_mut()
.for_each(|string| {
    string.push('\0');  // 每一个字符串的后面加入 \0 表示结束
});
// user/src/bin/user_shell.rs

let mut args_addr: Vec<*const u8> = args_copy   // 收集这几个字符串的地址
.iter()
.map(|arg| arg.as_ptr())
.collect();
args_addr.push(0 as *const u8); // 插入一个空指针
// user/src/bin/user_shell.rs

// child process
if exec(args_copy[0].as_str(), args_addr.as_slice()) == -1 {    // 将地址传入系统调用
    println!("Error when executing!");
    return -4;
}

用户库从用户栈上还原命令行参数

由于传入的 argv 是 usize,不便于使用,因此在进入 main 之前先还原参数,再调用 pub fn main(argc: usize, argv: &[&str])

// user/src/lib.rs
const USER_HEAP_SIZE: usize = 32768;

static mut HEAP_SPACE: [u8; USER_HEAP_SIZE] = [0; USER_HEAP_SIZE];

#[global_allocator]
static HEAP: LockedHeap = LockedHeap::empty();

#[unsafe(no_mangle)]
#[unsafe(link_section = ".text.entry")]     // 程序入口不再是 main
pub extern "C" fn _start(argc: usize, argv: usize) -> ! {
    // 初始化堆内存
    unsafe {
        HEAP.lock()
            .init(addr_of_mut!(HEAP_SPACE) as usize, USER_HEAP_SIZE);
    }
    // 新建字符串数组
    let mut v: Vec<&'static str> = Vec::new();
    for i in 0..argc {
        let str_start = unsafe {
            ((argv + i * core::mem::size_of::<usize>()) as *const usize).read_volatile()
        };
        let len = (0usize..).find(|i| unsafe {
            ((str_start + *i) as *const u8).read_volatile() == 0
        }).unwrap();
        // 读取字符串
        v.push(
            core::str::from_utf8(unsafe {
                core::slice::from_raw_parts(str_start as *const u8, len)
            }).unwrap()
        );
    }
    // 调用 main
    unsafe {
        exit(main(argc, v.as_slice()));
    }

cat 输出文件内容

cat.rs 代码如下,打开文件之后不断地读取并打印即可

#![no_std]
#![no_main]

#[macro_use]
extern crate user_lib;
extern crate alloc;

use user_lib::{OpenFlags, close, open, read};

#[unsafe(no_mangle)]
pub fn main(argc: usize, argv: &[&str]) -> i32 {
    assert!(argc == 2);
    let fd = open(argv[1], OpenFlags::RDONLY);
    if fd == -1 {
        panic!("Error occured when opening file");
    }
    let fd = fd as usize;
    let mut buf = [0u8; 256];
    loop {
        let size = read(fd, &mut buf) as usize;
        if size == 0 {
            break;
        }
        print!("{}", core::str::from_utf8(&buf[..size]).unwrap());
    }
    close(fd);
    0
}

标准输入输出重定向

POSIX Shell 的重定向语法如下

语法作用
cmd > file标准输出写入文件,覆盖原内容
cmd >> file标准输出追加到文件末尾
cmd < file从文件读取标准输入
cmd 2> file将标准错误输出写入文件
cmd 2>&1让 FD 2 指向 FD 1 当前指向的对象
cmd 1>&2让 FD 1 指向 FD 2 当前指向的对象
cmd > file 2>&1标准输出和标准错误都写入文件
cmd << EOFHere-document,向标准输入提供多行文本
cmd <> file以读写方式打开文件并作为标准输入

一般的重定向过程如下,假设需要将某个文件作为标准输入,那么首先需要打开文件,然后关闭标准输入,再使用 dup 系统调用让标准输入的 fd 指向刚刚的文件,最后再关闭旧的 fd。

为什么不直接关闭输入,然后再打开文件?因为这样可能会丢失标准输出,导致文件打开失败的信息无法及时输出。

关于 dup 系统调用,其实有三种,第三种是 Linux 特有的扩展

接口功能新 FD 如何确定
dup(oldfd)复制文件描述符自动分配最小可用 FD
dup2(oldfd, newfd)复制到指定 FD使用指定的 newfd
dup3(oldfd, newfd, flags)复制到指定 FD,并设置标志使用指定的 newfd

sys_dup

rCore 只实现了第一个

// user/src/lib.rs
pub fn dup(fd: usize) -> isize {
    sys_dup(fd)
}
// user/src/syscall.rs
pub fn sys_dup(fd: usize) -> isize {
    syscall(SYSCALL_DUP, [fd, 0, 0])
}

rCore 的做法就是新分配一个 fd 然后复制原本的计数引用,返回新的 fd

// os/src/syscall/fs.rs
pub fn sys_dup(fd: usize) -> isize {
    let task = current_task().unwrap();
    let mut inner = task.inner_exclusive_access();
    if fd >= inner.fd_table.len() {
        return -1;
    }
    if inner.fd_table[fd].is_none() {
        return -1;
    }
    let new_fd = inner.alloc_fd();
    inner.fd_table[new_fd] = Some(Arc::clone(inner.fd_table[fd].as_ref().unwrap()));
    new_fd as isize
}

user_shell 如何重定向

shell 需要检查输入是否有 <, >,然后进行分割,假设输入最多只有一个 < 或者只有一个 >,即只会出现以下两种情况

>> program arg1 arg2 < file1
>> program arg1 arg2 > file2
// user/src/bin/user_shell.rs

// redirect input
let mut input = String::new();
if let Some((idx, _)) = args_copy           // args_copy 是分割后的字符串数组
.iter()
.enumerate()
.find(|(_, arg)| arg.as_str() == "<\0") {   // 去掉 < 前面的,留下后面的作为输入
    input = args_copy[idx + 1].clone();
    args_copy.drain(idx..=idx + 1);
}

// redirect output
let mut output = String::new();
if let Some((idx, _)) = args_copy
.iter()
.enumerate()
.find(|(_, arg)| arg.as_str() == ">\0") {   // 去掉 > 前面的,留下后面的作为输出
    output = args_copy[idx + 1].clone();
    args_copy.drain(idx..=idx + 1);
}

在 fork 之后,再进行重定向

// user/src/bin/user_shell.rs

let pid = fork();
if pid == 0 {
    // input redirection
    if !input.is_empty() {
        let input_fd = open(input.as_str(), OpenFlags::RDONLY);
        if input_fd == -1 {
            println!("Error when opening file {}", input);
            return -4;
        }
        let input_fd = input_fd as usize;   // 有符号转无符号
        close(0);
        assert_eq!(dup(input_fd), 0);
        close(input_fd);
    }
    // output redirection
    if !output.is_empty() {
        let output_fd = open(
            output.as_str(),
            OpenFlags::CREATE | OpenFlags::WRONLY
        );
        if output_fd == -1 {
            println!("Error when opening file {}", output);
            return -4;
        }
        let output_fd = output_fd as usize;
        close(1);
        assert_eq!(dup(output_fd), 1);
        close(output_fd);
    }
    // child process
    if exec(args_copy[0].as_str(), args_addr.as_slice()) == -1 {
        println!("Error when executing!");
        return -4;
    }
    unreachable!();
} else {
    let mut exit_code: i32 = 0;
    let exit_pid = waitpid(pid as usize, &mut exit_code);
    assert_eq!(pid, exit_pid);
    println!("Shell: Process {} exited with code {}", pid, exit_code);
}

信号

信号机制简介

信号机制能够让进程在接收到特定事件的时候,立马进入提前设置好的事件处理例程,完成之后恢复工作,继续执行。在这个过程中,程序只需要负责提前设置事件处理例程即可。

比如在终端运行程序时,用户按下 Ctrl+C 希望停止进程,程序就会停止当前做的事情,退出

Unix 提供了 kill() 系统调用,向指定进程或进程组发送信号。进程是否终止,取决于信号类型及其处理方式

#include <signal.h>

kill(pid, SIGTERM);

操作系统通常需要维护 Pending 信号队列以及阻塞信号集合。信号通常在 Trap 返回时进行处理,执行提前设置好的处理函数,进程可以执行默认动作(SIG_DFL)、忽略信号(SIG_IGN)或者执行用户定义的信号处理函数(Signal Handler)。

#include <stdio.h>
#include <signal.h>
#include <unistd.h>

void handler(int sig) {
    const char msg[] = "Signal received\n";
    write(STDOUT_FILENO, msg, sizeof(msg) - 1);
}

int main() {
    signal(SIGINT, handler);

    while (1) {
        pause();
    }
}

一些信号如下

信号含义
SIGABRT非正常的进程退出,可能由调用 abort 函数产生
SIGCHLD进程状态变更时(通常是进程退出时),由内核发送给它的父进程
SIGINT在终端界面按下 CTRL+C 组合键时,由内核会发送给当前终端的前台进程
SIGKILL终止某个进程,由内核或其他进程发送给被终止进程
SIGSEGV非法内存访问异常,由内核发送给触发异常的进程
SIGILL非法指令异常,由内核发送给触发异常的进程
SIGTSTP在终端界面按下 CTRL+Z 组合键时,会发送给当前进程让它暂停
SIGSTOP也用于暂停进程,与 SIGTSTP 的区别在于 SIGSTOP 不能被忽略或捕获,即 SIGTSTP 更加灵活
SIGCONT恢复暂停的进程继续执行
SIGUSR1/2用户自定义信号 1/2

rCore-Tutorial-Book 给出了信号处理流程示意图

Signal

从示意图可以看到信号有两种来源

  1. 异步信号:进程正常执行过程中内核或者其他进程给它发送了一个信号
  2. 同步信号:进程执行期间触发,内核会将信号附加到 PCB 中

处理同样也有两种途径

  1. 进程未提供处理函数:内核按默认方式处理
  2. 进程提供了处理函数:保存 Trap 上下文,回到用户态执行处理函数,函数末尾需要调用 sigreturn 系统调用,这样才能恢复原本的 Trap 上下文

系统调用原型

rCore 中信号相关的系统调用如下

  • sys_kill(pid: usize, signal: i32): 向某个进程发送信号
  • sys_sigaction(signum: i32, action: *const SignalAction, old_action: *mut SignalAction): 设置信号处理例程
  • sys_sigprocmask(mask: u32): 设置进程的信号屏蔽掩码
  • sys_sigreturn(): 清除栈帧,从信号处理例程返回

信号编号的定义如下

// user/src/lib.rs

pub const SIGDEF: i32 = 0; // Default signal handling
pub const SIGHUP: i32 = 1;
pub const SIGINT: i32 = 2;
pub const SIGQUIT: i32 = 3;
pub const SIGILL: i32 = 4;
pub const SIGTRAP: i32 = 5;
pub const SIGABRT: i32 = 6;
pub const SIGBUS: i32 = 7;
pub const SIGFPE: i32 = 8;
pub const SIGKILL: i32 = 9;
...

SignalAction 的定义如下,包括 handler 地址以及掩码(执行期间可以屏蔽掉某些信号)

/// Action for a signal
#[repr(C, align(16))]   // 16字节对齐,避免跨页面
#[derive(Debug, Clone, Copy)]
pub struct SignalAction {
    pub handler: usize,
    pub mask: SignalFlags,
}

impl Default for SignalAction {
    fn default() -> Self {
        Self {
            handler: 0,
            mask: SignalFlags::empty(),
        }
    }
}

SignalFlags 定义如下

// user/src/lib.rs

bitflags! {
    pub struct SignalFlags: i32 {
        const SIGDEF = 1; // Default signal handling
        const SIGHUP = 1 << 1;
        const SIGINT = 1 << 2;
        const SIGQUIT = 1 << 3;
        const SIGILL = 1 << 4;
        const SIGTRAP = 1 << 5;
        ...
        const SIGSYS = 1 << 31;
    }
}

然后是几个系统调用在用户态的接口,注意 sigaction 和 sys_sigaction 参数不太一样,经过了一层包装

pub fn sigaction(
    signum: i32,
    action: Option<&SignalAction>,
    old_action: Option<&mut SignalAction>,
) -> isize {
    sys_sigaction(
        signum,
        action.map_or(core::ptr::null(), |a| a),    // 是 None 就传入空指针
        old_action.map_or(core::ptr::null_mut(), |a| a),
    )
}

pub fn sigprocmask(mask: u32) -> isize {
    sys_sigprocmask(mask)
}

pub fn sigreturn() -> isize {
    sys_sigreturn()
}

使用示例

// user/src/bin/sig_simple.rs

#![no_std]
#![no_main]

extern crate user_lib;

// use user_lib::{sigaction, sigprocmask, SignalAction, SignalFlags, fork, exit, wait, kill, getpid, sleep, sigreturn};
use user_lib::*;

fn func() {
    println!("user_sig_test passed");
    sigreturn();
}

#[unsafe(no_mangle)]
pub fn main() -> i32 {
    let mut new = SignalAction::default();
    let mut old = SignalAction::default();
    new.handler = linker_symbol_addr!(func);

    println!("signal_simple: sigaction");
    if sigaction(SIGUSR1, Some(&new), Some(&mut old)) < 0 { // 设置处理函数
        panic!("Sigaction failed!");
    }
    println!("signal_simple: kill");
    if kill(getpid() as usize, SIGUSR1) < 0 {   // 向自己发送信号
        println!("Kill failed!");
        exit(1);
    }
    println!("signal_simple: Done");
    0
}

信号机制实现

设置信号处理例程和信号掩码

// os/src/task/action.rs

/// Action for a signal
#[repr(C, align(16))]
#[derive(Debug, Clone, Copy)]
pub struct SignalAction {
    pub handler: usize,
    pub mask: SignalFlags,
}

impl Default for SignalAction {
    fn default() -> Self {
        Self {
            handler: 0,
            mask: SignalFlags::from_bits(40).unwrap(),
        }
    }
}

#[derive(Clone)]
pub struct SignalActions {
    pub table: [SignalAction; MAX_SIG + 1],
}

impl Default for SignalActions {
    fn default() -> Self {
        Self {
            table: [SignalAction::default(); MAX_SIG + 1],
        }
    }
}

在 TCB 中添加状态

// os/src/task/task.rs

pub struct TaskControlBlockInner {
    ...
    pub signal_mask: SignalFlags,
    pub signal_actions: SignalActions,
    ...
}

然后实现两个系统调用

// os/src/syscall/process.rs
pub fn sys_sigprocmask(mask: u32) -> isize {
    if let Some(task) = current_task() {
        let mut inner = task.inner_exclusive_access();
        let old_mask = inner.signal_mask;
        if let Some(flag) = SignalFlags::from_bits(mask) {
            inner.signal_mask = flag;
            old_mask.bits() as isize
        } else {
            -1
        }
    } else {
        -1
    }
}
pub fn sys_sigaction(
    signum: i32,
    action: *const SignalAction,
    old_action: *mut SignalAction,
) -> isize {
    let token = current_user_token();
    let task = current_task().unwrap();
    let mut inner = task.inner_exclusive_access();
    if signum as usize > MAX_SIG {
        return -1;
    }
    if let Some(flag) = SignalFlags::from_bits(1 << signum) {
        if check_sigaction_error(flag, action as usize, old_action as usize) {  // 先检查处理例程是否存在错误
            return -1;
        }
        let prev_action = inner.signal_actions.table[signum as usize];
        *translated_refmut(token, old_action) = prev_action;                            // 将旧的 action 复制过去
        inner.signal_actions.table[signum as usize] = *translated_ref(token, action);   // 新的 action 复制到表格中
        0
    } else {
        -1
    }
}

对于检查错误,前面用户态系统调用的时候允许了传入空指针的情况,因此在这里需要进行检查,除此之外,SIGKILL 和 SIGSTOP 只能由内核处理,不允许自定义信号处理例程

fn check_sigaction_error(signal: SignalFlags, action: usize, old_action: usize) -> bool {
    if action == 0
        || old_action == 0
        || signal == SignalFlags::SIGKILL
        || signal == SignalFlags::SIGSTOP
    {
        true    // 错误
    } else {
        false
    }
}

产生信号

进程中的待信号需要保存在状态中,SignalFlags 采用位图的方式,可以同时保存多个信号

// os/src/task/task.rs

pub struct TaskControlBlockInner {
    ...
    pub signals: SignalFlags,
    ...
}

先处理 kill 系统调用发送信号的情况,需要根据 pid 找到对应的进程,然后修改状态

// os/src/syscall/process.rs

pub fn sys_kill(pid: usize, signum: i32) -> isize {
    if let Some(task) = pid2task(pid) {
        if let Some(flag) = SignalFlags::from_bits(1 << signum) {
            // insert the signal if legal
            let mut task_ref = task.inner_exclusive_access();
            if task_ref.signals.contains(flag) {    // 进行检查,如果信号已经存在,返回 -1
                return -1;
            }
            task_ref.signals.insert(flag);
            0
        } else {
            -1
        }
    } else {
        -1
    }
}

至于 pid2task 的实现,rCore 维护了一个 BTree 实现的图,和 TASK_MANAGER 一起,在插入任务的时候顺便插入到图中

// os/src/task/manager.rs
lazy_static! {
    pub static ref TASK_MANAGER: UPSafeCell<TaskManager> =
        unsafe { UPSafeCell::new(TaskManager::new()) };
    pub static ref PID2TCB: UPSafeCell<BTreeMap<usize, Arc<TaskControlBlock>>> =
        unsafe { UPSafeCell::new(BTreeMap::new()) };
}

pub fn add_task(task: Arc<TaskControlBlock>) {
    PID2TCB
        .exclusive_access()
        .insert(task.getpid(), Arc::clone(&task));
    TASK_MANAGER.exclusive_access().add(task);
}

pub fn fetch_task() -> Option<Arc<TaskControlBlock>> {
    TASK_MANAGER.exclusive_access().fetch()
}

pub fn pid2task(pid: usize) -> Option<Arc<TaskControlBlock>> {
    let map = PID2TCB.exclusive_access();
    map.get(&pid).map(Arc::clone)
}

pub fn remove_from_pid2task(pid: usize) {
    let mut map = PID2TCB.exclusive_access();
    if map.remove(&pid).is_none() {
        panic!("cannot find pid {} in pid2task!", pid);
    }
}

解决完系统调用产生信号的情况,现在还需要补充内核产生信号的情况

// os/src/task/mod.rs

pub fn current_add_signal(signal: SignalFlags) {
    let task = current_task().unwrap();
    let mut task_inner = task.inner_exclusive_access();
    task_inner.signals |= signal;   // 直接使用按位或运算
}

然后在 trap 中添加信号,如果程序产生错误

// os/src/trap/mod.rs

#[unsafe(no_mangle)]
pub fn trap_handler() -> ! {
    ...
    let scause = scause::read();
    let stval = stval::read();
    let trap: Trap<Interrupt, Exception> = match scause.cause().try_into() {
        Ok(trap) => trap,
        Err(_) => panic!(
            "Unsupported trap {:?}, stval = {:#x}!",
            scause.cause(),
            stval
        ),
    };
    match trap {
        ...
        Trap::Exception(Exception::StoreFault)
        | Trap::Exception(Exception::StorePageFault)
        | Trap::Exception(Exception::InstructionFault)
        | Trap::Exception(Exception::InstructionPageFault)
        | Trap::Exception(Exception::LoadFault)
        | Trap::Exception(Exception::LoadPageFault) => {
            /*
            println!(
                "[kernel] {:?} in application, bad addr = {:#x}, bad instruction = {:#x}, kernel killed it.",
                scause.cause(),
                stval,
                current_trap_cx().sepc,
            );
            */
            current_add_signal(SignalFlags::SIGSEGV);   // 非法内存访问异常
        }
        Trap::Exception(Exception::IllegalInstruction) => {
            current_add_signal(SignalFlags::SIGILL);    // 非法指令异常
        ...
    }
    ...
}

注意到 xv6 中,同样的情况只会打印错误信息并且杀死进程,xv6 没有实现信号机制,而这里一般会在信号处理阶段再杀死进程

处理信号

在返回用户态前,内核会调用函数 handle_signals()

// os/src/task/mod.rs
pub fn trap_handler() -> ! {
    ...
    // handle signals (handle the sent signal)
    //println!("[K] trap_handler:: handle_signals");
    handle_signals();

    // check error signals (if error then exit)
    if let Some((errno, msg)) = check_signals_error_of_current() {
        println!("[kernel] {}", msg);
        exit_current_and_run_next(errno);
    }
    trap_return();
}

这个函数会检查是否有需要处理的信号(Pending Signals)并执行

// os/src/task/mod.rs
pub fn handle_signals() {
    loop {
        check_pending_signals();
        let (frozen, killed) = {    // frozen 指的是进程被暂停:当进程收到 SIGSTOP 信号之后,它的执行将被暂停,等到该进程收到 SIGCONT 信号之后再继续执行。
            let task = current_task().unwrap();
            let task_inner = task.inner_exclusive_access();
            (task_inner.frozen, task_inner.killed)
        };
        if !frozen || killed {  // 如果没有被暂停或者已经被杀死,退出循环然后从 trap 中返回
            break;
        }
        suspend_current_and_run_next();
    }
}

在 check_pending_signals() 中会调用 handler

// os/src/task/mod.rs
fn check_pending_signals() {
    for sig in 0..(MAX_SIG + 1) {   // 挨个检查信号位
        let task = current_task().unwrap();
        let task_inner = task.inner_exclusive_access();
        let signal = SignalFlags::from_bits(1 << sig).unwrap();
        if task_inner.signals.contains(signal) && (!task_inner.signal_mask.contains(signal)) {  // 信号存在并且这个信号不在屏蔽列表中
            let mut masked = true;
            let handling_sig = task_inner.handling_sig; // 是否有正在处理的信号
            if handling_sig == -1 {
                masked = false;
            } else {
                let handling_sig = handling_sig as usize;   // 如果有,并且这个信号例程没有屏蔽当前信号
                if !task_inner.signal_actions.table[handling_sig]
                    .mask
                    .contains(signal)
                {
                    masked = false;
                }
            }
            if !masked {    // 可以处理
                drop(task_inner);
                drop(task);
                if signal == SignalFlags::SIGKILL
                    || signal == SignalFlags::SIGSTOP
                    || signal == SignalFlags::SIGCONT
                    || signal == SignalFlags::SIGDEF
                {
                    // signal is a kernel signal
                    call_kernel_signal_handler(signal);
                } else {
                    // signal is a user signal
                    call_user_signal_handler(sig, signal);
                    return;
                }
            }
        }
    }
}

内核处理情况如下,遇到 SIGSTOP 会暂停进程,SIGCONT 则会解除暂停,SIGKILL或者 SIGDEF (Default) 则会杀死进程

// os/src/task/mod.rs
fn call_kernel_signal_handler(signal: SignalFlags) {
    let task = current_task().unwrap();
    let mut task_inner = task.inner_exclusive_access();
    match signal {
        SignalFlags::SIGSTOP => {
            task_inner.frozen = true;
            task_inner.signals ^= SignalFlags::SIGSTOP;
        }
        SignalFlags::SIGCONT => {
            if task_inner.signals.contains(SignalFlags::SIGCONT) {
                task_inner.signals ^= SignalFlags::SIGCONT;
                task_inner.frozen = false;
            }
        }
        _ => {
            // println!(
            //     "[K] call_kernel_signal_handler:: current task sigflag {:?}",
            //     task_inner.signals
            // );
            task_inner.killed = true;   // 后续会检查 killed 情况来执行对应步骤
        }
    }
}

而对于进程提供的用户例程,情况稍微复杂一些,需要先获取 handler,然后备份上下文,准备新的上下文进行返回

// os/src/task/mod.rs
fn call_user_signal_handler(sig: usize, signal: SignalFlags) {
    let task = current_task().unwrap();
    let mut task_inner = task.inner_exclusive_access();

    let handler = task_inner.signal_actions.table[sig].handler;
    if handler != 0 {
        // user handler

        // handle flag
        task_inner.handling_sig = sig as isize;     // 设置处理的标志
        task_inner.signals ^= signal;               // 反转这个标志

        // backup trapframe
        let trap_ctx = task_inner.get_trap_cx();
        task_inner.trap_ctx_backup = Some(*trap_ctx);   // 备份 trap 上下文

        // modify trapframe
        trap_ctx.sepc = handler;    // 返回时就会进入 handler

        // put args (a0)
        trap_ctx.x[10] = sig;   // a0 为信号
    } else {
        // default action
        println!("[K] task/call_user_signal_handler: default action: ignore it or kill process");
    }
}

在 trap 返回前,会先检查执行结果,发生了错误就会退出这个进程

// os/src/task/mod.rs
pub fn trap_handler() -> ! {
    ...
    handle_signals();

    if let Some((errno, msg)) = check_signals_error_of_current() {
        println!("[kernel] {}", msg);
        exit_current_and_run_next(errno);
    }
    trap_return();
}
// os/src/task/mod.rs
pub fn check_signals_error_of_current() -> Option<(i32, &'static str)> {
    let task = current_task().unwrap();
    let task_inner = task.inner_exclusive_access();
    task_inner.signals.check_error()
}

// os/src/task/signal.rs
impl SignalFlags {
    pub fn check_error(&self) -> Option<(i32, &'static str)> {
        if self.contains(Self::SIGINT) {
            Some((-2, "Killed, SIGINT=2"))
        } else if self.contains(Self::SIGILL) {
            Some((-4, "Illegal Instruction, SIGILL=4"))
        } else if self.contains(Self::SIGABRT) {
            Some((-6, "Aborted, SIGABRT=6"))
        } else if self.contains(Self::SIGFPE) {
            Some((-8, "Erroneous Arithmetic Operation, SIGFPE=8"))
        } else if self.contains(Self::SIGKILL) {
            Some((-9, "Killed, SIGKILL=9"))
        } else if self.contains(Self::SIGSEGV) {
            Some((-11, "Segmentation Fault, SIGSEGV=11"))
        } else {
            None
        }
    }
}

设置完上下文之后,从 trap 返回就会进入 handler,然后 handler 末尾需要调用 sigreturn 来恢复之前的上下文

pub fn sys_sigreturn() -> isize {
    if let Some(task) = current_task() {
        let mut inner = task.inner_exclusive_access();
        inner.handling_sig = -1;    // 没有正在处理的信号
        // restore the trap context
        let trap_ctx = inner.get_trap_cx();
        *trap_ctx = inner.trap_ctx_backup.unwrap();
        // Here we return the value of a0 in the trap_ctx,
        // otherwise it will be overwritten after we trap
        // back to the original execution of the application.
        trap_ctx.x[10] as isize
    } else {
        -1
    }
}