garentyler/xv6-riscv
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

rename sleep to sleep_lock

Browse Source
This commit is contained in:
Garen Tyler 2023-10-21 22:44:06 -06:00
parent 38e44e020b
commit d06d271c9e
Signed by: garentyler
GPG Key ID: D7A048C454CB7054
11 changed files with 193 additions and 77 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
kernel/rustkernel/src/bio.rs
View File

@ -13,14 +13,7 @@
//! - Only one process at a time can use a buffer,
//! so do not keep them longer than necessary.
use crate::{
sync::sleeplock::{holdingsleep, acquiresleep, releasesleep},
sync::spinlock::Spinlock,
buf::Buffer,
param::NBUF,
virtio_disk::virtio_disk_rw,
};
use core::ptr::addr_of_mut;
use crate::{buf::Buffer, param::NBUF, sync::spinlock::Spinlock};
pub struct BufferCache {
pub buffers: [Buffer; NBUF],
@ -34,7 +27,6 @@ impl BufferCache {
for buf in &mut self.buffers {
if buf.dev == dev && buf.blockno == blockno {
buf.refcnt += 1;
}
}
}

2
kernel/rustkernel/src/console.rs
View File

@ -108,6 +108,8 @@ pub unsafe extern "C" fn consoleread(user_dst: i32, mut dst: u64, mut n: i32) ->
// cons.lock.unlock();
return -1;
}
// let channel = addr_of_mut!(console.read_index).cast();
// console.sleep(channel);
sleep_mutex(addr_of_mut!(console.read_index).cast(), &mut console);
}

18
kernel/rustkernel/src/pipe.rs Normal file
View File

@ -0,0 +1,18 @@
use crate::sync::spinlock::Spinlock;
use core::ffi::c_char;
pub const PIPESIZE: usize = 512usize;
#[repr(C)]
pub struct Pipe {
lock: Spinlock,
data: [c_char; PIPESIZE],
/// Number of bytes read.
nread: u32,
/// Number of bytes written.
nwrite: u32,
/// Read fd is still open.
readopen: i32,
/// Write fd is still open.
writeopen: i32,
}

24
kernel/rustkernel/src/proc.rs
View File

