Merge pull request #1490 from hermit-os/clippy

fix: enable more Clippy lints

Author: mkroening

Cargo.toml

@@ -70,6 +70,33 @@ udp = ["smoltcp", "smoltcp/socket-udp"]
 vga = []
 vsock = ["pci"]
 
+[lints.rust]
+rust_2018_idioms = "warn"
+unsafe_op_in_unsafe_fn = "warn"
+
+[lints.clippy]
+borrow_as_ptr = "warn"
+cast_lossless = "warn"
+decimal_literal_representation = "warn"
+default_trait_access = "warn"
+explicit_deref_methods = "warn"
+if_not_else = "warn"
+ignored_unit_patterns = "warn"
+inconsistent_struct_constructor = "warn"
+manual_assert = "warn"
+manual_let_else = "warn"
+match_wildcard_for_single_variants = "warn"
+ptr_as_ptr = "warn"
+ptr_cast_constness = "warn"
+ref_as_ptr = "warn"
+ref_option = "warn"
+semicolon_if_nothing_returned = "warn"
+separated_literal_suffix = "warn"
+string_to_string = "warn"
+transmute_ptr_to_ptr = "warn"
+uninlined_format_args = "warn"
+unreadable_literal = "warn"
+
 [dependencies]
 hermit-macro = { path = "hermit-macro" }
 virtio = { package = "virtio-spec", version = "0.2", features = ["alloc", "mmio", "nightly", "zerocopy"] }

rustfmt.toml

@@ -1,3 +1,4 @@
 group_imports = "StdExternalCrate"
 hard_tabs = true
+hex_literal_case = "Lower"
 imports_granularity = "Module"

src/arch/aarch64/kernel/interrupts.rs

