diff --git a/src/acpi/gtdt.rs b/src/acpi/gtdt.rs index 04674c9b4b..7c11973384 100644 --- a/src/acpi/gtdt.rs +++ b/src/acpi/gtdt.rs @@ -1,5 +1,4 @@ use alloc::boxed::Box; -use core::mem; use super::{find_sdt, sdt::Sdt}; use crate::{ @@ -56,7 +55,7 @@ impl Gtdt { } pub fn new(sdt: &'static Sdt) -> Option<&'static Gtdt> { - if &sdt.signature == b"GTDT" && sdt.length as usize >= mem::size_of::() { + if &sdt.signature == b"GTDT" && sdt.length as usize >= size_of::() { Some(unsafe { &*((sdt as *const Sdt) as *const Gtdt) }) } else { None diff --git a/src/acpi/hpet.rs b/src/acpi/hpet.rs index c8b707466f..ad62f14a95 100644 --- a/src/acpi/hpet.rs +++ b/src/acpi/hpet.rs @@ -1,6 +1,4 @@ -use core::{mem, ptr}; - -use core::ptr::{read_volatile, write_volatile}; +use core::ptr::{self, read_volatile, write_volatile}; #[cfg(not(target_arch = "x86"))] use crate::memory::{RmmA, RmmArch}; @@ -37,7 +35,7 @@ impl Hpet { } pub fn new(sdt: &'static Sdt) -> Option { - if &sdt.signature == b"HPET" && sdt.length as usize >= mem::size_of::() { + if &sdt.signature == b"HPET" && sdt.length as usize >= size_of::() { let s = unsafe { ptr::read((sdt as *const Sdt) as *const Hpet) }; if s.base_address.address_space == 0 { unsafe { s.map() }; diff --git a/src/acpi/madt/mod.rs b/src/acpi/madt/mod.rs index 9ecd5cbdf9..3159b9c497 100644 --- a/src/acpi/madt/mod.rs +++ b/src/acpi/madt/mod.rs @@ -1,4 +1,4 @@ -use core::{cell::SyncUnsafeCell, mem}; +use core::cell::SyncUnsafeCell; use super::sdt::Sdt; use crate::find_one_sdt; @@ -179,7 +179,7 @@ impl Iterator for MadtIter { if self.i + entry_len <= self.sdt.data_len() { let item = match entry_type { 0x0 => { - if entry_len == mem::size_of::() + 2 { + if entry_len == size_of::() + 2 { MadtEntry::LocalApic(unsafe { &*((self.sdt.data_address() + self.i + 2) as *const MadtLocalApic) }) @@ -188,7 +188,7 @@ impl Iterator for MadtIter { } } 0x1 => { - if entry_len == mem::size_of::() + 2 { + if entry_len == size_of::() + 2 { MadtEntry::IoApic(unsafe { &*((self.sdt.data_address() + self.i + 2) as *const MadtIoApic) }) @@ -197,7 +197,7 @@ impl Iterator for MadtIter { } } 0x2 => { - if entry_len == mem::size_of::() + 2 { + if entry_len == size_of::() + 2 { MadtEntry::IntSrcOverride(unsafe { &*((self.sdt.data_address() + self.i + 2) as *const MadtIntSrcOverride) @@ -207,7 +207,7 @@ impl Iterator for MadtIter { } } 0xB => { - if entry_len >= mem::size_of::() + 2 { + if entry_len >= size_of::() + 2 { MadtEntry::Gicc(unsafe { &*((self.sdt.data_address() + self.i + 2) as *const MadtGicc) }) @@ -216,7 +216,7 @@ impl Iterator for MadtIter { } } 0xC => { - if entry_len >= mem::size_of::() + 2 { + if entry_len >= size_of::() + 2 { MadtEntry::Gicd(unsafe { &*((self.sdt.data_address() + self.i + 2) as *const MadtGicd) }) diff --git a/src/acpi/mod.rs b/src/acpi/mod.rs index 59bba21915..59e3526544 100644 --- a/src/acpi/mod.rs +++ b/src/acpi/mod.rs @@ -43,7 +43,7 @@ pub fn get_sdt(sdt_address: PhysicalAddress, mapper: &mut KernelMapper) -> let sdt; unsafe { - const SDT_SIZE: usize = core::mem::size_of::(); + const SDT_SIZE: usize = size_of::(); map_linearly(sdt_address, SDT_SIZE, mapper); sdt = &*(RmmA::phys_to_virt(sdt_address).data() as *const Sdt); diff --git a/src/acpi/rsdt.rs b/src/acpi/rsdt.rs index 226d4b8d16..e5e7d54428 100644 --- a/src/acpi/rsdt.rs +++ b/src/acpi/rsdt.rs @@ -1,5 +1,5 @@ use alloc::boxed::Box; -use core::{convert::TryFrom, mem}; +use core::convert::TryFrom; use rmm::PhysicalAddress; use super::{rxsdt::Rxsdt, sdt::Sdt}; @@ -37,7 +37,7 @@ pub struct RsdtIter { impl Iterator for RsdtIter { type Item = PhysicalAddress; fn next(&mut self) -> Option { - if self.i < self.sdt.data_len() / mem::size_of::() { + if self.i < self.sdt.data_len() / size_of::() { let item = unsafe { (self.sdt.data_address() as *const u32) .add(self.i) diff --git a/src/acpi/sdt.rs b/src/acpi/sdt.rs index be8dc61dd9..83ff67dac1 100644 --- a/src/acpi/sdt.rs +++ b/src/acpi/sdt.rs @@ -1,5 +1,3 @@ -use core::mem; - #[derive(Copy, Clone, Debug)] #[repr(C, packed)] pub struct Sdt { @@ -17,13 +15,13 @@ pub struct Sdt { impl Sdt { /// Get the address of this tables data pub fn data_address(&self) -> usize { - self as *const _ as usize + mem::size_of::() + self as *const _ as usize + size_of::() } /// Get the length of this tables data pub fn data_len(&self) -> usize { let total_size = self.length as usize; - let header_size = mem::size_of::(); + let header_size = size_of::(); total_size.saturating_sub(header_size) } } diff --git a/src/acpi/spcr.rs b/src/acpi/spcr.rs index d35eecf18d..a478d3aa4e 100644 --- a/src/acpi/spcr.rs +++ b/src/acpi/spcr.rs @@ -1,5 +1,3 @@ -use core::mem; - use super::{find_sdt, sdt::Sdt, GenericAddressStructure}; use crate::{ device::serial::COM1, @@ -133,7 +131,7 @@ impl Spcr { } pub fn new(sdt: &'static Sdt) -> Option<&'static Spcr> { - if &sdt.signature == b"SPCR" && sdt.length as usize >= mem::size_of::() { + if &sdt.signature == b"SPCR" && sdt.length as usize >= size_of::() { Some(unsafe { &*((sdt as *const Sdt) as *const Spcr) }) } else { None diff --git a/src/acpi/xsdt.rs b/src/acpi/xsdt.rs index 55e41646ab..bb59065e52 100644 --- a/src/acpi/xsdt.rs +++ b/src/acpi/xsdt.rs @@ -1,5 +1,5 @@ use alloc::boxed::Box; -use core::{convert::TryFrom, mem}; +use core::convert::TryFrom; use rmm::PhysicalAddress; use super::{rxsdt::Rxsdt, sdt::Sdt}; @@ -37,7 +37,7 @@ pub struct XsdtIter { impl Iterator for XsdtIter { type Item = PhysicalAddress; fn next(&mut self) -> Option { - if self.i < self.sdt.data_len() / mem::size_of::() { + if self.i < self.sdt.data_len() / size_of::() { let item = unsafe { core::ptr::read_unaligned((self.sdt.data_address() as *const u64).add(self.i)) }; diff --git a/src/arch/aarch64/interrupt/trace.rs b/src/arch/aarch64/interrupt/trace.rs index 72ec17d758..4f7ea6843b 100644 --- a/src/arch/aarch64/interrupt/trace.rs +++ b/src/arch/aarch64/interrupt/trace.rs @@ -1,4 +1,4 @@ -use core::{arch::asm, mem}; +use core::arch::asm; pub struct StackTrace { pub fp: usize, @@ -11,7 +11,7 @@ impl StackTrace { unsafe { let fp: usize; asm!("mov {}, fp", out(reg) fp); - let pc_ptr = fp.checked_add(mem::size_of::())?; + let pc_ptr = fp.checked_add(size_of::())?; Some(StackTrace { fp, pc_ptr: pc_ptr as *const usize, @@ -22,7 +22,7 @@ impl StackTrace { pub unsafe fn next(self) -> Option { unsafe { let fp = *(self.fp as *const usize); - let pc_ptr = fp.checked_add(mem::size_of::())?; + let pc_ptr = fp.checked_add(size_of::())?; Some(StackTrace { fp: fp, pc_ptr: pc_ptr as *const usize, diff --git a/src/arch/riscv64/device/irqchip/clint.rs b/src/arch/riscv64/device/irqchip/clint.rs index 560d86df0b..273dcb1855 100644 --- a/src/arch/riscv64/device/irqchip/clint.rs +++ b/src/arch/riscv64/device/irqchip/clint.rs @@ -24,7 +24,7 @@ pub static CLINT: Mutex> = Mutex::new(None); impl Clint { pub fn new(addr: *mut u8, size: usize, freq: usize) -> Self { - assert!(size >= core::mem::size_of::()); + assert!(size >= size_of::()); Self { regs: unsafe { (addr as *mut ClintRegs).as_mut().unwrap() }, freq: freq as u64 diff --git a/src/arch/riscv64/device/irqchip/plic.rs b/src/arch/riscv64/device/irqchip/plic.rs index 4d274bfdc3..ac08ff43f8 100644 --- a/src/arch/riscv64/device/irqchip/plic.rs +++ b/src/arch/riscv64/device/irqchip/plic.rs @@ -37,7 +37,7 @@ struct PlicRegs { const _: () = assert!(0x1000 == mem::offset_of!(PlicRegs, pending)); const _: () = assert!(0x2000 == mem::offset_of!(PlicRegs, enable)); const _: () = assert!(0x20_0000 == mem::offset_of!(PlicRegs, thresholds)); -const _: () = assert!(0x1000 == mem::size_of::()); +const _: () = assert!(0x1000 == size_of::()); impl PlicRegs { pub fn set_priority(self: &mut Self, irq: usize, priority: usize) { diff --git a/src/arch/riscv64/interrupt/handler.rs b/src/arch/riscv64/interrupt/handler.rs index 339fc2ab46..5b2470ee8c 100644 --- a/src/arch/riscv64/interrupt/handler.rs +++ b/src/arch/riscv64/interrupt/handler.rs @@ -1,5 +1,4 @@ use crate::{memory::ArchIntCtx, panic, syscall::IntRegisters}; -use core::mem::size_of; #[derive(Default)] #[repr(C)] diff --git a/src/arch/riscv64/interrupt/trace.rs b/src/arch/riscv64/interrupt/trace.rs index bf428c1ca0..5d24fe7503 100644 --- a/src/arch/riscv64/interrupt/trace.rs +++ b/src/arch/riscv64/interrupt/trace.rs @@ -1,4 +1,4 @@ -use core::{arch::asm, mem}; +use core::arch::asm; pub struct StackTrace { pub fp: usize, @@ -12,8 +12,8 @@ impl StackTrace { let fp: usize; asm!("mv {}, fp", out(reg) fp); - let pc_ptr = fp.checked_sub(mem::size_of::())?; - let fp = pc_ptr.checked_sub(mem::size_of::())?; + let pc_ptr = fp.checked_sub(size_of::())?; + let fp = pc_ptr.checked_sub(size_of::())?; Some(StackTrace { fp, pc_ptr: pc_ptr as *const usize, @@ -24,8 +24,8 @@ impl StackTrace { pub unsafe fn next(self) -> Option { unsafe { let fp = *(self.fp as *const usize); - let pc_ptr = fp.checked_sub(mem::size_of::())?; - let fp = pc_ptr.checked_sub(mem::size_of::())?; + let pc_ptr = fp.checked_sub(size_of::())?; + let fp = pc_ptr.checked_sub(size_of::())?; Some(StackTrace { fp: fp, pc_ptr: pc_ptr as *const usize, diff --git a/src/arch/x86_64/alternative.rs b/src/arch/x86_64/alternative.rs index 43142809e9..6198c8e3b3 100644 --- a/src/arch/x86_64/alternative.rs +++ b/src/arch/x86_64/alternative.rs @@ -1,7 +1,5 @@ #![allow(unused_imports)] -use core::mem::size_of; - use spin::Once; use x86::controlregs::{Cr4, Xcr0}; @@ -115,7 +113,7 @@ pub unsafe fn early_init(bsp: bool) { // 16 * size_of::() is well below usize::MAX #[expect(clippy::arithmetic_side_effects)] - if state.size() as usize != 16 * core::mem::size_of::() { + if state.size() as usize != 16 * size_of::() { warn!("Unusual AVX state size {}", state.size()); } diff --git a/src/arch/x86_64/interrupt/handler.rs b/src/arch/x86_64/interrupt/handler.rs index ec2f2d12d4..d3b9aa8986 100644 --- a/src/arch/x86_64/interrupt/handler.rs +++ b/src/arch/x86_64/interrupt/handler.rs @@ -510,7 +510,7 @@ macro_rules! interrupt_error { "iretq;", inner = sym inner, - rax_offset = const(::core::mem::size_of::<$crate::interrupt::handler::PreservedRegisters>() + ::core::mem::size_of::<$crate::interrupt::handler::ScratchRegisters>() - 8), + rax_offset = const(size_of::<$crate::interrupt::handler::PreservedRegisters>() + size_of::<$crate::interrupt::handler::ScratchRegisters>() - 8), ); } }; diff --git a/src/arch/x86_shared/idt.rs b/src/arch/x86_shared/idt.rs index 5b2cb283dd..7ddd78d3ee 100644 --- a/src/arch/x86_shared/idt.rs +++ b/src/arch/x86_shared/idt.rs @@ -273,7 +273,7 @@ pub unsafe fn install_idt(idt_ptr: *mut Idt) { } let idtr: DescriptorTablePointer = DescriptorTablePointer { - limit: (idt.entries.len() * mem::size_of::() - 1) as u16, + limit: (idt.entries.len() * size_of::() - 1) as u16, base: idt.entries.as_ptr() as *const X86IdtEntry, }; diff --git a/src/arch/x86_shared/interrupt/trace.rs b/src/arch/x86_shared/interrupt/trace.rs index 21ac9e21bc..5046b6f638 100644 --- a/src/arch/x86_shared/interrupt/trace.rs +++ b/src/arch/x86_shared/interrupt/trace.rs @@ -1,5 +1,3 @@ -use core::mem; - pub struct StackTrace { pub fp: usize, pub pc_ptr: *const usize, @@ -14,7 +12,7 @@ impl StackTrace { core::arch::asm!("mov {}, ebp", out(reg) fp); #[cfg(target_arch = "x86_64")] core::arch::asm!("mov {}, rbp", out(reg) fp); - let pc_ptr = fp.checked_add(mem::size_of::())?; + let pc_ptr = fp.checked_add(size_of::())?; Some(Self { fp, pc_ptr: pc_ptr as *const usize, @@ -25,7 +23,7 @@ impl StackTrace { pub unsafe fn next(self) -> Option { unsafe { let fp = *(self.fp as *const usize); - let pc_ptr = fp.checked_add(mem::size_of::())?; + let pc_ptr = fp.checked_add(size_of::())?; Some(Self { fp, pc_ptr: pc_ptr as *const usize, diff --git a/src/common/int_like.rs b/src/common/int_like.rs index bad1534ae4..a427a8d6fc 100644 --- a/src/common/int_like.rs +++ b/src/common/int_like.rs @@ -149,7 +149,6 @@ macro_rules! int_like { #[test] fn test() { use ::core::sync::atomic::AtomicUsize; - use core::mem::size_of; // Generate type `usize_like`. int_like!(UsizeLike, usize); diff --git a/src/context/arch/aarch64.rs b/src/context/arch/aarch64.rs index 312015095b..eeae97ed2e 100644 --- a/src/context/arch/aarch64.rs +++ b/src/context/arch/aarch64.rs @@ -4,7 +4,7 @@ use crate::{ percpu::PercpuBlock, syscall::FloatRegisters, }; -use core::{mem, mem::offset_of, ptr, sync::atomic::AtomicBool}; +use core::{mem::offset_of, ptr, sync::atomic::AtomicBool}; use spin::Once; use syscall::{EnvRegisters, Result}; @@ -92,7 +92,7 @@ impl Context { ) { let mut stack_top = stack.initial_top(); - const INT_REGS_SIZE: usize = core::mem::size_of::(); + const INT_REGS_SIZE: usize = size_of::(); if userspace_allowed { unsafe { @@ -230,9 +230,9 @@ unsafe extern "C" fn fp_save(float_regs: &mut FloatRegisters) { "str x9, [{3}]", "mrs x9, fpsr", "str x9, [{3}, {2} - {1}]", - const mem::offset_of!(FloatRegisters, fp_simd_regs), - const mem::offset_of!(FloatRegisters, fpcr), - const mem::offset_of!(FloatRegisters, fpsr), + const offset_of!(FloatRegisters, fp_simd_regs), + const offset_of!(FloatRegisters, fpcr), + const offset_of!(FloatRegisters, fpsr), inout(reg) float_regs => _, ); } @@ -263,9 +263,9 @@ unsafe extern "C" fn fp_load(float_regs: &mut FloatRegisters) { "msr fpcr, x9", "ldr x9, [{3}, {2} - {1}]", "msr fpsr, x9", - const mem::offset_of!(FloatRegisters, fp_simd_regs), - const mem::offset_of!(FloatRegisters, fpcr), - const mem::offset_of!(FloatRegisters, fpsr), + const offset_of!(FloatRegisters, fp_simd_regs), + const offset_of!(FloatRegisters, fpcr), + const offset_of!(FloatRegisters, fpsr), inout(reg) float_regs => _, ); } diff --git a/src/context/arch/riscv64.rs b/src/context/arch/riscv64.rs index ab6bc89617..b20e81d1ea 100644 --- a/src/context/arch/riscv64.rs +++ b/src/context/arch/riscv64.rs @@ -55,7 +55,7 @@ impl Context { ) { let mut stack_top = stack.initial_top(); - const INT_REGS_SIZE: usize = core::mem::size_of::(); + const INT_REGS_SIZE: usize = size_of::(); if userspace_allowed { unsafe { diff --git a/src/context/arch/x86.rs b/src/context/arch/x86.rs index f859d13c49..79a1bde6d1 100644 --- a/src/context/arch/x86.rs +++ b/src/context/arch/x86.rs @@ -77,7 +77,7 @@ impl Context { ) { let mut stack_top = stack.initial_top(); - const INT_REGS_SIZE: usize = core::mem::size_of::(); + const INT_REGS_SIZE: usize = size_of::(); unsafe { if userspace_allowed { @@ -86,13 +86,13 @@ impl Context { stack_top.write_bytes(0_u8, INT_REGS_SIZE); (&mut *stack_top.cast::()).init(); - stack_top = stack_top.sub(core::mem::size_of::()); + stack_top = stack_top.sub(size_of::()); stack_top .cast::() .write(crate::interrupt::syscall::enter_usermode as usize); } - stack_top = stack_top.sub(core::mem::size_of::()); + stack_top = stack_top.sub(size_of::()); stack_top.cast::().write(func as usize); } diff --git a/src/context/arch/x86_64.rs b/src/context/arch/x86_64.rs index 62fdb4cfe9..fcb3e1b0ec 100644 --- a/src/context/arch/x86_64.rs +++ b/src/context/arch/x86_64.rs @@ -89,7 +89,7 @@ impl Context { ) { let mut stack_top = stack.initial_top(); - const INT_REGS_SIZE: usize = core::mem::size_of::(); + const INT_REGS_SIZE: usize = size_of::(); // Kstack::initial_top() is always at least 8 byte aligned. assertion to be safe debug_assert!( @@ -104,13 +104,13 @@ impl Context { stack_top.write_bytes(0_u8, INT_REGS_SIZE); (*stack_top.cast::()).init(); - stack_top = stack_top.sub(core::mem::size_of::()); + stack_top = stack_top.sub(size_of::()); stack_top .cast::() .write(crate::interrupt::syscall::enter_usermode as usize); } - stack_top = stack_top.sub(core::mem::size_of::()); + stack_top = stack_top.sub(size_of::()); stack_top.cast::().write(func as usize); } diff --git a/src/context/context.rs b/src/context/context.rs index c8f0b1ef55..d3cdc06e86 100644 --- a/src/context/context.rs +++ b/src/context/context.rs @@ -405,7 +405,7 @@ impl Context { this_percpu.maybe_handle_tlb_shootdown(); } - let _old_addrsp = core::mem::replace( + let _old_addrsp = mem::replace( &mut *this_percpu.current_addrsp.borrow_mut(), addr_space.clone(), ); @@ -454,8 +454,8 @@ impl Context { sig: &mut SignalState, ) -> (&Sigcontrol, &SigProcControl, &mut SignalState) { let check = |off| { - assert_eq!(usize::from(off) % mem::align_of::(), 0); - assert!(usize::from(off).saturating_add(mem::size_of::()) < PAGE_SIZE); + assert_eq!(usize::from(off) % align_of::(), 0); + assert!(usize::from(off).saturating_add(size_of::()) < PAGE_SIZE); }; check(sig.procctl_off); check(sig.threadctl_off); @@ -547,7 +547,7 @@ impl BorrowedHtBuf { core::str::from_utf8(slice).map_err(|_| Error::new(EINVAL)) } pub unsafe fn use_for_struct(&mut self) -> Result<&mut T> { - if mem::size_of::() > PAGE_SIZE || mem::align_of::() > PAGE_SIZE { + if size_of::() > PAGE_SIZE || align_of::() > PAGE_SIZE { return Err(Error::new(EINVAL)); } self.buf_mut().fill(0_u8); diff --git a/src/cpu_set.rs b/src/cpu_set.rs index 9e7a5a9b32..727354ebc6 100644 --- a/src/cpu_set.rs +++ b/src/cpu_set.rs @@ -128,5 +128,5 @@ impl Display for LogicalCpuSet { pub type RawMask = [usize; SET_WORDS]; pub fn mask_as_bytes(mask: &RawMask) -> &[u8] { - unsafe { core::slice::from_raw_parts(mask.as_ptr().cast(), core::mem::size_of::()) } + unsafe { core::slice::from_raw_parts(mask.as_ptr().cast(), size_of::()) } } diff --git a/src/debugger.rs b/src/debugger.rs index a773a6c243..b41f27fcd3 100644 --- a/src/debugger.rs +++ b/src/debugger.rs @@ -227,7 +227,7 @@ fn dump_stack(context: &Context, mut sp: usize) { }) { let value = unsafe { *(sp as *const usize) }; println!(" {:>0width$x}: {:>0width$x}", sp, value, width = width); - if let Some(next_sp) = sp.checked_add(core::mem::size_of::()) { + if let Some(next_sp) = sp.checked_add(size_of::()) { sp = next_sp; } else { println!(" {:>0width$x}: OVERFLOW", sp, width = width); diff --git a/src/memory/mod.rs b/src/memory/mod.rs index 9ff21cd44c..393ae7ebd9 100644 --- a/src/memory/mod.rs +++ b/src/memory/mod.rs @@ -3,7 +3,6 @@ use core::{ cell::SyncUnsafeCell, - mem, num::NonZeroUsize, sync::atomic::{AtomicUsize, Ordering}, }; @@ -495,7 +494,7 @@ pub const MAX_SECTION_SIZE: usize = 1 << MAX_SECTION_SIZE_BITS; pub const MAX_SECTION_PAGE_COUNT: usize = MAX_SECTION_SIZE / PAGE_SIZE; const _: () = { - assert!(mem::size_of::().is_power_of_two()); + assert!(size_of::().is_power_of_two()); }; #[cold] @@ -529,7 +528,7 @@ fn init_sections(mut allocator: BumpAllocator) { }) .sum(); let section_array_page_count = - (max_section_count * mem::size_of::
()).div_ceil(PAGE_SIZE); + (max_section_count * size_of::
()).div_ceil(PAGE_SIZE); let base = allocator .allocate(FrameCount::new(section_array_page_count)) @@ -589,7 +588,7 @@ fn init_sections(mut allocator: BumpAllocator) { let page_info_count = core::cmp::min(page_info_max_count, pages_to_next_section); let page_info_array_size_pages = - (page_info_count * mem::size_of::()).div_ceil(PAGE_SIZE); + (page_info_count * size_of::()).div_ceil(PAGE_SIZE); let page_info_array = unsafe { let base = allocator .allocate(FrameCount::new(page_info_array_size_pages)) diff --git a/src/panic.rs b/src/panic.rs index c10fa16c72..cddbd9a993 100644 --- a/src/panic.rs +++ b/src/panic.rs @@ -1,6 +1,6 @@ //! Intrinsics for panic handling -use core::{mem, panic::PanicInfo, slice}; +use core::{panic::PanicInfo, slice}; #[cfg(target_pointer_width = "32")] use object::elf::FileHeader32 as FileHeader; @@ -171,8 +171,7 @@ pub unsafe fn user_stack_trace(stack: &InterruptStack) { break; } let rip_addr = fp + size_of::(); - let rip = match UserSliceRo::new(rip_addr, mem::size_of::()) - .and_then(|x| x.read_usize()) + let rip = match UserSliceRo::new(rip_addr, size_of::()).and_then(|x| x.read_usize()) { Ok(val) => val, Err(err) => { @@ -185,11 +184,10 @@ pub unsafe fn user_stack_trace(stack: &InterruptStack) { break; } - let next_fp = - match UserSliceRo::new(fp, mem::size_of::()).and_then(|x| x.read_usize()) { - Ok(val) => val, - Err(_err) => break, - }; + let next_fp = match UserSliceRo::new(fp, size_of::()).and_then(|x| x.read_usize()) { + Ok(val) => val, + Err(_err) => break, + }; if next_fp <= fp { println!( " 016x}; stack walk ended>", diff --git a/src/profiling.rs b/src/profiling.rs index 74f95007d8..95b668ffb3 100644 --- a/src/profiling.rs +++ b/src/profiling.rs @@ -2,7 +2,6 @@ use core::sync::atomic::AtomicU32; use core::{ cell::UnsafeCell, - mem::size_of, sync::atomic::{AtomicBool, AtomicPtr, AtomicUsize, Ordering}, }; diff --git a/src/scheme/event.rs b/src/scheme/event.rs index c3896d6336..36efe5b2b0 100644 --- a/src/scheme/event.rs +++ b/src/scheme/event.rs @@ -1,5 +1,4 @@ use alloc::sync::Arc; -use core::mem; use syscall::{EventFlags, O_NONBLOCK}; use crate::{ @@ -88,7 +87,7 @@ impl KernelScheme for EventScheme { }; let mut events_written = 0; - for chunk in buf.in_exact_chunks(mem::size_of::()) { + for chunk in buf.in_exact_chunks(size_of::()) { let event = unsafe { chunk.read_exact::()? }; if queue.write(&[event], token)? == 0 { break; @@ -96,7 +95,7 @@ impl KernelScheme for EventScheme { events_written += 1; } - Ok(events_written * mem::size_of::()) + Ok(events_written * size_of::()) } fn kfpath(&self, _id: usize, buf: UserSliceWo, _token: &mut CleanLockToken) -> Result { diff --git a/src/scheme/irq.rs b/src/scheme/irq.rs index 92efd9bbe1..453165f953 100644 --- a/src/scheme/irq.rs +++ b/src/scheme/irq.rs @@ -2,7 +2,7 @@ // this scheme should only handle raw IRQ registration and delivery to userspace. use core::{ - mem, str, + str, str::FromStr, sync::atomic::{AtomicUsize, Ordering}, }; @@ -450,7 +450,7 @@ impl crate::scheme::KernelScheme for IrqScheme { irq: handle_irq, ack: ref handle_ack, } => { - if buffer.len() < mem::size_of::() { + if buffer.len() < size_of::() { return Err(Error::new(EINVAL)); } let ack = buffer.read_usize()?; @@ -463,7 +463,7 @@ impl crate::scheme::KernelScheme for IrqScheme { unsafe { acknowledge(handle_irq as usize); } - Ok(mem::size_of::()) + Ok(size_of::()) } _ => Err(Error::new(EBADF)), } @@ -478,18 +478,18 @@ impl crate::scheme::KernelScheme for IrqScheme { irq: handle_irq, .. } => Stat { st_mode: MODE_CHR | 0o600, - st_size: mem::size_of::() as u64, + st_size: size_of::() as u64, st_blocks: 1, - st_blksize: mem::size_of::() as u32, + st_blksize: size_of::() as u32, st_ino: handle_irq.into(), st_nlink: 1, ..Default::default() }, Handle::Bsp => Stat { st_mode: MODE_CHR | 0o400, - st_size: mem::size_of::() as u64, + st_size: size_of::() as u64, st_blocks: 1, - st_blksize: mem::size_of::() as u32, + st_blksize: size_of::() as u32, st_ino: INO_BSP, st_nlink: 1, ..Default::default() @@ -554,23 +554,23 @@ impl crate::scheme::KernelScheme for IrqScheme { irq: handle_irq, ack: ref handle_ack, } => { - if buffer.len() < mem::size_of::() { + if buffer.len() < size_of::() { return Err(Error::new(EINVAL)); } let current = COUNTS.lock()[handle_irq as usize]; if handle_ack.load(Ordering::SeqCst) != current { buffer.write_usize(current)?; - Ok(mem::size_of::()) + Ok(size_of::()) } else { Ok(0) } } Handle::Bsp => { - if buffer.len() < mem::size_of::() { + if buffer.len() < size_of::() { return Err(Error::new(EINVAL)); } buffer.write_u32(LogicalCpuId::BSP.get())?; - Ok(mem::size_of::()) + Ok(size_of::()) } Handle::Avail(_) | Handle::TopLevel | Handle::Phandle(_, _) | Handle::SchemeRoot => { Err(Error::new(EISDIR)) diff --git a/src/scheme/pipe.rs b/src/scheme/pipe.rs index 418a5cd8a3..df5db9d908 100644 --- a/src/scheme/pipe.rs +++ b/src/scheme/pipe.rs @@ -469,7 +469,7 @@ impl KernelScheme for PipeScheme { let (mut vec, mut token) = vec.into_split(); let fds_available = vec.len(); - let max_fds_read = payload.len() / core::mem::size_of::(); + let max_fds_read = payload.len() / size_of::(); let fds_to_read = core::cmp::min(fds_available, max_fds_read); if fds_to_read > 0 { let fds_to_transfer: Vec<_> = vec.drain(..fds_to_read).collect(); diff --git a/src/scheme/proc.rs b/src/scheme/proc.rs index 143ffa4ce3..bdcc26da0a 100644 --- a/src/scheme/proc.rs +++ b/src/scheme/proc.rs @@ -28,7 +28,7 @@ use alloc::{ vec::Vec, }; use core::{ - mem::{self, size_of}, + mem::size_of, num::NonZeroUsize, slice, str, sync::atomic::{AtomicUsize, Ordering}, @@ -954,7 +954,7 @@ impl ContextHandle { } _ => return Err(Error::new(EINVAL)), } - Ok(words_read * mem::size_of::()) + Ok(words_read * size_of::()) } ContextHandle::Regs(kind) => match kind { RegsKind::Float => { @@ -967,7 +967,7 @@ impl ContextHandle { // registers being uninitiated context.set_fx_regs(regs); - Ok(mem::size_of::()) + Ok(size_of::()) }) } RegsKind::Int => { @@ -985,14 +985,14 @@ impl ContextHandle { Some(stack) => { stack.load(®s); - Ok(mem::size_of::()) + Ok(size_of::()) } }) } RegsKind::Env => { let regs = unsafe { buf.read_exact::()? }; write_env_regs(context, regs, token)?; - Ok(mem::size_of::()) + Ok(size_of::()) } }, ContextHandle::Sighandler => { @@ -1012,7 +1012,7 @@ impl ContextHandle { let state = if data.thread_control_addr != 0 && data.proc_control_addr != 0 { let validate_off = |addr, sz| { let off: usize = addr % PAGE_SIZE; - if off.is_multiple_of(mem::align_of::()) && off + sz <= PAGE_SIZE { + if off.is_multiple_of(align_of::()) && off + sz <= PAGE_SIZE { Ok(off as u16) } else { Err(Error::new(EINVAL)) @@ -1024,11 +1024,11 @@ impl ContextHandle { Some(SignalState { threadctl_off: validate_off( data.thread_control_addr, - mem::size_of::(), + size_of::(), )?, procctl_off: validate_off( data.proc_control_addr, - mem::size_of::(), + size_of::(), )?, user_handler: NonZeroUsize::new(data.user_handler) .ok_or(Error::new(EINVAL))?, @@ -1048,7 +1048,7 @@ impl ContextHandle { context.write(token.token()).sig = state; - Ok(mem::size_of::()) + Ok(size_of::()) } ContextHandle::Start => match context.write(token.token()).status { ref mut status @ Status::HardBlocked { @@ -1106,7 +1106,7 @@ impl ContextHandle { context, }; - Ok(mem::size_of::()) + Ok(size_of::()) } ContextHandle::CurrentAddrSpace => { let mut iter = buf.usizes(); @@ -1138,9 +1138,9 @@ impl ContextHandle { }; let written = if arg1.is_some() { - 4 * mem::size_of::() + 4 * size_of::() } else { - 3 * mem::size_of::() + 3 * size_of::() }; Ok(written) @@ -1152,7 +1152,7 @@ impl ContextHandle { } let mut lock_token = token.token(); addrspace.acquire_write(lock_token.downgrade()).mmap_min = val; - Ok(mem::size_of::()) + Ok(size_of::()) } Self::SchedAffinity => { let mask = unsafe { buf.read_exact::()? }; @@ -1162,7 +1162,7 @@ impl ContextHandle { .sched_affinity .override_from(&mask); - Ok(mem::size_of_val(&mask)) + Ok(size_of_val(&mask)) } ContextHandle::Status { privileged } => { let mut args = buf.usizes(); @@ -1240,11 +1240,11 @@ impl ContextHandle { let mut ctxt = context.write(token.token()); //trace!("FORCEKILL NONSELF={} {}, SELF={}", ctxt.debug_id, ctxt.pid, context::current().read().debug_id); if let context::Status::Dead { .. } = ctxt.status { - return Ok(mem::size_of::()); + return Ok(size_of::()); } ctxt.status = context::Status::Runnable; ctxt.being_sigkilled = true; - Ok(mem::size_of::()) + Ok(size_of::()) } } } @@ -1340,7 +1340,7 @@ impl ContextHandle { Output { float: context.get_fx_regs(), }, - mem::size_of::(), + size_of::(), ) } RegsKind::Int => { @@ -1357,7 +1357,7 @@ impl ContextHandle { Some(stack) => { let mut regs = IntRegisters::default(); stack.save(&mut regs); - Ok((Output { int: regs }, mem::size_of::())) + Ok((Output { int: regs }, size_of::())) } })? } @@ -1365,7 +1365,7 @@ impl ContextHandle { Output { env: read_env_regs(context, token)?, }, - mem::size_of::(), + size_of::(), ), }; @@ -1378,7 +1378,7 @@ impl ContextHandle { let Ok(offset) = usize::try_from(offset) else { return Ok(0); }; - let grants_to_skip = offset / mem::size_of::(); + let grants_to_skip = offset / size_of::(); // Output a list of grant descriptors, sufficient to allow relibc's fork() // implementation to fmap MAP_SHARED grants. @@ -1405,12 +1405,12 @@ impl ContextHandle { for (src, chunk) in dst .iter() .take(grants_read) - .zip(buf.in_exact_chunks(mem::size_of::())) + .zip(buf.in_exact_chunks(size_of::())) { chunk.copy_exactly(src)?; } - Ok(grants_read * mem::size_of::()) + Ok(grants_read * size_of::()) } ContextHandle::Filetable { data, .. } => read_from(buf, data, offset), @@ -1418,13 +1418,13 @@ impl ContextHandle { let mut token = token.token(); let addr = addrspace.acquire_read(token.downgrade()); buf.write_usize(addr.mmap_min)?; - Ok(mem::size_of::()) + Ok(size_of::()) } ContextHandle::SchedAffinity => { let mask = context.read(token.token()).sched_affinity.to_raw(); buf.copy_exactly(crate::cpu_set::mask_as_bytes(&mask))?; - Ok(mem::size_of_val(&mask)) + Ok(size_of_val(&mask)) } // TODO: Replace write() with SYS_SENDFD? ContextHandle::Status { .. } => { let status = { diff --git a/src/scheme/time.rs b/src/scheme/time.rs index 13d3dac25a..2ef0177185 100644 --- a/src/scheme/time.rs +++ b/src/scheme/time.rs @@ -1,6 +1,6 @@ use alloc::vec::Vec; use core::{ - fmt, mem, str, + fmt, str, sync::atomic::{AtomicUsize, Ordering}, }; use hashbrown::{hash_map::DefaultHashBuilder, HashMap}; @@ -165,7 +165,7 @@ impl KernelScheme for TimeScheme { let mut bytes_read = 0; - for current_chunk in buf.in_exact_chunks(mem::size_of::()) { + for current_chunk in buf.in_exact_chunks(size_of::()) { let arch_time = match (handle.clock, handle.kind.clone()) { (CLOCK_REALTIME, TimeSchemeKind::Default | TimeSchemeKind::ClockGettime) => { time::realtime(token) @@ -183,7 +183,7 @@ impl KernelScheme for TimeScheme { }; current_chunk.copy_exactly(&time)?; - bytes_read += mem::size_of::(); + bytes_read += size_of::(); } Ok(bytes_read) @@ -208,7 +208,7 @@ impl KernelScheme for TimeScheme { let mut bytes_written = 0; - for current_chunk in buf.in_exact_chunks(mem::size_of::()) { + for current_chunk in buf.in_exact_chunks(size_of::()) { let time = unsafe { current_chunk.read_exact::()? }; match (handle.clock, handle.kind.clone()) { @@ -224,7 +224,7 @@ impl KernelScheme for TimeScheme { _ => return Err(Error::new(EINVAL)), }; - bytes_written += mem::size_of::(); + bytes_written += size_of::(); } Ok(bytes_written) diff --git a/src/scheme/user.rs b/src/scheme/user.rs index de49ac906e..30d461e1ec 100644 --- a/src/scheme/user.rs +++ b/src/scheme/user.rs @@ -252,7 +252,7 @@ impl UserInner { // for TLB, but we don't really have any other choice. The scheme must be able // to access the borrowed memory until it has responded to the request. *callee_responsible = - core::mem::replace(caller_responsible, PageSpan::empty()); + mem::replace(caller_responsible, PageSpan::empty()); Err(Error::new(EINTR)) } else { @@ -2043,7 +2043,7 @@ impl KernelScheme for UserScheme { token: &mut CleanLockToken, ) -> Result { let inner = self.inner.clone(); - if !payload.len().is_multiple_of(mem::size_of::()) { + if !payload.len().is_multiple_of(size_of::()) { return Err(Error::new(EINVAL)); } @@ -2056,7 +2056,7 @@ impl KernelScheme for UserScheme { } let ctx = { context::current().read(token.token()).caller_ctx() }; - let len = payload.len() / mem::size_of::(); + let len = payload.len() / size_of::(); let res = inner.call( ctx, Vec::new(), diff --git a/src/startup/memory.rs b/src/startup/memory.rs index 298760f3c8..26922dde0a 100644 --- a/src/startup/memory.rs +++ b/src/startup/memory.rs @@ -6,7 +6,6 @@ use crate::{ use core::{ cell::SyncUnsafeCell, cmp::{max, min}, - mem, slice::{self, Iter}, }; use rmm::{ @@ -184,7 +183,7 @@ fn register_bootloader_areas(areas_base: usize, areas_size: usize) { let bootloader_areas = unsafe { slice::from_raw_parts( areas_base as *const BootloaderMemoryEntry, - areas_size / mem::size_of::(), + areas_size / size_of::(), ) }; for bootloader_area in bootloader_areas.iter() { diff --git a/src/sync/wait_queue.rs b/src/sync/wait_queue.rs index 3071bab004..b049ef7849 100644 --- a/src/sync/wait_queue.rs +++ b/src/sync/wait_queue.rs @@ -46,7 +46,7 @@ impl WaitQueue { continue; } else if buf.is_empty() { return Ok(0); - } else if buf.len() < core::mem::size_of::() { + } else if buf.len() < size_of::() { return Err(Error::new(EINVAL)); } else { // TODO: EWOULDBLOCK? @@ -55,12 +55,10 @@ impl WaitQueue { } let (s1, s2) = inner.as_slices(); - let s1_bytes = unsafe { - core::slice::from_raw_parts(s1.as_ptr().cast::(), core::mem::size_of_val(s1)) - }; - let s2_bytes = unsafe { - core::slice::from_raw_parts(s2.as_ptr().cast::(), core::mem::size_of_val(s2)) - }; + let s1_bytes = + unsafe { core::slice::from_raw_parts(s1.as_ptr().cast::(), size_of_val(s1)) }; + let s2_bytes = + unsafe { core::slice::from_raw_parts(s2.as_ptr().cast::(), size_of_val(s2)) }; let mut bytes_copied = buf.copy_common_bytes_from_slice(s1_bytes)?; @@ -68,7 +66,7 @@ impl WaitQueue { bytes_copied += buf_for_s2.copy_common_bytes_from_slice(s2_bytes)?; } - let _ = inner.drain(..bytes_copied / core::mem::size_of::()); + let _ = inner.drain(..bytes_copied / size_of::()); return Ok(bytes_copied); } diff --git a/src/syscall/debug.rs b/src/syscall/debug.rs index 112fbabf6e..853974d95b 100644 --- a/src/syscall/debug.rs +++ b/src/syscall/debug.rs @@ -1,5 +1,5 @@ use alloc::{borrow::ToOwned, string::String, vec::Vec}; -use core::{ascii, fmt::Debug, mem}; +use core::{ascii, fmt::Debug}; use super::{ copy_path_to_buf, @@ -38,7 +38,7 @@ fn debug_buf(ptr: usize, len: usize) -> Result> { }) } unsafe fn read_struct(ptr: usize) -> Result { - unsafe { UserSlice::ro(ptr, mem::size_of::()).and_then(|slice| slice.read_exact::()) } + unsafe { UserSlice::ro(ptr, size_of::()).and_then(|slice| slice.read_exact::()) } } //TODO: calling format_call with arguments from another process space will not work @@ -144,7 +144,7 @@ pub fn format_call(a: usize, b: usize, c: usize, d: usize, e: usize, f: usize, g let mut times = vec![unsafe { buf.read_exact::()? }]; // One or two timespecs - if let Some(second) = buf.advance(mem::size_of::()) { + if let Some(second) = buf.advance(size_of::()) { times.push(unsafe { second.read_exact::()? }); } Ok(times) diff --git a/src/syscall/fs.rs b/src/syscall/fs.rs index 37ae57645d..bf984641f4 100644 --- a/src/syscall/fs.rs +++ b/src/syscall/fs.rs @@ -1,6 +1,6 @@ //! Filesystem syscalls -use core::{mem::size_of, num::NonZeroUsize}; +use core::num::NonZeroUsize; use alloc::{string::String, sync::Arc, vec::Vec}; use redox_path::RedoxPath; diff --git a/src/syscall/futex.rs b/src/syscall/futex.rs index e9f1e5f737..4c187b8ec8 100644 --- a/src/syscall/futex.rs +++ b/src/syscall/futex.rs @@ -54,7 +54,7 @@ static FUTEXES: Mutex = fn validate_and_translate_virt(space: &AddrSpace, addr: VirtualAddress) -> Option { // TODO: Move this elsewhere! - if addr.data().saturating_add(core::mem::size_of::()) >= crate::USER_END_OFFSET { + if addr.data().saturating_add(size_of::()) >= crate::USER_END_OFFSET { return None; } @@ -87,7 +87,7 @@ pub fn futex( match op { // TODO: FUTEX_WAIT_MULTIPLE? FUTEX_WAIT | FUTEX_WAIT64 => { - let timeout_opt = UserSlice::ro(val2, core::mem::size_of::())? + let timeout_opt = UserSlice::ro(val2, size_of::())? .none_if_null() .map(|buf| unsafe { buf.read_exact::() }) .transpose()?; diff --git a/src/syscall/mod.rs b/src/syscall/mod.rs index e33331ea77..450a9d112f 100644 --- a/src/syscall/mod.rs +++ b/src/syscall/mod.rs @@ -4,8 +4,6 @@ extern crate syscall; -use core::mem::size_of; - use syscall::{dirent::DirentHeader, CallFlags, RwFlags, EINVAL}; pub use self::syscall::{ @@ -223,17 +221,14 @@ pub fn syscall( } SYS_YIELD => sched_yield(token).map(|()| 0), SYS_NANOSLEEP => nanosleep( - UserSlice::ro(b, core::mem::size_of::())?, - UserSlice::wo(c, core::mem::size_of::())?.none_if_null(), - token, - ) - .map(|()| 0), - SYS_CLOCK_GETTIME => clock_gettime( - b, - UserSlice::wo(c, core::mem::size_of::())?, + UserSlice::ro(b, size_of::())?, + UserSlice::wo(c, size_of::())?.none_if_null(), token, ) .map(|()| 0), + SYS_CLOCK_GETTIME => { + clock_gettime(b, UserSlice::wo(c, size_of::())?, token).map(|()| 0) + } SYS_FUTEX => futex(b, c, d, e, f, token), SYS_MPROTECT => mprotect(b, c, MapFlags::from_bits_truncate(d), token).map(|()| 0), diff --git a/src/syscall/process.rs b/src/syscall/process.rs index 477a20dbb1..b762b18236 100644 --- a/src/syscall/process.rs +++ b/src/syscall/process.rs @@ -204,7 +204,7 @@ pub unsafe fn usermode_bootstrap(bootstrap: &Bootstrap, token: &mut CleanLockTok .expect("Failed to allocate kernel scheme info page"); let mut cursor = kernel_schemes_info_page.start_address().data(); - const HEADER_SIZE: usize = mem::size_of::(); + const HEADER_SIZE: usize = size_of::(); UserSliceWo::new(cursor, HEADER_SIZE) .expect("failed to create kernel schemes header user slice") .copy_common_bytes_from_slice(&KERNEL_SCHEMES_COUNT.to_ne_bytes()) @@ -213,18 +213,18 @@ pub unsafe fn usermode_bootstrap(bootstrap: &Bootstrap, token: &mut CleanLockTok let info_bytes = unsafe { core::slice::from_raw_parts( kernel_schemes_infos.as_ptr() as *const u8, - KERNEL_SCHEMES_COUNT * mem::size_of::(), + KERNEL_SCHEMES_COUNT * size_of::(), ) }; UserSliceWo::new( cursor, - KERNEL_SCHEMES_COUNT * mem::size_of::(), + KERNEL_SCHEMES_COUNT * size_of::(), ) .expect("failed to create kernel schemes info user slice") .copy_common_bytes_from_slice(info_bytes) .expect("failed to copy kernel schemes info"); - cursor += KERNEL_SCHEMES_COUNT * mem::size_of::(); - UserSliceWo::new(cursor, mem::size_of::()) + cursor += KERNEL_SCHEMES_COUNT * size_of::(); + UserSliceWo::new(cursor, size_of::()) .expect("failed to create scheme creation cap user slice") .copy_common_bytes_from_slice(&scheme_creation_cap.to_ne_bytes()) .expect("failed to copy scheme creation cap"); diff --git a/src/syscall/usercopy.rs b/src/syscall/usercopy.rs index 1d02605ad1..b32925238a 100644 --- a/src/syscall/usercopy.rs +++ b/src/syscall/usercopy.rs @@ -109,13 +109,10 @@ impl UserSlice { pub unsafe fn read_exact(self) -> Result { let mut t: T = unsafe { core::mem::zeroed() }; let slice = unsafe { - core::slice::from_raw_parts_mut( - (&mut t as *mut T).cast::(), - core::mem::size_of::(), - ) + core::slice::from_raw_parts_mut((&mut t as *mut T).cast::(), size_of::()) }; - self.limit(core::mem::size_of::()) + self.limit(size_of::()) .ok_or(Error::new(EINVAL))? .copy_to_slice(slice)?; @@ -131,7 +128,7 @@ impl UserSlice { // TODO: Merge int IO functions? pub fn read_usize(self) -> Result { let mut ret = 0_usize.to_ne_bytes(); - self.limit(core::mem::size_of::()) + self.limit(size_of::()) .ok_or(Error::new(EINVAL))? .copy_to_slice(&mut ret)?; Ok(usize::from_ne_bytes(ret)) @@ -144,7 +141,7 @@ impl UserSlice { Ok(u32::from_ne_bytes(ret)) } pub fn usizes(self) -> impl Iterator> { - self.in_exact_chunks(core::mem::size_of::()) + self.in_exact_chunks(size_of::()) .map(Self::read_usize) } } @@ -177,13 +174,13 @@ impl UserSlice { Ok(()) } pub fn write_usize(self, word: usize) -> Result<()> { - self.limit(core::mem::size_of::()) + self.limit(size_of::()) .ok_or(Error::new(EINVAL))? .copy_from_slice(&word.to_ne_bytes())?; Ok(()) } pub fn write_u32(self, int: u32) -> Result<()> { - self.limit(core::mem::size_of::()) + self.limit(size_of::()) .ok_or(Error::new(EINVAL))? .copy_from_slice(&int.to_ne_bytes())?; Ok(())