From b805336cfcc944cfde55ba5282d12ec03dfd5367 Mon Sep 17 00:00:00 2001 From: bjorn3 <17426603+bjorn3@users.noreply.github.com> Date: Fri, 3 Apr 2026 20:57:39 +0200 Subject: [PATCH] Fix a bunch of warnings --- src/arch/aarch64/start.rs | 7 +------ src/context/context.rs | 3 --- src/context/memory.rs | 39 +++++++++++++++++---------------------- src/percpu.rs | 2 +- src/scheme/proc.rs | 2 +- src/scheme/sys/context.rs | 2 +- src/sync/ordered.rs | 2 +- 7 files changed, 22 insertions(+), 35 deletions(-) diff --git a/src/arch/aarch64/start.rs b/src/arch/aarch64/start.rs index 08d0ad11fe..5ad6d2b172 100644 --- a/src/arch/aarch64/start.rs +++ b/src/arch/aarch64/start.rs @@ -2,12 +2,7 @@ //! It is incredibly unsafe, and should be minimal in nature //! It must create the IDT with the correct entries, those entries are //! defined in other files inside of the `arch` module -use core::{ - arch::naked_asm, - cell::SyncUnsafeCell, - slice, - sync::atomic::{AtomicBool, Ordering}, -}; +use core::{arch::naked_asm, cell::SyncUnsafeCell, slice}; use fdt::Fdt; diff --git a/src/context/context.rs b/src/context/context.rs index 9d1aa07431..02a2e60f7b 100644 --- a/src/context/context.rs +++ b/src/context/context.rs @@ -486,9 +486,6 @@ pub struct BorrowedHtBuf { head_and_not_tail: bool, } impl BorrowedHtBuf { - pub fn head(token: &mut CleanLockToken) -> Result { - Self::head_locked(token.downgrade()) - } pub fn head_locked(token: LockToken) -> Result { let current = context::current(); let frame = &mut current.write(token).syscall_head; diff --git a/src/context/memory.rs b/src/context/memory.rs index 2b501acda1..4704829f7c 100644 --- a/src/context/memory.rs +++ b/src/context/memory.rs @@ -23,8 +23,8 @@ use crate::{ percpu::PercpuBlock, scheme::{self, KernelSchemes}, sync::{ - ArcRwLockWriteGuard, CleanLockToken, LockToken, RwLock, RwLockReadGuard, - RwLockUpgradableGuard, RwLockWriteGuard, L0, L2, L3, + CleanLockToken, LockToken, RwLock, RwLockReadGuard, RwLockUpgradableGuard, + RwLockWriteGuard, L2, L3, }, }; @@ -99,31 +99,31 @@ impl AddrSpaceWrapper { } pub fn acquire_read<'a>( &'a self, - mut lock_token: LockToken<'a, L2>, + lock_token: LockToken<'a, L2>, ) -> RwLockReadGuard<'a, L3, AddrSpace> { self.inner.read(lock_token) } pub fn acquire_upgradeable_read<'a>( &'a self, - mut lock_token: LockToken<'a, L2>, + lock_token: LockToken<'a, L2>, ) -> RwLockUpgradableGuard<'a, L3, AddrSpace> { self.inner.upgradeable_read(lock_token) } pub fn acquire_write<'a>( &'a self, - mut lock_token: LockToken<'a, L2>, + lock_token: LockToken<'a, L2>, ) -> RwLockWriteGuard<'a, L3, AddrSpace> { self.inner.write(lock_token) } pub unsafe fn acquire_reupgradeable_read<'a>( &'a self, - mut lock_token: LockToken<'a, L3>, + lock_token: LockToken<'a, L3>, ) -> RwLockUpgradableGuard<'a, L3, AddrSpace> { unsafe { self.inner.reupgradeable_read(lock_token) } } pub unsafe fn acquire_rewrite<'a>( &'a self, - mut lock_token: LockToken<'a, L3>, + lock_token: LockToken<'a, L3>, ) -> RwLockWriteGuard<'a, L3, AddrSpace> { unsafe { self.inner.rewrite(lock_token) } } @@ -523,7 +523,7 @@ impl AddrSpaceWrapper { token: &mut CleanLockToken, ) -> Result { let mut lock_token = token.token(); - let mut guard = self.acquire_write(lock_token.downgrade()); + let guard = self.acquire_write(lock_token.downgrade()); let (_start_page, info) = guard.grants.contains(page).ok_or(Error::new(EINVAL))?; @@ -1415,7 +1415,6 @@ impl Grant { Some((phys, _)) => Frame::containing(phys), // TODO: ensure the correct context is hardblocked, if necessary None => { - let (_, token) = guard.token_split(); let (frame, _, new_guard) = correct_inner( src.addr_space_lock, guard, @@ -2442,9 +2441,8 @@ pub fn try_correcting_page_tables( return Err(PfError::Segv); }; - let lock = &addr_space; let mut lock_token = token.token(); - let mut addr_space_lock = addr_space.acquire_write(lock_token.downgrade()); + let addr_space_lock = addr_space.acquire_write(lock_token.downgrade()); let (_, flush, _) = correct_inner(&addr_space, addr_space_lock, faulting_page, access, 0)?; @@ -2458,13 +2456,12 @@ pub fn try_correcting_page_tables( /// Caller also need to provide clean token for the new AddrSpace. fn correct_inner<'l>( addr_space_lock: &'l Arc, - mut addr_space_guard: RwLockWriteGuard<'l, L3, AddrSpace>, + mut addr_space: RwLockWriteGuard<'l, L3, AddrSpace>, faulting_page: Page, access: AccessMode, recursion_level: u32, ) -> Result<(Frame, PageFlush, RwLockWriteGuard<'l, L3, AddrSpace>), PfError> { let mut flusher = Flusher::with_cpu_set(&addr_space_lock.used_by, &addr_space_lock.tlb_ack); - let (mut addr_space, mut lock_token) = addr_space_guard.token_split(); let Some((grant_base, grant_info)) = addr_space.grants.contains(faulting_page) else { debug!("Lacks grant"); @@ -2573,7 +2570,7 @@ fn correct_inner<'l>( return Err(PfError::NonfatalInternalError); } - /// XXX: This is cheating, but guaranteed from Arc::ptr_eq above we won't deadlock + // XXX: This is cheating, but guaranteed from Arc::ptr_eq above we won't deadlock let mut free_token = unsafe { CleanLockToken::new() }; let mut guard = foreign_address_space.acquire_upgradeable_read(free_token.downgrade()); let src_page = src_base.next_by(pages_from_grant_start); @@ -2593,7 +2590,7 @@ fn correct_inner<'l>( .ok_or(PfError::RecursionLimitExceeded)?; let guard_token = guard.into_token(); - let addr_space_guard_token = addr_space_guard.into_token(); + let addr_space_guard_token = addr_space.into_token(); drop(flusher); // FIXME: Can this result in invalid address space state? @@ -2611,9 +2608,8 @@ fn correct_inner<'l>( }; // SAFETY: Caller guarantees addr_space_guard is coming from this addr_space_lock - addr_space_guard = + addr_space = unsafe { addr_space_lock.acquire_rewrite(addr_space_guard_token) }; - addr_space = &mut *addr_space_guard; flusher = Flusher::with_cpu_set( &addr_space_lock.used_by, &addr_space_lock.tlb_ack, @@ -2685,9 +2681,9 @@ fn correct_inner<'l>( let file_ref = file_ref.clone(); let flags = map_flags(grant_info.flags()); drop(flusher); - let addr_space_guard_token = addr_space_guard.into_token(); + let addr_space_guard_token = addr_space.into_token(); - /// XXX: This is cheating, but guaranteed we won't deadlock because we've dropped addr_space_guard + // XXX: This is cheating, but guaranteed we won't deadlock because we've dropped addr_space_guard let mut token = unsafe { CleanLockToken::new() }; let (scheme_id, scheme_number) = { @@ -2724,8 +2720,7 @@ fn correct_inner<'l>( .ok_or(PfError::NonfatalInternalError)?; // SAFETY: Caller guarantees addr_space_guard is coming from this addr_space_lock - addr_space_guard = unsafe { addr_space_lock.acquire_rewrite(addr_space_guard_token) }; - addr_space = &mut *addr_space_guard; + addr_space = unsafe { addr_space_lock.acquire_rewrite(addr_space_guard_token) }; flusher = Flusher::with_cpu_set(&addr_space_lock.used_by, &addr_space_lock.tlb_ack); info!("Got frame {:?} from external fmap", frame); @@ -2746,7 +2741,7 @@ fn correct_inner<'l>( }; drop(flusher); - Ok((frame, flush, addr_space_guard)) + Ok((frame, flush, addr_space)) } #[derive(Debug)] diff --git a/src/percpu.rs b/src/percpu.rs index 191c6eda8b..026e7d1026 100644 --- a/src/percpu.rs +++ b/src/percpu.rs @@ -167,7 +167,7 @@ pub unsafe fn switch_arch_hook() { match &*percpu.current_addrsp.borrow() { Some(next_addrsp) => { next_addrsp.used_by.atomic_set(percpu.cpu_id); - let mut token = unsafe { CleanLockToken::new() }; + let mut token = CleanLockToken::new(); let mut token = token.token(); let next = next_addrsp.acquire_read(token.downgrade()); diff --git a/src/scheme/proc.rs b/src/scheme/proc.rs index 916d8b5859..4f72e58042 100644 --- a/src/scheme/proc.rs +++ b/src/scheme/proc.rs @@ -567,7 +567,7 @@ impl KernelScheme for ProcScheme { Ok(result_base.start_address().data()) } ContextHandle::Sighandler => { - let mut context = context.read(token.token()); + let context = context.read(token.token()); // let (context, token) = context.token_split(); let sig = context.sig.as_ref().ok_or(Error::new(EBADF))?; let frame = match map.offset { diff --git a/src/scheme/sys/context.rs b/src/scheme/sys/context.rs index 7daa59dece..d51eccca24 100644 --- a/src/scheme/sys/context.rs +++ b/src/scheme/sys/context.rs @@ -4,7 +4,7 @@ use alloc::{ }; use core::fmt::Write; -use crate::{context, paging::PAGE_SIZE, sync::CleanLockToken, syscall::error::Result}; +use crate::{context, sync::CleanLockToken, syscall::error::Result}; pub fn resource(token: &mut CleanLockToken) -> Result> { let mut string = format!( diff --git a/src/sync/ordered.rs b/src/sync/ordered.rs index 8acb74b058..a002456ec7 100644 --- a/src/sync/ordered.rs +++ b/src/sync/ordered.rs @@ -644,7 +644,7 @@ impl<'a, L: Level, T> RwLockUpgradableGuard<'a, L, T> { } /// Upgrade to RW lock - pub fn upgrade(mut self) -> RwLockWriteGuard<'a, L, T> { + pub fn upgrade(self) -> RwLockWriteGuard<'a, L, T> { RwLockWriteGuard { inner: spin::RwLockUpgradableGuard::upgrade(self.inner), lock_token: self.lock_token,