andrey/osblog
1
0
Fork 0
mirror of https://github.com/sgmarz/osblog.git synced 2024-11-24 02:16:19 +04:00
Code Issues Projects Releases Wiki Activity

Updates to add a process for a file system read in the system call.

Browse Source
This commit is contained in:
Stephen Marz 2020-04-24 18:37:48 -04:00
parent 2e48b86656
commit 73636c1de1
9 changed files with 396 additions and 129 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
risc_v/src/block.rs
View File

@ -3,11 +3,11 @@
// Stephen Marz
// 10 March 2020
use crate::{kmem::{kfree, kmalloc},
use crate::{kmem::{kfree, kmalloc, talloc, tfree},
page::{zalloc, PAGE_SIZE},
virtio,
virtio::{Descriptor, MmioOffsets, Queue, StatusField, VIRTIO_RING_SIZE}};
use crate::process::{set_running, set_waiting};
use crate::process::{set_running, set_waiting, get_by_pid, add_kernel_process_args};
use core::mem::size_of;
#[repr(C)]
@ -376,13 +376,53 @@ pub fn handle_interrupt(idx: usize) {
}
}
pub fn process_read(pid: u16, dev: usize, buffer: *mut u8, size: u32, offset: u64) -> Result<u32, BlockErrors> {
println!("Process read {}, {}, 0x{:x}, {}, {}", pid, dev, buffer as usize, size, offset);
set_waiting(pid);
block_op(dev, buffer, size, offset, false, pid)
// ///////////////////////////////////////////////
// // BLOCK PROCESSES (KERNEL PROCESSES)
// ///////////////////////////////////////////////
struct ProcArgs {
pub pid: u16,
pub dev: usize,
pub buffer: *mut u8,
pub size: u32,
pub offset: u64,
}
pub fn process_write(pid: u16, dev: usize, buffer: *mut u8, size: u32, offset: u64) -> Result<u32, BlockErrors> {
set_waiting(pid);
block_op(dev, buffer, size, offset, true, pid)
fn read_proc(args_addr: usize) {
let args_ptr = args_addr as *mut ProcArgs;
let args = unsafe { args_ptr.as_ref().unwrap() };
let _ = block_op(args.dev, args.buffer, args.size, args.offset, false, args.pid);
tfree(args_ptr);
}
pub fn process_read(pid: u16, dev: usize, buffer: *mut u8, size: u32, offset: u64) {
// println!("Block read {}, {}, 0x{:x}, {}, {}", pid, dev, buffer as usize, size, offset);
let args = talloc::<ProcArgs>().unwrap();
args.pid = pid;
args.dev = dev;
args.buffer = buffer;
args.size = size;
args.offset = offset;
set_waiting(pid);
let _ = add_kernel_process_args(read_proc, args as *mut ProcArgs as usize);
}
fn write_proc(args_addr: usize) {
let args_ptr = args_addr as *mut ProcArgs;
let args = unsafe { args_ptr.as_ref().unwrap() };
let _ = block_op(args.dev, args.buffer, args.size, args.offset, true, args.pid);
tfree(args_ptr);
}
pub fn process_write(pid: u16, dev: usize, buffer: *mut u8, size: u32, offset: u64) {
let args = talloc::<ProcArgs>().unwrap();
args.pid = pid;
args.dev = dev;
args.buffer = buffer;
args.size = size;
args.offset = offset;
set_waiting(pid);
let _ = add_kernel_process_args(write_proc, args as *mut ProcArgs as usize);
}

11
risc_v/src/cpu.rs
View File

@ -233,3 +233,14 @@ pub fn satp_fence_asid(asid: usize) {
asm!("sfence.vma zero, $0" :: "r"(asid));
}
}
const MMIO_MTIME: *const u64 = 0x0200_BFF8 as *const u64;
pub fn get_mtime() -> usize {
unsafe {
(*MMIO_MTIME) as usize
}
}

1
risc_v/src/fs.rs
View File

@ -31,6 +31,7 @@ pub struct Descriptor {
pub node: u32,
pub loc: u32,
pub size: u32,
pub pid: u16,
}
pub enum FsError {

98
risc_v/src/minixfs.rs
View File

@ -6,6 +6,7 @@
use crate::{block,
fs::{Descriptor, FileSystem, FsError, Stat},
kmem::{kfree, kmalloc, talloc, tfree}};
use crate::process::{set_waiting, set_running, add_kernel_process_args};
use alloc::string::String;
use core::{mem::size_of, ptr::null_mut};
@ -108,7 +109,7 @@ impl MinixFileSystem {
/// the file's size. They are stored above the data zones, but to figure out where we
/// need to go to get the inode, we first need the superblock, which is where we can
/// find all of the information about the filesystem itself.
pub fn get_inode(bdev: usize, inode_num: u32) -> Option<Inode> {
pub fn get_inode(desc: &Descriptor, inode_num: u32) -> Option<Inode> {
// When we read, everything needs to be a multiple of a sector (512 bytes)
// So, we need to have memory available that's at least 512 bytes, even if
// we only want 10 bytes or 32 bytes (size of an Inode).
@ -119,14 +120,12 @@ impl MinixFileSystem {
// simultaneously, we can overlap the memory regions.
let super_block = unsafe { &*(buffer.get_mut() as *mut SuperBlock) };
let inode = unsafe { &*(buffer.get_mut() as *mut Inode) };
// Read from the block device. The size is 1 sector (512 bytes) and our offset is past
// the boot block (first 1024 bytes). This is where the superblock sits.
let result = block::read(bdev, buffer.get_mut(), 512, 1024);
for _ in 0..1000000 {
}
if result.is_ok() && super_block.magic == MAGIC {
println!("DO READ, magic should be next, buffer is at {:p}, desc is at {:p}", buffer.get(), desc as *const Descriptor);
syc_read(desc, buffer.get_mut(), 512, 1024);
println!("Magic is {:x}", super_block.magic);
if super_block.magic == MAGIC {
// If we get here, we successfully read what we think is the super block.
// The math here is 2 - one for the boot block, one for the super block. Then we
// have to skip the bitmaps blocks. We have a certain number of inode map blocks (imap)
@ -136,14 +135,9 @@ impl MinixFileSystem {
* BLOCK_SIZE as usize + (inode_num as usize - 1) * size_of::<Inode>();
// Now, we read the inode itself.
let result = block::read(bdev, buffer.get_mut(), 512, inode_offset as u64);
for _ in 0..1000000 {
}
if result.is_ok() {
syc_read(desc, buffer.get_mut(), 512, inode_offset as u32);
println!("Inode sizex = {} {:o}", inode.size, inode.mode);
return Some(inode.clone());
}
return Some(*inode);
}
// If we get here, some result wasn't OK. Either the super block
// or the inode itself.
@ -161,13 +155,14 @@ impl FileSystem for MinixFileSystem {
}
fn read(desc: &Descriptor, buffer: *mut u8, offset: u32, size: u32) -> u32 {
println!("MinixFileSystem::read: {}, {:p}, off: {}, sz: {}", desc.blockdev, buffer, offset, size);
let mut blocks_seen = 0u32;
let offset_block = offset / BLOCK_SIZE;
let offset_byte = offset % BLOCK_SIZE;
// let stats = Self::stat(desc);
let inode_result = Self::get_inode(desc, desc.node);
let mut block_buffer = BlockBuffer::new(BLOCK_SIZE);
let stats = Self::stat(desc);
let inode_result = Self::get_inode(desc.blockdev, desc.node);
if inode_result.is_none() {
// The inode couldn't be read, for some reason.
return 0;
@ -176,12 +171,12 @@ impl FileSystem for MinixFileSystem {
// First, the _size parameter (now in bytes_left) is the size of the buffer, not
// necessarily the size of the file. If our buffer is bigger than the file, we're OK.
// If our buffer is smaller than the file, then we can only read up to the buffer size.
let mut bytes_left = if size > stats.size {
stats.size
}
else {
size
};
// let mut bytes_left = if size > stats.size {
// stats.size
// }
// else {
// size
// };
let mut bytes_left = 0;
let mut bytes_read = 0u32;
// In Rust, our for loop automatically "declares" i from 0 to < 7. The syntax
@ -205,14 +200,10 @@ impl FileSystem for MinixFileSystem {
}
let zone_offset = zone_num * BLOCK_SIZE;
println!("Zone #{} -> #{} -> {}", i, zone_num, zone_offset);
if let Ok(_) = block::read(desc.blockdev, block_buffer.get_mut(), BLOCK_SIZE, zone_offset as u64) {
for _ in 0..100000 {}
println!("Offset = {:x}", unsafe {block_buffer.get_mut().add(32).read()});
}
syc_read(desc, block_buffer.get_mut(), BLOCK_SIZE, zone_offset);
}
blocks_seen += 1;
}
bytes_read
}
@ -223,7 +214,7 @@ impl FileSystem for MinixFileSystem {
fn close(_desc: &mut Descriptor) {}
fn stat(desc: &Descriptor) -> Stat {
let inode_result = Self::get_inode(desc.blockdev, desc.node);
let inode_result = Self::get_inode(desc, desc.node);
// This could be a little dangerous, but the descriptor should be checked in open().
let inode = inode_result.unwrap();
Stat { mode: inode.mode,
@ -232,3 +223,54 @@ impl FileSystem for MinixFileSystem {
gid: inode.gid, }
}
}
pub fn syc_read(desc: &Descriptor, buffer: *mut u8, size: u32, offset: u32) {
extern "C" {
fn make_syscall(sysno: usize, bdev: usize, buffer: usize, size: usize, offset: usize);
}
unsafe {
make_syscall(180, desc.blockdev as usize, buffer as usize, size as usize, offset as usize);
}
}
struct ProcArgs {
pub pid: u16,
pub dev: usize,
pub buffer: *mut u8,
pub size: u32,
pub offset: u32
}
fn read_proc(args_addr: usize) {
let args_ptr = args_addr as *mut ProcArgs;
let args = unsafe { args_ptr.as_ref().unwrap() };
let desc = Descriptor {
blockdev: args.dev,
node: 1,
loc: 0,
size: 500,
pid: args.pid
};
MinixFileSystem::read(&desc, args.buffer, args.offset, args.size);
tfree(args_ptr);
unsafe {
extern "C" {
fn make_syscall(no: usize);
}
make_syscall(93);
}
}
pub fn process_read(pid: u16, dev: usize, buffer: *mut u8, size: u32, offset: u32) {
// println!("FS read {}, {}, 0x{:x}, {}, {}", pid, dev, buffer as usize, size, offset);
let args = talloc::<ProcArgs>().unwrap();
args.pid = pid;
args.dev = dev;
args.buffer = buffer;
args.size = size;
args.offset = offset;
set_waiting(pid);
let _ = add_kernel_process_args(read_proc, args as *mut ProcArgs as usize);
}

145
risc_v/src/process.rs
View File

@ -3,13 +3,14 @@
// Stephen Marz
// 27 Nov 2019
use crate::{cpu::{build_satp, satp_fence_asid, CpuMode, SatpMode, TrapFrame},
use crate::{cpu::{build_satp, get_mtime, satp_fence_asid, CpuMode, SatpMode, TrapFrame},
page::{alloc, dealloc, map, unmap, zalloc, EntryBits, Table, PAGE_SIZE}};
use alloc::collections::vec_deque::VecDeque;
use core::ptr::null_mut;
// How many pages are we going to give a process for their
// stack?
const STACK_PAGES: usize = 2;
const STACK_PAGES: usize = 5;
// We want to adjust the stack to be at the bottom of the memory allocation
// regardless of where it is on the kernel heap.
const STACK_ADDR: usize = 0x1_0000_0000;
@ -31,10 +32,6 @@ pub static mut PROCESS_LIST: Option<VecDeque<Process>> = None;
// it's probably easier and faster just to increase the pid:
static mut NEXT_PID: u16 = 1;
extern "C" {
fn make_syscall(a: usize) -> usize;
}
/// Set a process' state to running. This doesn't do any checks.
/// If this PID is not found, this returns false. Otherwise, it
/// returns true.
@ -85,6 +82,32 @@ pub fn set_waiting(pid: u16) -> bool {
retval
}
/// Sleep a process
pub fn set_sleeping(pid: u16, duration: usize) -> bool {
// Yes, this is O(n). A better idea here would be a static list
// of process pointers.
let mut retval = false;
unsafe {
if let Some(mut pl) = PROCESS_LIST.take() {
for proc in pl.iter_mut() {
if proc.pid == pid {
proc.set_state(ProcessState::Sleeping);
proc.set_sleep_until(get_mtime() + duration);
retval = true;
break;
}
}
// Now, we no longer need the owned Deque, so we hand it
// back by replacing the PROCESS_LIST's None with the
// Some(pl).
PROCESS_LIST.replace(pl);
}
}
retval
}
/// Delete a process given by pid. If this process doesn't exist,
/// this function does nothing.
pub fn delete_process(pid: u16) {
unsafe {
if let Some(mut pl) = PROCESS_LIST.take() {
@ -105,20 +128,36 @@ pub fn delete_process(pid: u16) {
}
}
/// Get a process by PID. Since we leak the process list, this is
/// unsafe since the process can be deleted and we'll still have a pointer.
pub unsafe fn get_by_pid(pid: u16) -> *mut Process {
let mut ret = null_mut();
if let Some(mut pl) = PROCESS_LIST.take() {
for i in pl.iter_mut() {
if i.get_pid() == pid {
ret = i as *mut Process;
break;
}
}
PROCESS_LIST.replace(pl);
}
ret
}
/// We will eventually move this function out of here, but its
/// job is just to take a slot in the process list.
fn init_process() {
// We can't do much here until we have system calls because
// we're running in User space.
let mut i: usize = 0;
loop {
i += 1;
// Eventually, this will be a sleep system call.
if i > 100_000_000 {
unsafe {
make_syscall(1);
extern "C" {
fn make_syscall(sysno: usize, duration: usize) -> usize;
}
i = 0;
println!("Init is still here :), alright, back to sleep.");
make_syscall(2, 60000000);
}
}
}
@ -154,7 +193,7 @@ pub fn add_process_default(pr: fn()) {
}
/// Add a kernel process.
pub fn add_kernel_process(func: fn()) {
pub fn add_kernel_process(func: fn()) -> u16 {
// This is the Rust-ism that really trips up C++ programmers.
// PROCESS_LIST is wrapped in an Option<> enumeration, which
// means that the Option owns the Deque. We can only borrow from
@ -172,9 +211,10 @@ pub fn add_kernel_process(func: fn()) {
// We will convert NEXT_PID below into an atomic increment when
// we start getting into multi-hart processing. For now, we want
// a process. Get it to work, then improve it!
let my_pid = unsafe {NEXT_PID};
let mut ret_proc = Process { frame: zalloc(1) as *mut TrapFrame,
stack: zalloc(STACK_PAGES),
pid: unsafe { NEXT_PID },
pid: my_pid,
root: zalloc(1) as *mut Table,
state: ProcessState::Running,
data: ProcessData::zero(),
@ -201,12 +241,80 @@ pub fn add_kernel_process(func: fn()) {
// back by replacing the PROCESS_LIST's None with the
// Some(pl).
unsafe { PROCESS_LIST.replace(pl); }
my_pid
}
else {
// TODO: When we get to multi-hart processing, we need to keep
// trying to grab the process list. We can do this with an
// atomic instruction. but right now, we're a single-processor
// computer.
0
}
}
/// This is the same as the add_kernel_process function, except you can pass
/// arguments. Typically, this will be a memory address on the heap where
/// arguments can be found.
pub fn add_kernel_process_args(func: fn(args_ptr: usize), args: usize) -> u16 {
// This is the Rust-ism that really trips up C++ programmers.
// PROCESS_LIST is wrapped in an Option<> enumeration, which
// means that the Option owns the Deque. We can only borrow from
// it or move ownership to us. In this case, we choose the
// latter, where we move ownership to us, add a process, and
// then move ownership back to the PROCESS_LIST.
// This allows mutual exclusion as anyone else trying to grab
// the process list will get None rather than the Deque.
if let Some(mut pl) = unsafe { PROCESS_LIST.take() } {
// .take() will replace PROCESS_LIST with None and give
// us the only copy of the Deque.
let func_addr = func as usize;
let func_vaddr = func_addr; //- 0x6000_0000;
// println!("func_addr = {:x} -> {:x}", func_addr, func_vaddr);
// We will convert NEXT_PID below into an atomic increment when
// we start getting into multi-hart processing. For now, we want
// a process. Get it to work, then improve it!
let my_pid = unsafe {NEXT_PID};
let mut ret_proc = Process { frame: zalloc(1) as *mut TrapFrame,
stack: zalloc(STACK_PAGES),
pid: my_pid,
root: zalloc(1) as *mut Table,
state: ProcessState::Running,
data: ProcessData::zero(),
sleep_until: 0, };
unsafe {
NEXT_PID += 1;
}
// Now we move the stack pointer to the bottom of the
// allocation. The spec shows that register x2 (2) is the stack
// pointer.
// We could use ret_proc.stack.add, but that's an unsafe
// function which would require an unsafe block. So, convert it
// to usize first and then add PAGE_SIZE is better.
// We also need to set the stack adjustment so that it is at the
// bottom of the memory and far away from heap allocations.
unsafe {
(*ret_proc.frame).pc = func_vaddr;
(*ret_proc.frame).regs[10] = args;
(*ret_proc.frame).regs[2] = ret_proc.stack as usize + STACK_PAGES * 4096;
(*ret_proc.frame).mode = CpuMode::Machine as usize;
(*ret_proc.frame).pid = ret_proc.pid as usize;
}
pl.push_back(ret_proc);
// Now, we no longer need the owned Deque, so we hand it
// back by replacing the PROCESS_LIST's None with the
// Some(pl).
unsafe { PROCESS_LIST.replace(pl); }
my_pid
}
else {
// TODO: When we get to multi-hart processing, we need to keep
// trying to grab the process list. We can do this with an
// atomic instruction. but right now, we're a single-processor
// computer.
0
}
}
/// This should only be called once, and its job is to create
/// the init process. Right now, this process is in the kernel,
@ -214,7 +322,8 @@ pub fn add_kernel_process(func: fn()) {
pub fn init() -> usize {
unsafe {
PROCESS_LIST = Some(VecDeque::with_capacity(15));
add_process_default(init_process);
// add_process_default(init_process);
add_kernel_process(init_process);
// Ugh....Rust is giving me fits over here!
// I just want a memory address to the trap frame, but
// due to the borrow rules of Rust, I'm fighting here. So,
@ -267,6 +376,10 @@ impl Process {
self.frame as usize
}
pub fn get_frame(&mut self) -> *mut TrapFrame {
self.frame
}
pub fn get_program_counter(&self) -> usize {
unsafe { (*self.frame).pc }
}
@ -291,6 +404,10 @@ impl Process {
self.sleep_until
}
pub fn set_sleep_until(&mut self, until: usize) {
self.sleep_until = until;
}
pub fn new_default(func: fn()) -> Self {
let func_addr = func as usize;
let func_vaddr = func_addr; //- 0x6000_0000;

11
risc_v/src/sched.rs
View File

@ -4,6 +4,7 @@
// 27 Dec 2019
use crate::process::{ProcessState, PROCESS_LIST};
use crate::cpu::get_mtime;
pub fn schedule() -> usize {
let mut frame_addr: usize = 0x1111;
@ -15,7 +16,7 @@ pub fn schedule() -> usize {
// let mut mepc: usize = 0;
// let mut satp: usize = 0;
// let mut pid: usize = 0;
if let Some(prc) = pl.front() {
if let Some(prc) = pl.front_mut() {
match prc.get_state() {
ProcessState::Running => {
frame_addr =
@ -25,7 +26,13 @@ pub fn schedule() -> usize {
// satp = prc.get_table_address();
// pid = prc.get_pid() as usize;
},
ProcessState::Sleeping => {},
ProcessState::Sleeping => {
// Awaken sleeping processes whose sleep until is in
// the past.
if prc.get_sleep_until() <= get_mtime() {
prc.set_state(ProcessState::Running);
}
},
_ => {},
}
}

104
risc_v/src/syscall.rs
View File

@ -3,8 +3,11 @@
// Stephen Marz
// 3 Jan 2020
use crate::{block::process_read, cpu::TrapFrame};
use crate::process::delete_process;
use crate::{block::block_op,
cpu::TrapFrame,
fs::FileSystem,
minixfs,
process::{delete_process, set_sleeping}};
pub fn do_syscall(mepc: usize, frame: *mut TrapFrame) -> usize {
let syscall_number;
@ -18,6 +21,68 @@ pub fn do_syscall(mepc: usize, frame: *mut TrapFrame) -> usize {
// }
// }
}
match syscall_number {
0 | 93 => unsafe {
// Exit
// Currently, we cannot kill a process, it runs forever. We will delete
// the process later and free the resources, but for now, we want to get
// used to how processes will be scheduled on the CPU.
delete_process((*frame).pid as u16);
0
},
1 => {
println!("Test syscall");
mepc + 4
},
2 => unsafe {
// Sleep
set_sleeping((*frame).pid as u16, (*frame).regs[10]);
0
},
63 => unsafe {
// Read system call
// This is an asynchronous call. This will get the process going. We won't hear the answer until
// we an interrupt back.
// TODO: The buffer is a virtual memory address that needs to be translated to a physical memory
// location.
// This needs to be put into a process and ran.
let _ = minixfs::process_read(
(*frame).pid as u16,
(*frame).regs[10] as usize,
(*frame).regs[11] as *mut u8,
(*frame).regs[12] as u32,
(*frame).regs[13] as u32
);
// If we return 0, the trap handler will schedule another process.
0
},
180 => unsafe {
println!(
"Pid: {}, Dev: {}, Buffer: 0x{:x}, Size: {}, Offset: {}",
(*frame).pid,
(*frame).regs[10],
(*frame).regs[11],
(*frame).regs[12],
(*frame).regs[13]
);
let _ = block_op((*frame).regs[10],
(*frame).regs[11] as *mut u8,
(*frame).regs[12] as u32,
(*frame).regs[13] as u64,
false,
(*frame).pid as u16
);
0
},
_ => {
println!("Unknown syscall number {}", syscall_number);
mepc + 4
},
}
}
// These system call numbers come from libgloss so that we can use newlib
// for our system calls.
// Libgloss wants the system call number in A7 and arguments in A0..A6
@ -62,38 +127,3 @@ pub fn do_syscall(mepc: usize, frame: *mut TrapFrame) -> usize {
// #define SYS_lstat 1039
// #define SYS_time 1062
// #define SYS_getmainvars 2011
match syscall_number {
0 | 93 => unsafe {
// Exit
// Currently, we cannot kill a process, it runs forever. We will delete
// the process later and free the resources, but for now, we want to get
// used to how processes will be scheduled on the CPU.
delete_process((*frame).pid as u16);
0
},
1 => {
println!("Test syscall");
mepc + 4
},
63 => unsafe {
// Read system call
// This is an asynchronous call. This will get the process going. We won't hear the answer until
// we an interrupt back.
// TODO: The buffer is a virtual memory address that needs to be translated to a physical memory
// location.
let _ = process_read(
(*frame).pid as u16,
(*frame).regs[10],
(*frame).regs[11] as *mut u8,
(*frame).regs[12] as u32,
(*frame).regs[13] as u64,
);
// If we return 0, the trap handler will schedule another process.
0
},
_ => {
println!("Unknown syscall number {}", syscall_number);
mepc + 4
},
}
}

8
risc_v/src/test.rs
View File

@ -6,14 +6,8 @@ extern "C" {
pub fn test_block() {
// Let's test the block driver!
println!("Started test block process.");
let desc = crate::fs::Descriptor {
blockdev: 8,
node: 1,
loc: 0,
size: 500,
};
let buffer = crate::kmem::kmalloc(1024);
println!("Started test block process, buffer is at {:p}.", buffer);
unsafe {
make_syscall(63, 8, buffer as usize, 1024, 1024);
for i in 0..32 {

37
risc_v/src/trap.rs
View File

@ -37,9 +37,6 @@ extern "C" fn m_trap(epc: usize,
// number. So, here we narrow down just the cause number.
let cause_num = cause & 0xfff;
let mut return_pc = epc;
unsafe {
(*frame).pc = return_pc;
}
if is_async {
// Asynchronous trap
match cause_num {
@ -53,8 +50,22 @@ extern "C" fn m_trap(epc: usize,
// We would typically invoke the scheduler here to pick another
// process to run.
// Machine timer
// println!("CTX");
let frame = schedule();
// let p = frame as *const TrapFrame;
// println!(
// "CTX Startup {}, pc = {:x}",
// (*p).pid,
// (*p).pc
// );
// print!(" ");
// for i in 1..32 {
// if i % 4 == 0 {
// println!();
// print!(" ");
// }
// print!("{:2}:{:08x} ", i, (*p).regs[i]);
// }
// println!();
schedule_next_context_switch(1);
rust_switch_to_user(frame);
},
@ -93,7 +104,21 @@ extern "C" fn m_trap(epc: usize,
// the system call so that when we resume this process, we're after the ecall.
(*frame).pc += 4;
let frame = schedule();
// let p = frame as *const crate::process::Process;
// let p = frame as *const TrapFrame;
// println!(
// "SYC Startup {}, pc = {:x}",
// (*p).pid,
// (*p).pc,
// );
// print!(" ");
// for i in 1..32 {
// if i % 4 == 0 {
// println!();
// print!(" ");
// }
// print!("{:2}:{:08x} ", i, (*p).regs[i]);
// }
// println!();
schedule_next_context_switch(1);
rust_switch_to_user(frame);
}
@ -121,7 +146,7 @@ extern "C" fn m_trap(epc: usize,
return_pc += 4;
},
_ => {
panic!("Unhandled sync trap CPU#{} -> {}\n", hart, cause_num);
panic!("Unhandled sync trap {}. CPU#{} -> 0x{:08x}: 0x{:08x}\n", cause_num, hart, epc, tval);
},
}
};