andrey/rCore-Tutorial-v3
1
0
Fork 0
mirror of https://github.com/rcore-os/rCore-Tutorial-v3.git synced 2024-11-23 01:46:24 +04:00
Code Issues Projects Releases Wiki Activity

Drop fd_table when a process exits; user_shell supports pipes

Browse Source
This commit is contained in:
Yifan Wu 2022-01-21 00:11:15 -08:00
parent 2ec8a4d28b
commit 87e61ef7e9
3 changed files with 192 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
os/src/task/mod.rs
View File

@ -66,6 +66,8 @@ pub fn exit_current_and_run_next(exit_code: i32) {
inner.children.clear();
// deallocate user space
inner.memory_set.recycle_data_pages();
// drop file descriptors
inner.fd_table.clear();
drop(inner);
// **** release current PCB
// drop task manually to maintain rc correctly

28
user/src/bin/count_lines.rs Normal file
View File

@ -0,0 +1,28 @@
#![no_std]
#![no_main]
#[macro_use]
extern crate user_lib;
use user_lib::read;
#[no_mangle]
pub fn main(_argc: usize, _argv: &[&str]) -> i32 {
let mut buf = [0u8; 256];
let mut lines = 0usize;
let mut total_size = 0usize;
loop {
let len = read(0, &mut buf) as usize;
if len == 0 { break; }
total_size += len;
let string = core::str::from_utf8(&buf[..len]).unwrap();
lines += string.chars().fold(0, |acc, c| {
acc + if c == '\n' { 1 } else { 0 }
});
}
if total_size > 0 {
lines += 1;
}
println!("{}", lines);
0
}

126
user/src/bin/user_shell.rs
View File

@ -10,6 +10,7 @@ const LF: u8 = 0x0au8;
const CR: u8 = 0x0du8;
const DL: u8 = 0x7fu8;
const BS: u8 = 0x08u8;
const LINE_START: &str = ">> ";
use alloc::string::String;
use alloc::vec::Vec;
@ -21,36 +22,32 @@ use user_lib::{
OpenFlags,
close,
dup,
pipe,
};
use user_lib::console::getchar;
#[no_mangle]
pub fn main() -> i32 {
println!("Rust user shell");
let mut line: String = String::new();
print!(">> ");
loop {
let c = getchar();
match c {
LF | CR => {
println!("");
if !line.is_empty() {
let args: Vec<_> = line.as_str().split(' ').collect();
#[derive(Debug)]
struct ProcessArguments {
input: String,
output: String,
args_copy: Vec<String>,
args_addr: Vec<*const u8>,
}
impl ProcessArguments {
pub fn new(command: &str) -> Self {
let args: Vec<_> = command.split(' ').collect();
let mut args_copy: Vec<String> = args
.iter()
.filter(|&arg| { !arg.is_empty() })
.map(|&arg| {
let mut string = String::new();
string.push_str(arg);
string.push('\0');
string
})
.collect();
args_copy
.iter_mut()
.for_each(|string| {
string.push('\0');
});
// redirect input
let mut input = String::new();
if let Some((idx, _)) = args_copy
@ -76,9 +73,68 @@ pub fn main() -> i32 {
.map(|arg| arg.as_ptr())
.collect();
args_addr.push(0 as *const u8);
Self {
input,
output,
args_copy,
args_addr,
}
}
}
#[no_mangle]
pub fn main() -> i32 {
println!("Rust user shell");
let mut line: String = String::new();
print!("{}", LINE_START);
loop {
let c = getchar();
match c {
LF | CR => {
println!("");
if !line.is_empty() {
let splited: Vec<_> = line.as_str().split('|').collect();
let process_arguments_list: Vec<_> = splited
.iter()
.map(|&cmd| ProcessArguments::new(cmd))
.collect();
let mut valid = true;
for (i, process_args) in process_arguments_list.iter().enumerate() {
if i == 0 {
if !process_args.output.is_empty() { valid = false; }
} else if i == process_arguments_list.len() - 1 {
if !process_args.input.is_empty() { valid = false; }
} else {
if !process_args.output.is_empty() || !process_args.input.is_empty() {
valid = false;
}
}
}
if process_arguments_list.len() == 1 { valid = true; }
if !valid {
println!("Invalid command: Inputs/Outputs cannot be correctly binded!");
} else {
// create pipes
let mut pipes_fd: Vec<[usize; 2]> = Vec::new();
if !process_arguments_list.is_empty() {
for _ in 0..process_arguments_list.len()-1 {
let mut pipe_fd = [0usize; 2];
pipe(&mut pipe_fd);
pipes_fd.push(pipe_fd);
}
}
let mut children: Vec<_> = Vec::new();
for (i, process_argument) in process_arguments_list
.iter()
.enumerate() {
let pid = fork();
if pid == 0 {
// input redirection
let input = &process_argument.input;
let output = &process_argument.output;
let args_copy = &process_argument.args_copy;
let args_addr = &process_argument.args_addr;
// redirect input
if !input.is_empty() {
let input_fd = open(input.as_str(), OpenFlags::RDONLY);
if input_fd == -1 {
@ -90,7 +146,7 @@ pub fn main() -> i32 {
assert_eq!(dup(input_fd), 0);
close(input_fd);
}
// output redirection
// redirect output
if !output.is_empty() {
let output_fd = open(
output.as_str(),
@ -105,21 +161,47 @@ pub fn main() -> i32 {
assert_eq!(dup(output_fd), 1);
close(output_fd);
}
// child process
// receive input from the previous process
if i > 0 {
close(0);
let read_end = pipes_fd.get(i-1).unwrap()[0];
assert_eq!(dup(read_end), 0);
}
// send output to the next process
if i < process_arguments_list.len()-1 {
close(1);
let write_end = pipes_fd.get(i).unwrap()[1];
assert_eq!(dup(write_end), 1);
}
// close all pipe ends inherited from the parent process
for pipe_fd in pipes_fd.iter() {
close(pipe_fd[0]);
close(pipe_fd[1]);
}
// execute new application
if exec(args_copy[0].as_str(), args_addr.as_slice()) == -1 {
println!("Error when executing!");
return -4;
}
unreachable!();
} else {
children.push(pid);
}
}
for pipe_fd in pipes_fd.iter() {
close(pipe_fd[0]);
close(pipe_fd[1]);
}
let mut exit_code: i32 = 0;
for pid in children.into_iter() {
let exit_pid = waitpid(pid as usize, &mut exit_code);
assert_eq!(pid, exit_pid);
println!("Shell: Process {} exited with code {}", pid, exit_code);
}
}
line.clear();
}
print!(">> ");
print!("{}", LINE_START);
}
BS | DL => {
if !line.is_empty() {