Merge #651

651: Disable many unstable Rust features r=stlankes a=mkroening



Co-authored-by: Martin Kröning <mkroening@posteo.net>

Author: bors[bot]

Dockerfile

@@ -5,7 +5,7 @@ ENV RUSTUP_HOME=/usr/local/rustup \
     CARGO_HOME=/usr/local/cargo \
     PATH=/usr/local/cargo/bin:$PATH \
     # Manually sync this with rust-toolchain.toml!
-    RUST_VERSION=nightly-2022-12-12 \
+    RUST_VERSION=nightly-2023-02-07 \
     RUST_COMPONENTS="llvm-tools-preview rust-src" \
     RUST_TARGETS="x86_64-unknown-none"
 

rust-toolchain.toml

@@ -1,6 +1,6 @@
 [toolchain]
 # Manually sync this with Dockerfile!
-channel = "nightly-2022-12-12"
+channel = "nightly-2023-02-07"
 components = [
     "llvm-tools-preview",
     "rust-src",

src/arch/x86_64/kernel/scheduler.rs

@@ -274,10 +274,7 @@ impl TaskTLS {
 			// So the thread pointer needs to be `block_ptr + tls_offset`.
 			// Allocating only tls_len bytes would be enough to hold the TLS block.
 			// For the thread pointer to be sound though, we need it's value to be included in or one byte past the same allocation.
-			let block = Box::<[u8]>::new_zeroed_slice(tls_offset);
-
-			// SAFETY: All u8s can hold the bit-pattern 0 as a valid value
-			unsafe { block.assume_init() }
+			vec![0; tls_offset].into_boxed_slice()
 		};
 
 		// Initialize beginning of the TLS block with TLS initialization image

src/drivers/net/rtl8139.rs

@@ -519,19 +519,8 @@ pub fn init_device(adapter: &pci::PciAdapter) -> Result<RTL8139Driver, DriverErr
 		outl(iobase + TCR, TCR_IFG | TCR_MXDMA0 | TCR_MXDMA1 | TCR_MXDMA2);
 	}
 
