Merge pull request #1658 from hermit-os/release-0.11.0

chore: release version 0.11.0

Author: mkroening

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "hermit-kernel"
-version = "0.10.0"
+version = "0.11.0"
 authors = [
 	"Stefan Lankes <[email protected]>",
 	"Colin Finck <[email protected]>",

Cargo.toml

@@ -120,7 +120,7 @@ pub(crate) extern "C" fn do_fiq(_state: &State) -> *mut usize {
 	if let Some(irqid) = GicV3::get_and_acknowledge_interrupt() {
 		let vector: u8 = u32::from(irqid).try_into().unwrap();
 
-		debug!("Receive fiq {}", vector);
+		debug!("Receive fiq {vector}");
 		increment_irq_counter(vector);
 
 		if let Some(handlers) = INTERRUPT_HANDLERS.get() {
@@ -148,7 +148,7 @@ pub(crate) extern "C" fn do_irq(_state: &State) -> *mut usize {
 	if let Some(irqid) = GicV3::get_and_acknowledge_interrupt() {
 		let vector: u8 = u32::from(irqid).try_into().unwrap();
 
-		debug!("Receive interrupt {}", vector);
+		debug!("Receive interrupt {vector}");
 		increment_irq_counter(vector);
 
 		if let Some(handlers) = INTERRUPT_HANDLERS.get() {
@@ -189,27 +189,27 @@ pub(crate) extern "C" fn do_sync(state: &State) {
 			// add page fault handler
 
 			error!("Current stack pointer {state:p}");
-			error!("Unable to handle page fault at {:#x}", far);
+			error!("Unable to handle page fault at {far:#x}");
 			error!("Exception return address {:#x}", ELR_EL1.get());
 			error!("Thread ID register {:#x}", TPIDR_EL0.get());
 			error!("Table Base Register {:#x}", TTBR0_EL1.get());
-			error!("Exception Syndrome Register {:#x}", esr);
+			error!("Exception Syndrome Register {esr:#x}");
 
 			GicV3::end_interrupt(irqid);
 			scheduler::abort()
 		} else {
 			error!("Unknown exception");
 		}
 	} else if ec == 0x3c {
-		error!("Trap to debugger, PC={:#x}", pc);
+		error!("Trap to debugger, PC={pc:#x}");
 	} else {
-		error!("Unsupported exception class: {:#x}, PC={:#x}", ec, pc);
+		error!("Unsupported exception class: {ec:#x}, PC={pc:#x}");
 	}
 }
 
 #[unsafe(no_mangle)]
 pub(crate) extern "C" fn do_bad_mode(_state: &State, reason: u32) -> ! {
-	error!("Receive unhandled exception: {}", reason);
+	error!("Receive unhandled exception: {reason}");
 
 	scheduler::abort()
 }
@@ -257,13 +257,9 @@ pub(crate) fn init() {
 	let cpu_id = core_id();
 
 	info!("Found {num_cpus} cpus!");
+	info!("Found GIC Distributor interface at {gicd_start:p} (size {gicd_size:#X})");
 	info!(
-		"Found GIC Distributor interface at {:p} (size {:#X})",
-		gicd_start, gicd_size
-	);
-	info!(
-		"Found generic interrupt controller redistributor at {:p} (size {:#X}, stride {:#X})",
-		gicr_start, gicr_size, gicr_stride
+		"Found generic interrupt controller redistributor at {gicr_start:p} (size {gicr_size:#X}, stride {gicr_stride:#X})"
 	);
 
 	let gicd_address =
@@ -323,10 +319,7 @@ pub(crate) fn init() {
 					TIMER_INTERRUPT = irq;
 				}
 
-				debug!(
-					"Timer interrupt: {}, type {}, flags {}",
-					irq, irqtype, irqflags
-				);
+				debug!("Timer interrupt: {irq}, type {irqtype}, flags {irqflags}");
 
 				IRQ_NAMES
 					.lock()
@@ -366,7 +359,7 @@ static IRQ_NAMES: InterruptTicketMutex<HashMap<u8, &'static str, RandomState>> =
 
 #[allow(dead_code)]
 pub(crate) fn add_irq_name(irq_number: u8, name: &'static str) {
-	debug!("Register name \"{}\"  for interrupt {}", name, irq_number);
+	debug!("Register name \"{name}\"  for interrupt {irq_number}");
 	IRQ_NAMES.lock().insert(SPI_START + irq_number, name);
 }
 

src/arch/aarch64/kernel/interrupts.rs

@@ -89,7 +89,7 @@ fn detect_pci_regions(dtb: &Dtb<'_>, parts: &[&str]) -> (u64, u64, u64) {
 			}
 			0b10 => {
 				let prefetchable = high.get_bit(30);
-				debug!("32 bit memory space: prefetchable {}", prefetchable);
+				debug!("32 bit memory space: prefetchable {prefetchable}");
 				if mem32_start != 0 {
 					warn!("Found already 32 bit memory space");
 				}
@@ -100,7 +100,7 @@ fn detect_pci_regions(dtb: &Dtb<'_>, parts: &[&str]) -> (u64, u64, u64) {
 			}
 			0b11 => {
 				let prefetchable = high.get_bit(30);
-				debug!("64 bit memory space: prefetchable {}", prefetchable);
+				debug!("64 bit memory space: prefetchable {prefetchable}");
 				if mem64_start != 0 {
 					warn!("Found already 64 bit memory space");
 				}
@@ -194,10 +194,7 @@ fn detect_interrupt(
 		(value_slice, residual_slice) = residual_slice.split_at(core::mem::size_of::<u32>());
 		let irq_flags = u32::from_be_bytes(value_slice.try_into().unwrap());
 
-		trace!(
-			"Interrupt type {:#x}, number {:#x} flags {:#x}",
-			irq_type, irq_number, irq_flags
-		);
+		trace!("Interrupt type {irq_type:#x}, number {irq_number:#x} flags {irq_flags:#x}");
 
 		if high.get_bits(0..24) == addr {
 			pin += 1;
@@ -250,8 +247,7 @@ pub fn init() {
 				let pci_address =
 					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
+					"Mapping PCI Enhanced Configuration Space interface to virtual address {pci_address:p} (size {size:#X})"
 				);
 
 				let mut flags = PageTableEntryFlags::empty();
@@ -265,9 +261,9 @@ pub fn init() {
 
 				let (mut io_start, mem32_start, mut mem64_start) = detect_pci_regions(&dtb, &parts);
 
-				debug!("IO address space starts at{:#X}", io_start);
-				debug!("Memory32 address space starts at {:#X}", mem32_start);
-				debug!("Memory64 address space starts {:#X}", mem64_start);
+				debug!("IO address space starts at{io_start:#X}");
+				debug!("Memory32 address space starts at {mem32_start:#X}");
+				debug!("Memory64 address space starts {mem64_start:#X}");
 				assert!(io_start > 0);
 				assert!(mem32_start > 0);
 				assert!(mem64_start > 0);
@@ -339,8 +335,7 @@ pub fn init() {
 								&parts,
 							) {
 								debug!(
-									"Initialize interrupt pin {} and line {} for device {}",
-									pin, line, device_id
+									"Initialize interrupt pin {pin} and line {line} for device {device_id}"
 								);
 								dev.set_irq(pin, line);
 							}

src/arch/aarch64/kernel/pci.rs

@@ -203,10 +203,7 @@ pub fn configure() {
 			out(reg) pmcr_el0,
 			options(nostack, nomem),
 		);
-		debug!(
-			"PMCR_EL0 (has RES1 bits and therefore mustn't be zero): {:#X}",
-			pmcr_el0
-		);
+		debug!("PMCR_EL0 (has RES1 bits and therefore mustn't be zero): {pmcr_el0:#X}");
 		pmcr_el0 |= (1 << 0) | (1 << 2) | (1 << 6);
 		asm!(
 			"msr pmcr_el0, {}",

src/arch/aarch64/kernel/processor.rs

@@ -181,7 +181,7 @@ impl TaskStacks {
 
 	pub fn from_boot_stacks() -> TaskStacks {
 		let stack = VirtAddr::new(CURRENT_STACK_ADDRESS.load(Ordering::Relaxed));
-		debug!("Using boot stack {:p}", stack);
+		debug!("Using boot stack {stack:p}");
 
 		TaskStacks::Boot(BootStack { stack })
 	}
@@ -327,7 +327,7 @@ extern "C" fn task_start(_f: extern "C" fn(usize), _arg: usize, _user_stack: u64
 
 #[cfg(target_os = "none")]
 extern "C" fn thread_exit(status: i32) -> ! {
-	debug!("Exit thread with error code {}!", status);
+	debug!("Exit thread with error code {status}!");
 	core_scheduler().exit(status)
 }
 

src/arch/aarch64/kernel/scheduler.rs

@@ -64,7 +64,7 @@ pub fn init() {
 				let (slice, _residual_slice) = residual_slice.split_at(core::mem::size_of::<u64>());
 				let size = u64::from_be_bytes(slice.try_into().unwrap());
 
-				debug!("Found RTC at {:p} (size {:#X})", addr, size);
+				debug!("Found RTC at {addr:p} (size {size:#X})");
 
 				let pl031_address = virtualmem::allocate_aligned(
 					size.try_into().unwrap(),

src/arch/aarch64/kernel/systemtime.rs

@@ -550,15 +550,15 @@ fn get_page_range<S: PageSize>(virtual_address: VirtAddr, count: usize) -> PageI
 }
 
 pub fn get_page_table_entry<S: PageSize>(virtual_address: VirtAddr) -> Option<PageTableEntry> {
-	trace!("Looking up Page Table Entry for {:p}", virtual_address);
+	trace!("Looking up Page Table Entry for {virtual_address:p}");
 
 	let page = Page::<S>::including_address(virtual_address);
 	let root_pagetable = unsafe { &mut *(L0TABLE_ADDRESS.as_mut_ptr::<PageTable<L0Table>>()) };
 	root_pagetable.get_page_table_entry(page)
 }
 
 pub fn get_physical_address<S: PageSize>(virtual_address: VirtAddr) -> Option<PhysAddr> {
-	trace!("Getting physical address for {:p}", virtual_address);
+	trace!("Getting physical address for {virtual_address:p}");
 
 	let page = Page::<S>::including_address(virtual_address);
 	let root_pagetable = unsafe { &mut *(L0TABLE_ADDRESS.as_mut_ptr::<PageTable<L0Table>>()) };
@@ -586,8 +586,7 @@ pub fn map<S: PageSize>(
 	flags: PageTableEntryFlags,
 ) {
 	trace!(
-		"Mapping virtual address {:p} to physical address {:p} ({} pages)",
-		virtual_address, physical_address, count
+		"Mapping virtual address {virtual_address:p} to physical address {physical_address:p} ({count} pages)"
 	);
 
 	let range = get_page_range::<S>(virtual_address, count);
@@ -616,10 +615,7 @@ pub fn map_heap<S: PageSize>(virt_addr: VirtAddr, count: usize) -> Result<(), us
 }
 
 pub fn unmap<S: PageSize>(virtual_address: VirtAddr, count: usize) {
-	trace!(
-		"Unmapping virtual address {:p} ({} pages)",
-		virtual_address, count
-	);
+	trace!("Unmapping virtual address {virtual_address:p} ({count} pages)");
 
 	let range = get_page_range::<S>(virtual_address, count);
 	let root_pagetable = unsafe { &mut *(L0TABLE_ADDRESS.as_mut_ptr::<PageTable<L0Table>>()) };
@@ -635,7 +631,7 @@ pub unsafe fn init() {
 	let aa64mmfr0: u64;
 
 	let ram_start = get_ram_address();
-	info!("RAM starts at physical address {:p}", ram_start);
+	info!("RAM starts at physical address {ram_start:p}");
 
 	// determine physical address size
 	unsafe {

src/arch/aarch64/mm/paging.rs

@@ -58,7 +58,7 @@ pub fn init() {
 				warn!("Unknown platform, guessing PLIC context 1");
 				PLATFORM_MODEL = Model::Unknown;
 			}
-			info!("Model: {}", model);
+			info!("Model: {model}");
 		}
 	}
 }
@@ -122,7 +122,7 @@ pub fn init_drivers() {
 					.property("local-mac-address")
 					.expect("local-mac-address property for GEM not found in FDT")
 					.value;
-				debug!("Local MAC address: {:x?}", mac);
+				debug!("Local MAC address: {mac:x?}");
 				let mut phy_addr = u32::MAX;
 
 				let phy_node = gem_node
@@ -140,10 +140,7 @@ pub fn init_drivers() {
 				}
 
 				let gem_region_start = PhysAddr::new(gem_region.starting_address as u64);
-				debug!(
-					"Init GEM at {:p}, irq: {}, phy_addr: {}",
-					gem_region_start, irq, phy_addr
-				);
+				debug!("Init GEM at {gem_region_start:p}, irq: {irq}, phy_addr: {phy_addr}");
 				paging::identity_map::<paging::HugePageSize>(
 					AddrRange::new(
 						gem_region_start,
@@ -181,10 +178,7 @@ pub fn init_drivers() {
 
 				let virtio_region_start = PhysAddr::new(virtio_region.starting_address as u64);
 
-				debug!(
-					"Init virtio_mmio at {:p}, irq: {}",
-					virtio_region_start, irq
-				);
+				debug!("Init virtio_mmio at {virtio_region_start:p}, irq: {irq}");
 				paging::identity_map::<paging::HugePageSize>(
 					AddrRange::new(
 						virtio_region_start,

src/arch/riscv64/kernel/devicetree.rs

@@ -56,7 +56,7 @@ static IRQ_NAMES: InterruptTicketMutex<HashMap<u8, &'static str, RandomState>> =
 
 #[allow(dead_code)]
 pub(crate) fn add_irq_name(irq_number: u8, name: &'static str) {
-	debug!("Register name \"{}\"  for interrupt {}", name, irq_number);
+	debug!("Register name \"{name}\"  for interrupt {irq_number}");
 	IRQ_NAMES.lock().insert(irq_number, name);
 }
 
@@ -102,7 +102,7 @@ pub(crate) fn enable_and_wait() {
 				// // Disable Supervisor-level software interrupt, wakeup not needed
 				// sie::clear_ssoft();
 
-				debug!("sip: {:x?}", pending_interrupts);
+				debug!("sip: {pending_interrupts:x?}");
 				trace!("TIMER");
 				crate::arch::riscv64::kernel::scheduler::timer_handler();
 				break;
@@ -138,7 +138,7 @@ pub(crate) fn install_handlers() {
 				+ PLIC_ENABLE_OFFSET
 				+ 0x80 * (*context as usize)
 				+ ((*irq_number / 32) * 4) as usize;
-			debug!("enable_address {:x}", enable_address);
+			debug!("enable_address {enable_address:x}");
 			core::ptr::write_volatile(enable_address as *mut u32, 1 << (irq_number % 32));
 		}
 	}
@@ -196,7 +196,7 @@ fn external_handler() {
 	let irq = unsafe { core::ptr::read_volatile(claim_address as *mut u32) };
 
 	if irq != 0 {
-		debug!("External INT: {}", irq);
+		debug!("External INT: {irq}");
 		let mut cur_int = CURRENT_INTERRUPTS.lock();
 		cur_int.push(irq);
 		if cur_int.len() > 1 {