@ -4,7 +4,7 @@ use crate::{
kalloc::kfree,
param::*,
riscv::{self, Pagetable, PTE_W},
sync::spinlock::{pop_off, push_off, Spinlock},
sync::spinlock::Spinlock,
sync::spinmutex::SpinMutexGuard,
};
use core::{
@ -241,8 +241,7 @@ pub unsafe extern "C" fn mycpu() -> *mut Cpu {
pub unsafe extern "C" fn myproc() -> *mut Proc {
let _ = crate::trap::InterruptBlocker::new();
let c = mycpu();
let p = (*c).proc;
p
(*c).proc
}
#[no_mangle]
@ -408,7 +407,7 @@ pub unsafe extern "C" fn sched() {
/// Atomically release lock and sleep on chan.
/// Reacquires lock when awakened.
#[no_mangle]
pub unsafe extern "C" fn sleep(chan: *mut c_void, lock: *mut Spinlock) {
pub unsafe extern "C" fn sleep_lock(chan: *mut c_void, lock: *mut Spinlock) {
let p = myproc();
// Must acquire p->lock in order to
@ -455,6 +454,20 @@ pub unsafe fn sleep_mutex<T>(chan: *mut c_void, mutex: &mut SpinMutexGuard<T>) {
core::mem::forget(guard);
}
// pub unsafe fn sleep(chan: *mut c_void) {
// let p = myproc();
// let _guard = (*p).lock.lock();
//
// // Go to sleep.
// (*p).chan = chan;
// (*p).state = ProcState::Sleeping;
//
// sched();
//
// // Clean up.
// (*p).chan = null_mut();
// }
/// Kill the process with the given pid.
/// The victim won't exit until it tries to return
/// to user space (see usertrap() in trap.c).
@ -486,6 +499,5 @@ pub unsafe extern "C" fn setkilled(p: *mut Proc) {
#[no_mangle]
pub unsafe extern "C" fn killed(p: *mut Proc) -> i32 {
let _guard = (*p).lock.lock();
let k = (*p).killed;
k
(*p).killed
}

1
kernel/rustkernel/src/sync/mod.rs
View File

@ -1,3 +1,4 @@
pub(crate) mod mutex;
pub mod sleeplock;
pub mod spinlock;
pub mod spinmutex;

85
kernel/rustkernel/src/sync/mutex.rs Normal file
View File

@ -0,0 +1,85 @@
// use core::{
// cell::UnsafeCell,
// ops::{Deref, DerefMut, Drop},
// sync::atomic::{AtomicBool, Ordering},
// ffi::c_void,
// ptr::addr_of,
// };
// use crate::proc::{sleep, wakeup, sched, myproc, ProcState};
//
// pub struct Mutex<T> {
// locked: AtomicBool,
// inner: UnsafeCell<T>,
// }
// impl<T> Mutex<T> {
// pub const fn new(value: T) -> Mutex<T> {
// Mutex {
// locked: AtomicBool::new(false),
// inner: UnsafeCell::new(value),
// }
// }
// pub unsafe fn get_inner(&self) -> *mut T {
// self.inner.get()
// }
// /// Spin until the mutex is unlocked, acquiring afterwards.
// pub fn spin_lock(&self) -> MutexGuard<'_, T> {
// while self.locked.swap(true, Ordering::Acquire) {
// core::hint::spin_loop();
// }
//
// MutexGuard { mutex: self }
// }
// /// Sleep until the mutex is unlocked, acquiring afterwards.
// pub fn sleep_lock(&self) -> MutexGuard<'_, T> {
// while self.locked.swap(true, Ordering::Acquire) {
// unsafe {
// sleep(addr_of!(*self).cast_mut().cast());
// }
// }
//
// MutexGuard { mutex: self }
// }
// pub unsafe fn unlock(&self) {
// self.locked.store(false, Ordering::Release);
// wakeup(addr_of!(*self).cast_mut().cast());
// }
// }
// unsafe impl<T> Sync for Mutex<T> where T: Send {}
//
// pub struct MutexGuard<'m, T> {
// pub mutex: &'m Mutex<T>,
// }
// impl<'m, T> MutexGuard<'m, T> {
// pub unsafe fn sleep(&mut self, channel: *mut c_void){
// let p = myproc();
// let _guard = (*p).lock.lock();
// self.mutex.unlock();
//
// // Go to sleep.
// (*p).chan = channel;
// (*p).state = ProcState::Sleeping;
// sched();
//
// // Clean up.
// let guard = self.mutex.spin_lock();
// core::mem::forget(guard);
// }
// }
// impl<'m, T> Deref for MutexGuard<'m, T> {
// type Target = T;
//
// fn deref(&self) -> &Self::Target {
// unsafe { &*self.mutex.get_inner() }
// }
// }
// impl<'m, T> DerefMut for MutexGuard<'m, T> {
// fn deref_mut(&mut self) -> &mut Self::Target {
// unsafe { &mut *self.mutex.get_inner() }
// }
// }
// impl<'m, T> Drop for MutexGuard<'m, T> {
// fn drop(&mut self) {
// unsafe { self.mutex.unlock() }
// }
// }
//

15
kernel/rustkernel/src/sync/sleeplock.rs
View File

@ -1,8 +1,11 @@
use crate::{
proc::{myproc, sleep, wakeup},
sync::spinlock::{self, Spinlock},
proc::{myproc, sleep_lock, wakeup},
sync::spinlock::Spinlock,
};
use core::{
ffi::c_char,
ptr::{addr_of, null_mut},
};
use core::{ffi::c_char, ptr::{addr_of, null_mut}};
#[repr(C)]
pub struct Sleeplock {
@ -33,10 +36,14 @@ impl Sleeplock {
pub fn held_by_current_proc(&self) -> bool {
self.locked > 0 && self.pid == unsafe { (*myproc()).pid }
}
#[allow(clippy::while_immutable_condition)]
pub unsafe fn lock_unguarded(&self) {
let _guard = self.inner.lock();
while self.locked > 0 {
sleep(addr_of!(*self).cast_mut().cast(), addr_of!(self.inner).cast_mut().cast());
sleep_lock(
addr_of!(*self).cast_mut().cast(),
addr_of!(self.inner).cast_mut().cast(),
);
}
let this: &mut Self = &mut *addr_of!(*self).cast_mut();
this.locked = 1;

2
kernel/rustkernel/src/sync/spinlock.rs
View File

@ -4,7 +4,7 @@ use crate::{
};
use core::{
ffi::c_char,
ptr::{null_mut, addr_of},
ptr::{addr_of, null_mut},
sync::atomic::{AtomicBool, Ordering},
};

4
kernel/rustkernel/src/sysproc.rs
View File

@ -1,5 +1,5 @@
use crate::{
proc::{exit, fork, growproc, kill, killed, myproc, sleep, wait},
proc::{exit, fork, growproc, kill, killed, myproc, sleep_lock, wait},
syscall::{argaddr, argint},
};
use core::ptr::addr_of_mut;
@ -53,7 +53,7 @@ pub unsafe extern "C" fn sys_sleep() -> u64 {
crate::trap::tickslock.unlock();
return -1i64 as u64;
}
sleep(
sleep_lock(
addr_of_mut!(crate::trap::ticks).cast(),
addr_of_mut!(crate::trap::tickslock).cast(),
)

4
kernel/rustkernel/src/uart.rs
View File

@ -3,7 +3,7 @@
use crate::{
console::consoleintr,
proc::{sleep, sleep_mutex, wakeup},
proc::{sleep_lock, wakeup},
riscv::memlayout::UART0,
sync::spinlock::Spinlock,
sync::spinmutex::SpinMutex,
@ -171,7 +171,7 @@ pub(crate) unsafe fn uartputc(c: u8) {
while uart_tx_w == uart_tx_r + UART_TX_BUF_SIZE {
// Buffer is full.
// Wait for uartstart() to open up space in the buffer.
sleep(
sleep_lock(
addr_of_mut!(uart_tx_r).cast(),
addr_of_mut!(uart_tx_lock).cast(),
);

63
kernel/rustkernel/src/virtio_disk.rs
View File

@ -6,7 +6,7 @@
//! The virtio spec: https://docs.oasis-open.org/virtio/virtio/v1.1/virtio-v1.1.pdf
//! qemu ... -drive file=fs.img,if=none,format=raw,id=x0 -device virtio-blk-device,drive=x0,bus=virtio-mmio-bus.0
use crate::{sync::spinlock::Spinlock, buf::Buffer};
use crate::{buf::Buffer, sync::spinlock::Spinlock};
use core::ffi::c_char;
// Virtio MMIO control registers, mapped starting at 0x10001000
@ -20,55 +20,55 @@ pub const VIRTIO_MMIO_VERSION: u64 = 0x004u64;
///
/// 1: Network
/// 2: Disk
pub const VIRTIO_MMIO_DEVICE_ID: u64 = 0x008u64;
pub const VIRTIO_MMIO_DEVICE_ID: u64 = 0x008u64;
/// 0x554d4551
pub const VIRTIO_MMIO_VENDOR_ID: u64 = 0x00cu64;
pub const VIRTIO_MMIO_DEVICE_FEATURES: u64 = 0x010u64;
pub const VIRTIO_MMIO_DRIVER_FEATURES: u64 = 0x020u64;
pub const VIRTIO_MMIO_VENDOR_ID: u64 = 0x00cu64;
pub const VIRTIO_MMIO_DEVICE_FEATURES: u64 = 0x010u64;
pub const VIRTIO_MMIO_DRIVER_FEATURES: u64 = 0x020u64;
/// Select queue, write-only.
pub const VIRTIO_MMIO_QUEUE_SEL: u64 = 0x030u64;
pub const VIRTIO_MMIO_QUEUE_SEL: u64 = 0x030u64;
/// Max size of current queue, read-only.
pub const VIRTIO_MMIO_QUEUE_NUM_MAX: u64 = 0x034u64;
pub const VIRTIO_MMIO_QUEUE_NUM_MAX: u64 = 0x034u64;
/// Size of current queue, write-only.
pub const VIRTIO_MMIO_QUEUE_NUM: u64 = 0x038u64;
pub const VIRTIO_MMIO_QUEUE_NUM: u64 = 0x038u64;
/// Ready bit.
pub const VIRTIO_MMIO_QUEUE_READY: u64 = 0x044u64;
pub const VIRTIO_MMIO_QUEUE_READY: u64 = 0x044u64;
/// Write-only.
pub const VIRTIO_MMIO_QUEUE_NOTIFY: u64 = 0x050u64;
pub const VIRTIO_MMIO_QUEUE_NOTIFY: u64 = 0x050u64;
/// Read-only.
pub const VIRTIO_MMIO_INTERRUPT_STATUS: u64 = 0x060u64;
pub const VIRTIO_MMIO_INTERRUPT_STATUS: u64 = 0x060u64;
/// Write-only.
pub const VIRTIO_MMIO_INTERRUPT_ACK: u64 = 0x064u64;
pub const VIRTIO_MMIO_INTERRUPT_ACK: u64 = 0x064u64;
/// Read/write.
pub const VIRTIO_MMIO_STATUS: u64 = 0x070u64;
pub const VIRTIO_MMIO_STATUS: u64 = 0x070u64;
/// Physical address for descriptor table, write-only.
pub const VIRTIO_MMIO_QUEUE_DESC_LOW: u64 = 0x080u64;
pub const VIRTIO_MMIO_QUEUE_DESC_HIGH: u64 = 0x084u64;
pub const VIRTIO_MMIO_QUEUE_DESC_LOW: u64 = 0x080u64;
pub const VIRTIO_MMIO_QUEUE_DESC_HIGH: u64 = 0x084u64;
/// Physical address for available ring, write-only.
pub const VIRTIO_MMIO_DRIVER_DESC_LOW: u64 = 0x090u64;
pub const VIRTIO_MMIO_DRIVER_DESC_HIGH: u64 = 0x094u64;
pub const VIRTIO_MMIO_DRIVER_DESC_LOW: u64 = 0x090u64;
pub const VIRTIO_MMIO_DRIVER_DESC_HIGH: u64 = 0x094u64;
/// Physical address for used ring, write-only.
pub const VIRTIO_MMIO_DEVICE_DESC_LOW: u64 = 0x0a0u64;
pub const VIRTIO_MMIO_DEVICE_DESC_HIGH: u64 = 0x0a4u64;
pub const VIRTIO_MMIO_DEVICE_DESC_LOW: u64 = 0x0a0u64;
pub const VIRTIO_MMIO_DEVICE_DESC_HIGH: u64 = 0x0a4u64;
// Status register bits, from qemu virtio_config.h.
pub const VIRTIO_CONFIG_S_ACKNOWLEDGE: u8 = 0x01u8;
pub const VIRTIO_CONFIG_S_DRIVER: u8 = 0x02u8;
pub const VIRTIO_CONFIG_S_DRIVER_OK: u8 = 0x04u8;
pub const VIRTIO_CONFIG_S_FEATURES_OK: u8 = 0x08u8;
pub const VIRTIO_CONFIG_S_ACKNOWLEDGE: u8 = 0x01u8;
pub const VIRTIO_CONFIG_S_DRIVER: u8 = 0x02u8;
pub const VIRTIO_CONFIG_S_DRIVER_OK: u8 = 0x04u8;
pub const VIRTIO_CONFIG_S_FEATURES_OK: u8 = 0x08u8;
// Device feature bits
/// Disk is read-only.
pub const VIRTIO_BLK_F_RO: u8 = 5u8;
pub const VIRTIO_BLK_F_RO: u8 = 5u8;
/// Supports SCSI command passthrough.
pub const VIRTIO_BLK_F_SCSI: u8 = 7u8;
pub const VIRTIO_BLK_F_SCSI: u8 = 7u8;
/// Writeback mode available in config.
pub const VIRTIO_BLK_F_CONFIG_WCE: u8 = 11u8;
pub const VIRTIO_BLK_F_CONFIG_WCE: u8 = 11u8;
/// Support more than one vq.
pub const VIRTIO_BLK_F_MQ: u8 = 12u8;
pub const VIRTIO_F_ANY_LAYOUT: u8 = 27u8;
pub const VIRTIO_RING_F_INDIRECT_DESC: u8 = 28u8;
pub const VIRTIO_RING_F_EVENT_IDX: u8 = 29u8;
pub const VIRTIO_BLK_F_MQ: u8 = 12u8;
pub const VIRTIO_F_ANY_LAYOUT: u8 = 27u8;
pub const VIRTIO_RING_F_INDIRECT_DESC: u8 = 28u8;
pub const VIRTIO_RING_F_EVENT_IDX: u8 = 29u8;
/// This many virtio descriptors.
///
@ -123,7 +123,7 @@ pub struct VirtqUsed {
// Described in section 5.2 of the spec.
/// Read the disk.
pub const VIRTIO_BLK_T_IN: u32 = 0u32;
pub const VIRTIO_BLK_T_IN: u32 = 0u32;
/// Write the disk.
pub const VIRTIO_BLK_T_OUT: u32 = 1u32;
@ -177,7 +177,6 @@ pub struct Disk {
/// Indexed by first descriptor index of chain.
pub info: [DiskInfo; NUM_DESCRIPTORS],
/// Disk command headers.
/// One-for-one with descriptors, for convenience.
pub ops: [VirtioBlockRequest; NUM_DESCRIPTORS],