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_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 << EOF | Here-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 给出了信号处理流程示意图

从示意图可以看到信号有两种来源
- 异步信号:进程正常执行过程中内核或者其他进程给它发送了一个信号
- 同步信号:进程执行期间触发,内核会将信号附加到 PCB 中
处理同样也有两种途径
- 进程未提供处理函数:内核按默认方式处理
- 进程提供了处理函数:保存 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
}
}