From 548be7daea178faf6e943baca4dc916e35436483 Mon Sep 17 00:00:00 2001 From: Garen Tyler Date: Sat, 21 Oct 2023 21:42:02 -0600 Subject: [PATCH] rename spinlock.lock() to spinlock.lock_unguarded() --- kernel/rustkernel/src/console.rs | 2 -- kernel/rustkernel/src/kalloc.rs | 4 ++-- kernel/rustkernel/src/printf.rs | 2 +- kernel/rustkernel/src/proc.rs | 20 ++++++++++---------- kernel/rustkernel/src/sync/sleeplock.rs | 6 +++--- kernel/rustkernel/src/sync/spinlock.rs | 4 ++-- kernel/rustkernel/src/sysproc.rs | 4 ++-- kernel/rustkernel/src/trap.rs | 2 +- kernel/rustkernel/src/uart.rs | 10 +++++----- 9 files changed, 26 insertions(+), 28 deletions(-) diff --git a/kernel/rustkernel/src/console.rs b/kernel/rustkernel/src/console.rs index f05787c..316227d 100644 --- a/kernel/rustkernel/src/console.rs +++ b/kernel/rustkernel/src/console.rs @@ -98,7 +98,6 @@ pub unsafe extern "C" fn consoleread(user_dst: i32, mut dst: u64, mut n: i32) -> let mut c; let mut cbuf; - // cons.lock.lock(); let mut console = cons.lock(); while n > 0 { @@ -161,7 +160,6 @@ pub unsafe fn consoleinit() { /// Do erase/kill processing, then append to cons.buf. /// Wake up consoleread() if a whole line has arrived. pub fn consoleintr(mut c: u8) { - // cons.lock.lock(); let mut console = cons.lock(); if c == ctrl_x(b'P') { diff --git a/kernel/rustkernel/src/kalloc.rs b/kernel/rustkernel/src/kalloc.rs index b07b329..b1ddb92 100644 --- a/kernel/rustkernel/src/kalloc.rs +++ b/kernel/rustkernel/src/kalloc.rs @@ -73,7 +73,7 @@ pub unsafe extern "C" fn kfree(pa: *mut u8) { let run: *mut Run = pa.cast(); - kmem.lock.lock(); + kmem.lock.lock_unguarded(); (*run).next = kmem.freelist; kmem.freelist = run; kmem.lock.unlock(); @@ -85,7 +85,7 @@ pub unsafe extern "C" fn kfree(pa: *mut u8) { /// Returns 0 if the memory cannot be allocated. #[no_mangle] pub unsafe extern "C" fn kalloc() -> *mut u8 { - kmem.lock.lock(); + kmem.lock.lock_unguarded(); let run = kmem.freelist; if !run.is_null() { diff --git a/kernel/rustkernel/src/printf.rs b/kernel/rustkernel/src/printf.rs index 1d2723c..da091be 100644 --- a/kernel/rustkernel/src/printf.rs +++ b/kernel/rustkernel/src/printf.rs @@ -14,7 +14,7 @@ pub struct PrintLock { macro_rules! print { ($($arg:tt)*) => {{ - unsafe { $crate::printf::PRINT_LOCK.lock() }; + unsafe { $crate::printf::PRINT_LOCK.lock_unguarded() }; // Allocate a page of memory as the buffer and release it when we're done. let buf = unsafe { $crate::kalloc::kalloc() as *mut [u8; 4096] }; diff --git a/kernel/rustkernel/src/proc.rs b/kernel/rustkernel/src/proc.rs index 1d27d6f..9108012 100644 --- a/kernel/rustkernel/src/proc.rs +++ b/kernel/rustkernel/src/proc.rs @@ -248,7 +248,7 @@ pub unsafe extern "C" fn myproc() -> *mut Proc { #[no_mangle] pub unsafe extern "C" fn allocpid() -> i32 { let lock = addr_of_mut!(pid_lock); - (*lock).lock(); + (*lock).lock_unguarded(); let pid = nextpid; nextpid += 1; (*lock).unlock(); @@ -265,7 +265,7 @@ pub unsafe extern "C" fn allocpid() -> i32 { pub unsafe extern "C" fn allocproc() -> *mut Proc { for p in &mut proc { let lock = addr_of_mut!(p.lock); - (*lock).lock(); + (*lock).lock_unguarded(); if p.state != ProcState::Unused { (*lock).unlock(); @@ -331,7 +331,7 @@ pub unsafe extern "C" fn freeproc(p: *mut Proc) { // let p: *mut Proc = addr_of_mut!(*p); // // if p != myproc() { -// (*p).lock.lock(); +// (*p).lock.lock_unguarded(); // if (*p).state == ProcState::Sleeping && (*p).chan == chan { // (*p).state = ProcState::Runnable; // } @@ -375,7 +375,7 @@ pub unsafe extern "C" fn growproc(n: i32) -> i32 { #[no_mangle] pub unsafe extern "C" fn r#yield() { let p = myproc(); - (*p).lock.lock(); + (*p).lock.lock_unguarded(); (*p).state = ProcState::Runnable; sched(); (*p).lock.unlock(); @@ -421,7 +421,7 @@ pub unsafe extern "C" fn sleep(chan: *mut c_void, lock: *mut Spinlock) { // (wakeup locks p->lock), // so it's okay to release lk. - (*p).lock.lock(); + (*p).lock.lock_unguarded(); (*lock).unlock(); // Go to sleep. @@ -435,14 +435,14 @@ pub unsafe extern "C" fn sleep(chan: *mut c_void, lock: *mut Spinlock) { // Reacquire original lock. (*p).lock.unlock(); - (*lock).lock(); + (*lock).lock_unguarded(); } pub unsafe fn sleep_mutex(chan: *mut c_void, mutex: &mut SpinMutexGuard) { let p = myproc(); let mutex = mutex.mutex; - (*p).lock.lock(); + (*p).lock.lock_unguarded(); mutex.unlock(); // Go to sleep. @@ -466,7 +466,7 @@ pub unsafe fn sleep_mutex(chan: *mut c_void, mutex: &mut SpinMutexGuard) { #[no_mangle] pub unsafe extern "C" fn kill(pid: i32) -> i32 { for p in &mut proc { - p.lock.lock(); + p.lock.lock_unguarded(); if p.pid == pid { p.killed = 1; @@ -486,14 +486,14 @@ pub unsafe extern "C" fn kill(pid: i32) -> i32 { #[no_mangle] pub unsafe extern "C" fn setkilled(p: *mut Proc) { - (*p).lock.lock(); + (*p).lock.lock_unguarded(); (*p).killed = 1; (*p).lock.unlock(); } #[no_mangle] pub unsafe extern "C" fn killed(p: *mut Proc) -> i32 { - (*p).lock.lock(); + (*p).lock.lock_unguarded(); let k = (*p).killed; (*p).lock.unlock(); k diff --git a/kernel/rustkernel/src/sync/sleeplock.rs b/kernel/rustkernel/src/sync/sleeplock.rs index c58382e..0045aad 100644 --- a/kernel/rustkernel/src/sync/sleeplock.rs +++ b/kernel/rustkernel/src/sync/sleeplock.rs @@ -22,7 +22,7 @@ pub unsafe extern "C" fn initsleeplock(lock: *mut Sleeplock, name: *mut c_char) #[no_mangle] pub unsafe extern "C" fn acquiresleep(lock: *mut Sleeplock) { - (*lock).inner.lock(); + (*lock).inner.lock_unguarded(); while (*lock).locked > 0 { sleep(lock.cast(), addr_of_mut!((*lock).inner)); } @@ -33,7 +33,7 @@ pub unsafe extern "C" fn acquiresleep(lock: *mut Sleeplock) { #[no_mangle] pub unsafe extern "C" fn releasesleep(lock: *mut Sleeplock) { - (*lock).inner.lock(); + (*lock).inner.lock_unguarded(); (*lock).locked = 0; (*lock).pid = 0; wakeup(lock.cast()); @@ -42,7 +42,7 @@ pub unsafe extern "C" fn releasesleep(lock: *mut Sleeplock) { #[no_mangle] pub unsafe extern "C" fn holdingsleep(lock: *mut Sleeplock) -> i32 { - (*lock).inner.lock(); + (*lock).inner.lock_unguarded(); let holding = ((*lock).locked > 0) && ((*lock).pid == (*myproc()).pid); (*lock).inner.unlock(); if holding { diff --git a/kernel/rustkernel/src/sync/spinlock.rs b/kernel/rustkernel/src/sync/spinlock.rs index 02c8d6f..9ff3663 100644 --- a/kernel/rustkernel/src/sync/spinlock.rs +++ b/kernel/rustkernel/src/sync/spinlock.rs @@ -36,7 +36,7 @@ impl Spinlock { pub fn held_by_current_cpu(&self) -> bool { self.cpu == unsafe { mycpu() } && self.locked.load(Ordering::Relaxed) } - pub unsafe fn lock(&mut self) { + pub unsafe fn lock_unguarded(&mut self) { push_off(); if self.held_by_current_cpu() { @@ -76,7 +76,7 @@ pub unsafe extern "C" fn holding(lock: *mut Spinlock) -> i32 { #[no_mangle] pub unsafe extern "C" fn acquire(lock: *mut Spinlock) { - (*lock).lock(); + (*lock).lock_unguarded(); } #[no_mangle] diff --git a/kernel/rustkernel/src/sysproc.rs b/kernel/rustkernel/src/sysproc.rs index 68873bb..bc73977 100644 --- a/kernel/rustkernel/src/sysproc.rs +++ b/kernel/rustkernel/src/sysproc.rs @@ -46,7 +46,7 @@ pub unsafe extern "C" fn sys_sleep() -> u64 { let mut n = 0i32; argint(0, addr_of_mut!(n)); - crate::trap::tickslock.lock(); + crate::trap::tickslock.lock_unguarded(); let ticks = crate::trap::ticks; while crate::trap::ticks < ticks + n as u32 { if killed(myproc()) > 0 { @@ -72,7 +72,7 @@ pub unsafe extern "C" fn sys_kill() -> u64 { /// Returns how many clock tick interrupts have occurred since start. #[no_mangle] pub unsafe extern "C" fn sys_uptime() -> u64 { - crate::trap::tickslock.lock(); + crate::trap::tickslock.lock_unguarded(); let ticks = crate::trap::ticks; crate::trap::tickslock.unlock(); ticks as u64 diff --git a/kernel/rustkernel/src/trap.rs b/kernel/rustkernel/src/trap.rs index 05d2b60..4effc27 100644 --- a/kernel/rustkernel/src/trap.rs +++ b/kernel/rustkernel/src/trap.rs @@ -45,7 +45,7 @@ pub unsafe extern "C" fn trapinithart() { #[no_mangle] pub unsafe extern "C" fn clockintr() { - tickslock.lock(); + tickslock.lock_unguarded(); ticks += 1; wakeup(addr_of_mut!(ticks).cast()); tickslock.unlock(); diff --git a/kernel/rustkernel/src/uart.rs b/kernel/rustkernel/src/uart.rs index d061f12..9e7bf30 100644 --- a/kernel/rustkernel/src/uart.rs +++ b/kernel/rustkernel/src/uart.rs @@ -158,9 +158,9 @@ pub(crate) unsafe fn uartinit() { /// from interrupts, it's only suitable for use /// by write(). pub(crate) unsafe fn uartputc(c: u8) { - uart_tx_lock.lock(); - // let mut buf = uart_tx_buf.lock(); - // let u = uart.lock(); + uart_tx_lock.lock_unguarded(); + // let mut buf = uart_tx_buf.lock_unguarded(); + // let u = uart.lock_unguarded(); if crate::PANICKED { loop { @@ -200,7 +200,7 @@ unsafe fn uartstart() { return; } - // let buf = uart_tx_buf.lock(); + // let buf = uart_tx_buf.lock_unguarded(); let c = uart_tx_buf[uart_tx_r % UART_TX_BUF_SIZE]; uart_tx_r += 1; @@ -231,7 +231,7 @@ pub(crate) unsafe fn uartintr() { } // Send buffered characters. - uart_tx_lock.lock(); + uart_tx_lock.lock_unguarded(); uartstart(); uart_tx_lock.unlock(); }