Yifan Wu
4 years ago
parent
57f7debbc6
commit
5389b7adca
@ -1,168 +0,0 @@
|
||||
use super::File;
|
||||
use alloc::sync::{Arc, Weak};
|
||||
use crate::sync::UPSafeCell;
|
||||
use crate::mm::UserBuffer;
|
||||
|
||||
use crate::task::suspend_current_and_run_next;
|
||||
|
||||
pub struct Pipe {
|
||||
readable: bool,
|
||||
writable: bool,
|
||||
buffer: Arc<UPSafeCell<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,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
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>>,
|
||||
}
|
||||
|
||||
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));
|
||||
}
|
||||
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;
|
||||
}
|
||||
}
|
||||
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()
|
||||
}
|
||||
}
|
||||
|
||||
/// 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)
|
||||
}
|
||||
|
||||
impl File for Pipe {
|
||||
fn readable(&self) -> bool { self.readable }
|
||||
fn writable(&self) -> bool { self.writable }
|
||||
fn read(&self, buf: UserBuffer) -> usize {
|
||||
assert_eq!(self.readable(), true);
|
||||
let mut buf_iter = buf.into_iter();
|
||||
let mut read_size = 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 read_size;
|
||||
}
|
||||
drop(ring_buffer);
|
||||
suspend_current_and_run_next();
|
||||
continue;
|
||||
}
|
||||
// read at most loop_read bytes
|
||||
for _ in 0..loop_read {
|
||||
if let Some(byte_ref) = buf_iter.next() {
|
||||
unsafe { *byte_ref = ring_buffer.read_byte(); }
|
||||
read_size += 1;
|
||||
} else {
|
||||
return read_size;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
fn write(&self, buf: UserBuffer) -> usize {
|
||||
assert_eq!(self.writable(), true);
|
||||
let mut buf_iter = buf.into_iter();
|
||||
let mut write_size = 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 });
|
||||
write_size += 1;
|
||||
} else {
|
||||
return write_size;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,69 +0,0 @@
|
||||
#![no_std]
|
||||
#![no_main]
|
||||
|
||||
#[macro_use]
|
||||
extern crate user_lib;
|
||||
|
||||
extern crate alloc;
|
||||
|
||||
use user_lib::{fork, close, pipe, read, write, wait, get_time};
|
||||
use alloc::format;
|
||||
|
||||
const LENGTH: usize = 3000;
|
||||
#[no_mangle]
|
||||
pub fn main() -> i32 {
|
||||
// create pipes
|
||||
// parent write to child
|
||||
let mut down_pipe_fd = [0usize; 2];
|
||||
// child write to parent
|
||||
let mut up_pipe_fd = [0usize; 2];
|
||||
pipe(&mut down_pipe_fd);
|
||||
pipe(&mut up_pipe_fd);
|
||||
let mut random_str = [0u8; LENGTH];
|
||||
if fork() == 0 {
|
||||
// close write end of down pipe
|
||||
close(down_pipe_fd[1]);
|
||||
// close read end of up pipe
|
||||
close(up_pipe_fd[0]);
|
||||
assert_eq!(read(down_pipe_fd[0], &mut random_str) as usize, LENGTH);
|
||||
close(down_pipe_fd[0]);
|
||||
let sum: usize = random_str.iter().map(|v| *v as usize).sum::<usize>();
|
||||
println!("sum = {}(child)", sum);
|
||||
let sum_str = format!("{}", sum);
|
||||
write(up_pipe_fd[1], sum_str.as_bytes());
|
||||
close(up_pipe_fd[1]);
|
||||
println!("Child process exited!");
|
||||
0
|
||||
} else {
|
||||
// close read end of down pipe
|
||||
close(down_pipe_fd[0]);
|
||||
// close write end of up pipe
|
||||
close(up_pipe_fd[1]);
|
||||
// generate a long random string
|
||||
for i in 0..LENGTH {
|
||||
random_str[i] = get_time() as u8;
|
||||
}
|
||||
// send it
|
||||
assert_eq!(write(down_pipe_fd[1], &random_str) as usize, random_str.len());
|
||||
// close write end of down pipe
|
||||
close(down_pipe_fd[1]);
|
||||
// calculate sum(parent)
|
||||
let sum: usize = random_str.iter().map(|v| *v as usize).sum::<usize>();
|
||||
println!("sum = {}(parent)", sum);
|
||||
// recv sum(child)
|
||||
let mut child_result = [0u8; 32];
|
||||
let result_len = read(up_pipe_fd[0], &mut child_result) as usize;
|
||||
close(up_pipe_fd[0]);
|
||||
// check
|
||||
assert_eq!(
|
||||
sum,
|
||||
str::parse::<usize>(
|
||||
core::str::from_utf8(&child_result[..result_len]).unwrap()
|
||||
).unwrap()
|
||||
);
|
||||
let mut _unused: i32 = 0;
|
||||
wait(&mut _unused);
|
||||
println!("pipe_large_test passed!");
|
||||
0
|
||||
}
|
||||
}
|
||||
@ -1,44 +0,0 @@
|
||||
#![no_std]
|
||||
#![no_main]
|
||||
|
||||
#[macro_use]
|
||||
extern crate user_lib;
|
||||
|
||||
use user_lib::{fork, close, pipe, read, write, wait};
|
||||
|
||||
static STR: &str = "Hello, world!";
|
||||
|
||||
#[no_mangle]
|
||||
pub fn main() -> i32 {
|
||||
// create pipe
|
||||
let mut pipe_fd = [0usize; 2];
|
||||
pipe(&mut pipe_fd);
|
||||
// read end
|
||||
assert_eq!(pipe_fd[0], 3);
|
||||
// write end
|
||||
assert_eq!(pipe_fd[1], 4);
|
||||
if fork() == 0 {
|
||||
// child process, read from parent
|
||||
// close write_end
|
||||
close(pipe_fd[1]);
|
||||
let mut buffer = [0u8; 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
|
||||
}
|
||||
}
|
||||
Loading…
Reference in new issue