Merge branch 'main' into allocator-abstraction

Author: m-mueller678

src/arch/x86_64/kernel/apic.rs

@@ -460,15 +460,15 @@ fn detect_from_mp() -> Result<PhysAddr, ()> {
 		(virtual_address | (u64::from(mp_float.mp_config) & (BasePageSize::SIZE - 1))) as usize;
 	let mp_config: &ApicConfigTable = unsafe { &*(ptr::with_exposed_provenance(addr)) };
 	if mp_config.signature != MP_CONFIG_SIGNATURE {
-		warn!("Invalid MP config table");
+		warn!("MP config table invalid!");
 		unsafe {
 			deallocate_virtual(virtual_address, BasePageSize::SIZE as usize);
 		}
 		return Err(());
 	}
 
 	if mp_config.entry_count == 0 {
-		warn!("No MP table entries! Guess IO-APIC!");
+		warn!("No MP table entries, guessing IOAPIC...");
 		let default_address = PhysAddr::new(0xfec0_0000);
 
 		init_ioapic_address(default_address);
@@ -490,7 +490,7 @@ fn detect_from_mp() -> Result<PhysAddr, ()> {
 				2 => {
 					let io_entry: &ApicIoEntry = unsafe { &*(ptr::with_exposed_provenance(addr)) };
 					let ioapic = PhysAddr::new(io_entry.addr.into());
-					info!("Found IOAPIC at 0x{ioapic:p}");
+					info!("IOAPIC found at {ioapic:p}");
 
 					init_ioapic_address(ioapic);
 
@@ -507,10 +507,10 @@ fn detect_from_mp() -> Result<PhysAddr, ()> {
 }
 
 fn default_apic() -> PhysAddr {
-	warn!("Try to use default APIC address");
-
 	let default_address = PhysAddr::new(0xfee0_0000);
 
+	warn!("Using default APIC address: {default_address:p}");
+
 	// currently, uhyve doesn't support an IO-APIC
 	if !env::is_uhyve() {
 		init_ioapic_address(default_address);
@@ -525,32 +525,30 @@ pub fn eoi() {
 
 pub fn init() {
 	// Detect CPUs and APICs.
-	let local_apic_physical_address = detect_from_acpi()
-		.or_else(|()| detect_from_mp())
-		.unwrap_or_else(|()| default_apic());
+	let local_apic_physical_address = if env::is_uhyve() {
+		default_apic()
+	} else {
+		detect_from_acpi()
+			.or_else(|()| detect_from_mp())
+			.unwrap_or_else(|()| default_apic())
+	};
 
 	// Initialize x2APIC or xAPIC, depending on what's available.
-	init_x2apic();
-	if !processor::supports_x2apic() {
+	if processor::supports_x2apic() {
+		init_x2apic();
+	} else if env::is_uefi() {
+		// already id mapped in UEFI systems, just use the physical address as virtual one
+		LOCAL_APIC_ADDRESS
+			.set(VirtAddr::new(local_apic_physical_address.as_u64()))
+			.unwrap();
+	} else {
 		// We use the traditional xAPIC mode available on all x86-64 CPUs.
 		// It uses a mapped page for communication.
-		if env::is_uefi() {
-			//already id mapped in UEFI systems, just use the physical address as virtual one
-			LOCAL_APIC_ADDRESS
-				.set(VirtAddr::new(local_apic_physical_address.as_u64()))
-				.unwrap();
-		} else {
-			let local_apic_address =
+		let local_apic_address =
 				allocate_virtual(BasePageSize::SIZE as usize, BasePageSize::SIZE as usize).unwrap();
-			LOCAL_APIC_ADDRESS.set(local_apic_address).unwrap();
-			debug!(
-				"Mapping Local APIC at {local_apic_physical_address:p} to virtual address {local_apic_address:p}"
-			);
-
-			let mut flags = PageTableEntryFlags::empty();
-			flags.device().writable().execute_disable();
-			paging::map::<BasePageSize>(local_apic_address, local_apic_physical_address, 1, flags);
-		}
+		let mut flags = PageTableEntryFlags::empty();
+		flags.device().writable().execute_disable();
+		paging::map::<BasePageSize>(local_apic_address, local_apic_physical_address, 1, flags);
 	}
 
 	// Set gates to ISRs for the APIC interrupts we are going to enable.
@@ -722,16 +720,14 @@ pub fn set_oneshot_timer(wakeup_time: Option<u64>) {
 }
 
 pub fn init_x2apic() {
-	if processor::supports_x2apic() {
-		debug!("Enable x2APIC support");
-		// The CPU supports the modern x2APIC mode, which uses MSRs for communication.
-		// Enable it.
-		let mut msr = IA32_APIC_BASE;
-		let mut apic_base = unsafe { msr.read() };
-		apic_base |= X2APIC_ENABLE;
-		unsafe {
-			msr.write(apic_base);
-		}
+	debug!("Enable x2APIC support");
+	// The CPU supports the modern x2APIC mode, which uses MSRs for communication.
+	// Enable it.
+	let mut msr = IA32_APIC_BASE;
+	let mut apic_base = unsafe { msr.read() };
+	apic_base |= X2APIC_ENABLE;
+	unsafe {
+		msr.write(apic_base);
 	}
 }
 

src/arch/x86_64/kernel/mod.rs

@@ -136,7 +136,9 @@ pub fn application_processor_init() {
 	processor::configure();
 	gdt::add_current_core();
 	interrupts::load_idt();
-	apic::init_x2apic();
+	if processor::supports_x2apic() {
+		apic::init_x2apic();
+	}
 	apic::init_local_apic();
 	debug!("Cr0 = {:?}", Cr0::read());
 	debug!("Cr4 = {:?}", Cr4::read());

src/executor/vsock.rs

@@ -1,4 +1,4 @@
-use alloc::collections::BTreeMap;
+use alloc::collections::{BTreeMap, btree_map};
 use alloc::vec::Vec;
 use core::future;
 use core::task::Poll;
@@ -170,10 +170,15 @@ impl VsockMap {
 	}
 
 	pub fn bind(&mut self, port: u32) -> io::Result<()> {
-		self.port_map
-			.try_insert(port, RawSocket::new(VsockState::Listen))
-			.map_err(|_| Errno::Addrinuse)?;
-		Ok(())
+		let entry = self.port_map.entry(port);
+
+		match entry {
+			btree_map::Entry::Vacant(vacant_entry) => {
+				vacant_entry.insert(RawSocket::new(VsockState::Listen));
+				Ok(())
+			}
+			btree_map::Entry::Occupied(_occupied_entry) => Err(Errno::Addrinuse),
+		}
 	}
 
 	pub fn connect(&mut self, port: u32, cid: u32) -> io::Result<u32> {
@@ -182,7 +187,8 @@ impl VsockMap {
 			raw.remote_cid = cid;
 			raw.remote_port = port;
 
-			if self.port_map.try_insert(i, raw).is_ok() {
+			if let btree_map::Entry::Vacant(vacant_entry) = self.port_map.entry(i) {
+				vacant_entry.insert(raw);
 				return Ok(i);
 			}
 		}

src/lib.rs

@@ -11,7 +11,6 @@
 #![feature(allocator_api)]
 #![feature(linkage)]
 #![feature(linked_list_cursors)]
-#![feature(map_try_insert)]
 #![feature(maybe_uninit_as_bytes)]
 #![feature(maybe_uninit_slice)]
 #![feature(maybe_uninit_write_slice)]

src/mm/allocator.rs

@@ -40,7 +40,6 @@
 //!                │   │               │   │
 //! ```
 
-pub(crate) mod allocator;
 pub(crate) mod device_alloc;
 pub(crate) mod physicalmem;
 pub(crate) mod virtualmem;
@@ -49,10 +48,11 @@ use core::mem;
 use core::ops::Range;
 
 use align_address::Align;
-use hermit_sync::Lazy;
+use free_list::{PageLayout, PageRange};
+use hermit_sync::{Lazy, RawInterruptTicketMutex};
 pub use memory_addresses::{PhysAddr, VirtAddr};
+use talc::{ErrOnOom, Span, Talc, Talck};
 
-use self::allocator::LockedAllocator;
 #[cfg(any(target_arch = "x86_64", target_arch = "riscv64"))]
 use crate::arch::mm::paging::HugePageSize;
 pub use crate::arch::mm::paging::virtual_to_physical;
@@ -63,7 +63,7 @@ use crate::{arch, env};
 
 #[cfg(target_os = "none")]
 #[global_allocator]
-pub(crate) static ALLOCATOR: LockedAllocator = LockedAllocator::new();
+pub(crate) static ALLOCATOR: Talck<RawInterruptTicketMutex, ErrOnOom> = Talc::new(ErrOnOom).lock();
 
 /// Physical and virtual address range of the 2 MiB pages that map the kernel.
 static KERNEL_ADDR_RANGE: Lazy<Range<VirtAddr>> = Lazy::new(|| {
@@ -271,11 +271,9 @@ pub(crate) fn init() {
 
 	let heap_end_addr = map_addr;
 
+	let arena = Span::new(heap_start_addr.as_mut_ptr(), heap_end_addr.as_mut_ptr());
 	unsafe {
-		ALLOCATOR.init(
-			heap_start_addr.as_mut_ptr(),
-			(heap_end_addr - heap_start_addr) as usize,
-		);
+		ALLOCATOR.lock().claim(arena).unwrap();
 	}
 
 	info!("Heap is located at {heap_start_addr:p}..{heap_end_addr:p} ({map_size} Bytes unmapped)");

src/mm/mod.rs

@@ -14,7 +14,7 @@ use core::sync::atomic::{AtomicI32, AtomicU32, Ordering};
 
 use ahash::RandomState;
 use crossbeam_utils::Backoff;
-use hashbrown::HashMap;
+use hashbrown::{HashMap, hash_map};
 use hermit_sync::*;
 #[cfg(target_arch = "riscv64")]
 use riscv::register::sstatus;
@@ -564,10 +564,12 @@ impl PerCoreScheduler {
 			};
 
 			let fd = new_fd()?;
-			if object_map.try_insert(fd, obj).is_err() {
-				Err(Errno::Mfile)
-			} else {
-				Ok(fd)
+			match object_map.entry(fd) {
+				hash_map::Entry::Occupied(_occupied_entry) => Err(Errno::Mfile),
+				hash_map::Entry::Vacant(vacant_entry) => {
+					vacant_entry.insert(obj);
+					Ok(fd)
+				}
 			}
 		})
 	}
@@ -583,10 +585,12 @@ impl PerCoreScheduler {
 
 			let obj = object_map.get(&fd1).cloned().ok_or(Errno::Badf)?;
 
-			if object_map.try_insert(fd2, obj).is_err() {
-				Err(Errno::Mfile)
-			} else {
-				Ok(fd2)
+			match object_map.entry(fd2) {
+				hash_map::Entry::Occupied(_occupied_entry) => Err(Errno::Mfile),
+				hash_map::Entry::Vacant(vacant_entry) => {
+					vacant_entry.insert(obj);
+					Ok(fd2)
+				}
 			}
 		})
 	}

src/scheduler/mod.rs

@@ -468,43 +468,19 @@ impl Task {
 			let objmap = OBJECT_MAP.get().unwrap().clone();
 			let mut guard = objmap.write();
 			if env::is_uhyve() {
-				guard
-					.try_insert(
-						STDIN_FILENO,
-						Arc::new(async_lock::RwLock::new(UhyveStdin::new())),
-					)
-					.expect("cannot insert stdin");
-				guard
-					.try_insert(
-						STDOUT_FILENO,
-						Arc::new(async_lock::RwLock::new(UhyveStdout::new())),
-					)
-					.expect("cannot insert stdout");
-				guard
-					.try_insert(
-						STDERR_FILENO,
-						Arc::new(async_lock::RwLock::new(UhyveStderr::new())),
-					)
-					.expect("cannot insert stderr");
+				let stdin = Arc::new(async_lock::RwLock::new(UhyveStdin::new()));
+				let stdout = Arc::new(async_lock::RwLock::new(UhyveStdout::new()));
+				let stderr = Arc::new(async_lock::RwLock::new(UhyveStderr::new()));
+				guard.insert(STDIN_FILENO, stdin);
+				guard.insert(STDOUT_FILENO, stdout);
+				guard.insert(STDERR_FILENO, stderr);
 			} else {
-				guard
-					.try_insert(
-						STDIN_FILENO,
-						Arc::new(async_lock::RwLock::new(GenericStdin::new())),
-					)
-					.expect("cannot insert stdin");
-				guard
-					.try_insert(
-						STDOUT_FILENO,
-						Arc::new(async_lock::RwLock::new(GenericStdout::new())),
-					)
-					.expect("cannot insert stdout");
-				guard
-					.try_insert(
-						STDERR_FILENO,
-						Arc::new(async_lock::RwLock::new(GenericStderr::new())),
-					)
-					.expect("cannot insert stderr");
+				let stdin = Arc::new(async_lock::RwLock::new(GenericStdin::new()));
+				let stdout = Arc::new(async_lock::RwLock::new(GenericStdout::new()));
+				let stderr = Arc::new(async_lock::RwLock::new(GenericStderr::new()));
+				guard.insert(STDIN_FILENO, stdin);
+				guard.insert(STDOUT_FILENO, stdout);
+				guard.insert(STDERR_FILENO, stderr);
 			}
 		}