rcore_test
/
rCore-Tutorial-v3-tests
1
1
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

add cargo fmt in Makefile, and exec make fmt

Browse Source
ch8
Yu Chen 3 years ago
parent fdeaca9bb0
commit 5729debb09
8 changed files with 39 additions and 48 deletions
Show Stats Download Patch File Download Diff File

2
Makefile
Unescape View File

@ -6,3 +6,5 @@ docker:
build_docker:
docker build -t ${DOCKER_NAME} .
fmt:
cd easy-fs; cargo fmt; cd ../easy-fs-fuse cargo fmt; cd ../os ; cargo fmt; cd ../user; cargo fmt; cd ..

1
os/src/boards/k210.rs
Unescape View File

@ -20,4 +20,3 @@ pub const MMIO: &[(usize, usize)] = &[
];
pub type BlockDeviceImpl = crate::drivers::block::SDCardWrapper;

1
os/src/boards/qemu.rs
Unescape View File

@ -3,4 +3,3 @@ pub const CLOCK_FREQ: usize = 12500000;
pub const MMIO: &[(usize, usize)] = &[(0x10001000, 0x1000)];
pub type BlockDeviceImpl = crate::drivers::block::VirtIOBlock;

1
os/src/config.rs
Unescape View File

@ -11,4 +11,3 @@ pub const TRAMPOLINE: usize = usize::MAX - PAGE_SIZE + 1;
pub const TRAP_CONTEXT_BASE: usize = TRAMPOLINE - PAGE_SIZE;
pub use crate::board::{CLOCK_FREQ, MMIO};

4
os/src/drivers/block/mod.rs
Unescape View File

@ -1,13 +1,13 @@
mod sdcard;
mod virtio_blk;
pub use virtio_blk::VirtIOBlock;
pub use sdcard::SDCardWrapper;
pub use virtio_blk::VirtIOBlock;
use crate::board::BlockDeviceImpl;
use alloc::sync::Arc;
use easy_fs::BlockDevice;
use lazy_static::*;
use crate::board::BlockDeviceImpl;
lazy_static! {
pub static ref BLOCK_DEVICE: Arc<dyn BlockDevice> = Arc::new(BlockDeviceImpl::new());

36
os/src/mm/memory_set.rs
Unescape View File

@ -351,26 +351,20 @@ pub fn remap_test() {
let mid_text: VirtAddr = ((stext as usize + etext as usize) / 2).into();
let mid_rodata: VirtAddr = ((srodata as usize + erodata as usize) / 2).into();
let mid_data: VirtAddr = ((sdata as usize + edata as usize) / 2).into();
assert!(
!kernel_space
.page_table
.translate(mid_text.floor())
.unwrap()
.writable(),
);
assert!(
!kernel_space
.page_table
.translate(mid_rodata.floor())
.unwrap()
.writable(),
);
assert!(
!kernel_space
.page_table
.translate(mid_data.floor())
.unwrap()
.executable(),
);
assert!(!kernel_space
.page_table
.translate(mid_text.floor())
.unwrap()
.writable(),);
assert!(!kernel_space
.page_table
.translate(mid_rodata.floor())
.unwrap()
.writable(),);
assert!(!kernel_space
.page_table
.translate(mid_data.floor())
.unwrap()
.executable(),);
println!("remap_test passed!");
}

7
user/src/bin/early_exit.rs
Unescape View File

@ -5,11 +5,13 @@
extern crate user_lib;
extern crate alloc;
use user_lib::{thread_create, exit};
use alloc::vec::Vec;
use user_lib::{exit, thread_create};
pub fn thread_a() -> ! {
for i in 0..1000 { print!("{}", i); }
for i in 0..1000 {
print!("{}", i);
}
exit(1)
}
@ -19,4 +21,3 @@ pub fn main() -> i32 {
println!("main thread exited.");
exit(0)
}

35
user/src/bin/stackful_coroutine.rs
Unescape View File

@ -3,7 +3,6 @@
// https://github.com/cfsamson/example-greenthreads
#![no_std]
#![no_main]
#![feature(naked_functions)]
#![feature(asm)]
@ -17,10 +16,10 @@ use core::arch::asm;
use alloc::vec;
use alloc::vec::Vec;
use user_lib::{exit};
use user_lib::exit;
// In our simple example we set most constraints here.
const DEFAULT_STACK_SIZE: usize = 4096; //128 got SEGFAULT, 256(1024, 4096) got right results.
const DEFAULT_STACK_SIZE: usize = 4096; //128 got SEGFAULT, 256(1024, 4096) got right results.
const MAX_TASKS: usize = 5;
static mut RUNTIME: usize = 0;
@ -93,10 +92,7 @@ impl Runtime {
let mut available_tasks: Vec<Task> = (1..MAX_TASKS).map(|i| Task::new(i)).collect();
tasks.append(&mut available_tasks);
Runtime {
tasks,
current: 0,
}
Runtime { tasks, current: 0 }
}
/// This is cheating a bit, but we need a pointer to our Runtime stored so we can call yield on it even if
@ -110,9 +106,9 @@ impl Runtime {
/// This is where we start running our runtime. If it is our base task, we call yield until
/// it returns false (which means that there are no tasks scheduled) and we are done.
pub fn run(&mut self){
while self.t_yield() {}
println!("All tasks finished!");
pub fn run(&mut self) {
while self.t_yield() {}
println!("All tasks finished!");
}
/// This is our return function. The only place we use this is in our `guard` function.
@ -131,7 +127,7 @@ impl Runtime {
/// If we find a task that's ready to be run we change the state of the current task from `Running` to `Ready`.
/// Then we call switch which will save the current context (the old context) and load the new context
/// into the CPU which then resumes based on the context it was just passed.
///
///
/// NOITCE: if we comment below `#[inline(never)]`, we can not get the corrent running result
#[inline(never)]
fn t_yield(&mut self) -> bool {
@ -200,10 +196,9 @@ impl Runtime {
// enough space to actually get an aligned pointer in the first place).
let s_ptr = (s_ptr as usize & !7) as *mut u8;
available.ctx.x1 = guard as u64; //ctx.x1 is old return address
available.ctx.nx1 = f as u64; //ctx.nx2 is new return address
available.ctx.x1 = guard as u64; //ctx.x1 is old return address
available.ctx.nx1 = f as u64; //ctx.nx2 is new return address
available.ctx.x2 = s_ptr.offset(-32) as u64; //cxt.x2 is sp
}
available.state = State::Ready;
}
@ -264,9 +259,10 @@ pub fn yield_task() {
/// see: https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html
#[naked]
#[no_mangle]
unsafe fn switch(old: *mut TaskContext, new: *const TaskContext) {
unsafe fn switch(old: *mut TaskContext, new: *const TaskContext) {
// a0: _old, a1: _new
asm!("
asm!(
"
sd x1, 0x00(a0)
sd x2, 0x08(a0)
sd x8, 0x10(a0)
@ -300,12 +296,13 @@ unsafe fn switch(old: *mut TaskContext, new: *const TaskContext) {
ld t0, 0x70(a1)
jr t0
", options( noreturn)
",
options(noreturn)
);
}
#[no_mangle]
pub fn main() {
pub fn main() {
println!("stackful_coroutine begin...");
println!("TASK 0(Runtime) STARTING");
let mut runtime = Runtime::new();
@ -349,4 +346,4 @@ pub fn main() {
runtime.run();
println!("stackful_coroutine PASSED");
exit(0);
}
}

Write Preview
Loading…
Cancel
Save