@@ -175,11 +175,11 @@ pub(crate) extern "C" fn do_sync(state: &State) {
 	let irqid = GicV3::get_and_acknowledge_interrupt().unwrap();
 	let esr = ESR_EL1.get();
 	let ec = esr >> 26;
-	let iss = esr & 0xFFFFFF;
+	let iss = esr & 0x00ff_ffff;
 	let pc = ELR_EL1.get();
 
 	/* data abort from lower or current level */
-	if (ec == 0b100100) || (ec == 0b100101) {
+	if (ec == 0b10_0100) || (ec == 0b10_0101) {
 		/* check if value in far_el1 is valid */
 		if (iss & (1 << 10)) == 0 {
 			/* read far_el1 register, which holds the faulting virtual address */

src/arch/aarch64/kernel/mod.rs

@@ -23,7 +23,7 @@ use crate::arch::aarch64::kernel::core_local::*;
 use crate::arch::aarch64::kernel::serial::SerialPort;
 use crate::env;
 
-const SERIAL_PORT_BAUDRATE: u32 = 115200;
+const SERIAL_PORT_BAUDRATE: u32 = 115_200;
 
 static COM1: SpinMutex<SerialPort> = SpinMutex::new(SerialPort::new(0x800));
 

src/arch/aarch64/kernel/pci.rs

@@ -24,17 +24,20 @@ pub(crate) struct PciConfigRegion(VirtAddr);
 
 impl PciConfigRegion {
 	pub const fn new(addr: VirtAddr) -> Self {
-		assert!(addr.as_u64() & 0xFFFFFFF == 0, "Unaligned PCI Config Space");
+		assert!(
+			addr.as_u64() & 0x0fff_ffff == 0,
+			"Unaligned PCI Config Space"
+		);
 		Self(addr)
 	}
 
 	#[inline]
 	fn addr_from_offset(&self, pci_addr: PciAddress, offset: u16) -> usize {
-		assert!(offset & 0xF000 == 0, "Invalid offset");
+		assert!(offset & 0xf000 == 0, "Invalid offset");
 		(u64::from(pci_addr.bus()) << 20
 			| u64::from(pci_addr.device()) << 15
 			| u64::from(pci_addr.function()) << 12
-			| (u64::from(offset) & 0xFFF)
+			| (u64::from(offset) & 0xfff)
 			| self.0.as_u64()) as usize
 	}
 }
@@ -246,7 +249,7 @@ pub fn init() {
 				let size = u64::from_be_bytes(slice.try_into().unwrap());
 
 				let pci_address =
-					virtualmem::allocate_aligned(size.try_into().unwrap(), 0x10000000).unwrap();
+					virtualmem::allocate_aligned(size.try_into().unwrap(), 0x1000_0000).unwrap();
 				info!("Mapping PCI Enhanced Configuration Space interface to virtual address {:p} (size {:#X})", pci_address, size);
 
 				let mut flags = PageTableEntryFlags::empty();
@@ -268,8 +271,8 @@ pub fn init() {
 				assert!(mem64_start > 0);
 
 				let max_bus_number = size
-					/ (PCI_MAX_DEVICE_NUMBER as u64
-						* PCI_MAX_FUNCTION_NUMBER as u64
+					/ (u64::from(PCI_MAX_DEVICE_NUMBER)
+						* u64::from(PCI_MAX_FUNCTION_NUMBER)
 						* BasePageSize::SIZE);
 				info!("Scanning PCI Busses 0 to {}", max_bus_number - 1);
 
@@ -299,12 +302,12 @@ pub fn init() {
 											cmd |= CommandRegister::IO_ENABLE
 												| CommandRegister::BUS_MASTER_ENABLE;
 										}
-										// Currently, we ignore 32 bit memory bars
-										/*Bar::Memory32 { address, size, prefetchable } => {
-											dev.set_bar(i.try_into().unwrap(), Bar::Memory32 { address: mem32_start.try_into().unwrap(), size,  prefetchable });
-											mem32_start += u64::from(size);
-											cmd |= CommandRegister::MEMORY_ENABLE | CommandRegister::BUS_MASTER_ENABLE;
-										}*/
+										Bar::Memory32 { .. } => {
+											// Currently, we ignore 32 bit memory bars
+											// dev.set_bar(i.try_into().unwrap(), Bar::Memory32 { address: mem32_start.try_into().unwrap(), size,  prefetchable });
+											// mem32_start += u64::from(size);
+											// cmd |= CommandRegister::MEMORY_ENABLE | CommandRegister::BUS_MASTER_ENABLE;
+										}
 										Bar::Memory64 {
 											address: _,
 											size,
@@ -322,7 +325,6 @@ pub fn init() {
 											cmd |= CommandRegister::MEMORY_ENABLE
 												| CommandRegister::BUS_MASTER_ENABLE;
 										}
-										_ => {}
 									}
 								}
 							}

src/arch/aarch64/kernel/processor.rs

@@ -27,7 +27,9 @@ impl fmt::Display for CpuFrequencySources {
 		match &self {
 			CpuFrequencySources::CommandLine => write!(f, "Command Line"),
 			CpuFrequencySources::Register => write!(f, "CNTFRQ_EL0"),
-			_ => panic!("Attempted to print an invalid CPU Frequency Source"),
+			CpuFrequencySources::Invalid => {
+				panic!("Attempted to print an invalid CPU Frequency Source")
+			}
 		}
 	}
 }
@@ -63,11 +65,14 @@ impl CpuFrequency {
 
 	unsafe fn detect_from_cmdline(&mut self) -> Result<(), ()> {
 		let mhz = env::freq().ok_or(())?;
-		self.set_detected_cpu_frequency(u32::from(mhz) * 1000000, CpuFrequencySources::CommandLine)
+		self.set_detected_cpu_frequency(
+			u32::from(mhz) * 1_000_000,
+			CpuFrequencySources::CommandLine,
+		)
 	}
 
 	unsafe fn detect_from_register(&mut self) -> Result<(), ()> {
-		let hz = CNTFRQ_EL0.get() & 0xFFFFFFFF;
+		let hz = CNTFRQ_EL0.get() & 0xffff_ffff;
 		self.set_detected_cpu_frequency(hz.try_into().unwrap(), CpuFrequencySources::Register)
 	}
 
@@ -115,7 +120,7 @@ pub fn shutdown(error_code: i32) -> ! {
 			semihosting::process::exit(error_code)
 		} else {
 			unsafe {
-				const PSCI_SYSTEM_OFF: u64 = 0x84000008;
+				const PSCI_SYSTEM_OFF: u64 = 0x8400_0008;
 				// call hypervisor to shut down the system
 				asm!("hvc #0", in("x0") PSCI_SYSTEM_OFF, options(nomem, nostack));
 
@@ -132,13 +137,13 @@ pub fn shutdown(error_code: i32) -> ! {
 pub fn get_timer_ticks() -> u64 {
 	// We simulate a timer with a 1 microsecond resolution by taking the CPU timestamp
 	// and dividing it by the CPU frequency in MHz.
-	let ticks = 1000000 * u128::from(get_timestamp()) / u128::from(CPU_FREQUENCY.get());
+	let ticks = 1_000_000 * u128::from(get_timestamp()) / u128::from(CPU_FREQUENCY.get());
 	u64::try_from(ticks).unwrap()
 }
 
 #[inline]
 pub fn get_frequency() -> u16 {
-	(CPU_FREQUENCY.get() / 1000000).try_into().unwrap()
+	(CPU_FREQUENCY.get() / 1_000_000).try_into().unwrap()
 }
 
 #[inline]
@@ -219,7 +224,7 @@ pub fn detect_frequency() {
 fn __set_oneshot_timer(wakeup_time: Option<u64>) {
 	if let Some(wt) = wakeup_time {
 		// wt is the absolute wakeup time in microseconds based on processor::get_timer_ticks.
-		let deadline = u128::from(wt) * u128::from(CPU_FREQUENCY.get()) / 1000000;
+		let deadline = u128::from(wt) * u128::from(CPU_FREQUENCY.get()) / 1_000_000;
 		let deadline = u64::try_from(deadline).unwrap();
 
 		unsafe {

src/arch/aarch64/kernel/scheduler.rs

@@ -354,7 +354,7 @@ impl TaskFrame for Task {
 			// Set a marker for debugging at the very top.
 			let mut stack = self.stacks.get_kernel_stack() + self.stacks.get_kernel_stack_size()
 				- TaskStacks::MARKER_SIZE;
-			*stack.as_mut_ptr::<u64>() = 0xDEAD_BEEFu64;
+			*stack.as_mut_ptr::<u64>() = 0xdead_beefu64;
 
 			// Put the State structure expected by the ASM switch() function on the stack.
 			stack -= mem::size_of::<State>();
@@ -374,7 +374,7 @@ impl TaskFrame for Task {
 			(*state).spsel = 1;
 
 			/* Zero the condition flags. */
-			(*state).spsr_el1 = 0x3E5;
+			(*state).spsr_el1 = 0x3e5;
 
 			// Set the task's stack pointer entry to the stack we have just crafted.
 			self.last_stack_pointer = stack;
@@ -383,7 +383,7 @@ impl TaskFrame for Task {
 			self.user_stack_pointer = self.stacks.get_user_stack()
 				+ self.stacks.get_user_stack_size()
 				- TaskStacks::MARKER_SIZE;
-			*self.user_stack_pointer.as_mut_ptr::<u64>() = 0xDEAD_BEEFu64;
+			*self.user_stack_pointer.as_mut_ptr::<u64>() = 0xdead_beefu64;
 			(*state).sp_el0 = self.user_stack_pointer.as_u64();
 		}
 	}

src/arch/aarch64/kernel/start.rs

@@ -75,7 +75,7 @@ unsafe extern "C" fn pre_init(boot_info: Option<&'static RawBootInfo>, cpu_id: u
 		{
 			error!("SMP support deactivated");
 			loop {
-				crate::arch::processor::halt()
+				crate::arch::processor::halt();
 			}
 		}
 		#[cfg(feature = "smp")]

src/arch/aarch64/kernel/switch.rs

@@ -12,10 +12,10 @@ macro_rules! kernel_function_impl {
 				$(
 					assert!(mem::size_of::<$A>() <= mem::size_of::<usize>());
 					let $arg = {
-						let mut reg = 0_usize;
+						let mut reg = 0usize;
 						// SAFETY: $A is smaller than usize and directly fits in a register
 						// Since f takes $A as argument via C calling convention, any upper bytes do not matter.
-						ptr::write(ptr::from_mut(&mut reg) as _, $arg);
+						ptr::write(ptr::from_mut(&mut reg).cast(), $arg);
 						reg
 					};
 				)*

src/arch/aarch64/kernel/systemtime.rs

@@ -84,7 +84,7 @@ pub fn init() {
 				);
 
 				let boot_time =
-					OffsetDateTime::from_unix_timestamp(rtc_read(RTC_DR) as i64).unwrap();
+					OffsetDateTime::from_unix_timestamp(rtc_read(RTC_DR).into()).unwrap();
 				info!("Hermit booted on {boot_time}");
 
 				let micros = u64::try_from(boot_time.unix_timestamp_nanos() / 1000).unwrap();