rename spinlock.lock() to spinlock.lock_unguarded()

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') {

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() {

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] };

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<T>(chan: *mut c_void, mutex: &mut SpinMutexGuard<T>) {
     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<T>(chan: *mut c_void, mutex: &mut SpinMutexGuard<T>) {
 #[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

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 {

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]

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

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();

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();
 }