-	let rxbuffer = Box::<[u8]>::try_new_zeroed_slice(RX_BUF_LEN).map_err(|_| {
-		error!("Unable to allocate buffers for RTL8139");
-		DriverError::InitRTL8139DevFail(RTL8139Error::Unknown)
-	})?;
-	// SAFETY: All u8s can hold the bit-pattern 0 as a valid value
-	let rxbuffer = unsafe { rxbuffer.assume_init() };
-
-	let txbuffer = Box::<[u8]>::try_new_zeroed_slice(NO_TX_BUFFERS * TX_BUF_LEN).map_err(|_| {
-		error!("Unable to allocate buffers for RTL8139");
-		DriverError::InitRTL8139DevFail(RTL8139Error::Unknown)
-	})?;
-	// SAFETY: All u8s can hold the bit-pattern 0 as a valid value
-	let txbuffer = unsafe { txbuffer.assume_init() };
+	let rxbuffer = vec![0; RX_BUF_LEN].into_boxed_slice();
+	let txbuffer = vec![0; NO_TX_BUFFERS * TX_BUF_LEN].into_boxed_slice();
 
 	debug!(
 		"Allocate TxBuffer at {:p} and RxBuffer at {:p}",

src/drivers/virtio/virtqueue/packed.rs

@@ -1025,7 +1025,7 @@ impl PackedVq {
 		if !self.dropped.borrow().is_empty() {
 			self.dropped
 				.borrow_mut()
-				.drain_filter(|tkn| tkn.state == TransferState::Finished);
+				.retain(|tkn| tkn.state != TransferState::Finished);
 		}
 	}
 

src/drivers/virtio/virtqueue/split.rs

@@ -271,7 +271,7 @@ impl SplitVq {
 		if !self.dropped.borrow().is_empty() {
 			self.dropped
 				.borrow_mut()
-				.drain_filter(|tkn| tkn.state == TransferState::Finished);
+				.retain(|tkn| tkn.state != TransferState::Finished);
 		}
 	}
 

src/lib.rs

@@ -7,22 +7,13 @@
 #![warn(clippy::transmute_ptr_to_ptr)]
 #![allow(clippy::missing_safety_doc)]
 #![allow(incomplete_features)]
-#![feature(abi_x86_interrupt)]
+#![cfg_attr(target_arch = "x86_64", feature(abi_x86_interrupt))]
 #![feature(allocator_api)]
-#![feature(atomic_mut_ptr)]
 #![feature(asm_const)]
-#![feature(const_mut_refs)]
 #![feature(linked_list_cursors)]
 #![feature(naked_functions)]
-#![feature(new_uninit)]
 #![feature(specialization)]
-#![feature(core_intrinsics)]
-#![feature(alloc_error_handler)]
-#![feature(vec_into_raw_parts)]
-#![feature(drain_filter)]
 #![feature(strict_provenance)]
-#![feature(map_try_insert)]
-#![feature(is_some_and)]
 #![cfg_attr(target_os = "none", no_std)]
 #![cfg_attr(target_os = "none", feature(custom_test_frameworks))]
 #![cfg_attr(all(target_os = "none", test), test_runner(crate::test_runner))]
@@ -82,8 +73,6 @@ pub(crate) mod fd;
 mod mm;
 #[cfg(feature = "tcp")]
 mod net;
-#[cfg(target_os = "none")]
-mod runtime_glue;
 mod scheduler;
 mod synch;
 mod syscalls;
@@ -385,3 +374,12 @@ fn application_processor_main() -> ! {
 	// Run the scheduler loop.
 	core_scheduler.run();
 }
+
+#[cfg(target_os = "none")]
+#[panic_handler]
+fn panic(info: &core::panic::PanicInfo<'_>) -> ! {
+	let core_id = crate::arch::core_local::core_id();
+	println!("[{core_id}][PANIC] {info}");
+
+	crate::syscalls::shutdown(1)
+}

src/runtime_glue.rs

@@ -168,9 +168,8 @@ impl TaskHandlePriorityQueue {
 	/// Checks if the given task is in the queue. Returns `true` if the task
 	/// was found.
 	pub fn contains(&self, task: TaskHandle) -> bool {
-		self.queues[task.priority.into() as usize]
-			.as_ref()
-			.is_some_and(|queue| queue.iter().any(|queued| queued.id == task.id))
+		matches!(self.queues[task.priority.into() as usize]
+			.as_ref(), Some(queue) if queue.iter().any(|queued| queued.id == task.id))
 	}
 
 	/// Add a task handle by its priority to the queue

src/scheduler/task.rs

@@ -22,6 +22,11 @@ bitflags! {
 	}
 }
 
+fn addr(addr: &AtomicU32) -> usize {
+	let ptr: *const _ = addr;
+	ptr.addr()
+}
+
 /// If the value at address matches the expected value, park the current thread until it is either
 /// woken up with `futex_wake` (returns 0) or the specified timeout elapses (returns -ETIMEDOUT).
 ///
@@ -44,20 +49,17 @@ pub fn futex_wait(address: &AtomicU32, expected: u32, timeout: Option<u64>, flag
 	let scheduler = core_scheduler();
 	scheduler.block_current_task(wakeup_time);
 	let handle = scheduler.get_current_task_handle();
-	parking_lot
-		.entry(address.as_mut_ptr().addr())
-		.or_default()
-		.push(handle);
+	parking_lot.entry(addr(address)).or_default().push(handle);
 	drop(parking_lot);
 
 	loop {
 		scheduler.reschedule();
 
 		let mut parking_lot = PARKING_LOT.lock();
-		if wakeup_time.is_some_and(|t| t <= get_timer_ticks()) {
+		if matches!(wakeup_time, Some(t) if t <= get_timer_ticks()) {
 			let mut wakeup = true;
 			// Timeout occurred, try to remove ourselves from the waiting queue.
-			if let Entry::Occupied(mut queue) = parking_lot.entry(address.as_mut_ptr().addr()) {
+			if let Entry::Occupied(mut queue) = parking_lot.entry(addr(address)) {
 				// If we are not in the waking queue, this must have been a wakeup.
 				wakeup = !queue.get_mut().remove(handle);
 				if queue.get().is_empty() {
@@ -72,9 +74,8 @@ pub fn futex_wait(address: &AtomicU32, expected: u32, timeout: Option<u64>, flag
 			}
 		} else {
 			// If we are not in the waking queue, this must have been a wakeup.
-			let wakeup = !parking_lot
-				.get(&address.as_mut_ptr().addr())
-				.is_some_and(|queue| queue.contains(handle));
+			let wakeup = !matches!(parking_lot
+				.get(&addr(address)), Some(queue) if queue.contains(handle));
 
 			if wakeup {
 				return 0;
@@ -97,7 +98,7 @@ pub fn futex_wake(address: &AtomicU32, count: i32) -> i32 {
 	}
 
 	let mut parking_lot = PARKING_LOT.lock();
-	let mut queue = match parking_lot.entry(address.as_mut_ptr().addr()) {
+	let mut queue = match parking_lot.entry(addr(address)) {
 		Entry::Occupied(entry) => entry,
 		Entry::Vacant(_) => return 0,
 	};