Tasking subsystem rework

[greatbridf]

1. Unified the stackful and stackless coroutine schemes.

Rework the scheduler and rename it to Runtime. Use stackless coroutines as the basic scheduling unit so we can run only one scheduler with only one stack on each cores. This reduces complexity and improves performance A LOT.

In scenarios where we DO need a stackful execution environment, we provide an extra wrappers called stackful(). To run computational (or time comsuming) tasks on a time slice based preemptible basis is as simple as wrapping the future with it and throw it to the runtime:

RUNTIME.spawn(async {
    // Some computational work
    loop { println!("computational work") }
});

The task above will block the cpu forever if it is chosen by the scheduler to run as the poll function will never return. The solution is very simple:

RUNTIME.spawn(stackful(async {
    // Some computational work
    loop { println!("computational work") }
}));

You wrap the future with stackful(), and the future will be thrown to the dedicated stack, got preempted and yield the control back to the runtime. Voila.

2. Partial adaption of all async functions (this part may need further discussion).

The filesystem and block device subsystem is left unchanged although it would be as easy as noting the functions as #[async_trait] and change every function through the calling chain to async as well (they're migrated to the new block_on function as a temporary solution). The main reason is that async fns in dyn traits can only be implemented by using boxed dyn Futures, which would impact the performance severely on hot paths like the two.

The current solution is to wrap Thread::run with stackful() to make them preemptible so that we can continue to use block_on.... This is ugly but works well.

3. Fixed various bugs in the HAL's trap subsystem.

[Copilot]

Pull Request Overview

This PR implements a major rework of the tasking subsystem, unifying stackful and stackless coroutine schemes with a new runtime-based scheduling approach. The changes replace the existing scheduler with a simplified Runtime that uses stackless coroutines as the basic scheduling unit, while providing stackful execution via a wrapper for computational tasks that require preemption.

Key changes include:

• Complete replacement of the Scheduler with a Runtime system using stackless coroutines
• Introduction of stackful() wrapper for time-slice based preemptible execution of computational tasks
• Migration from Task::block_on() to a new block_on() function throughout the codebase
• Simplification of task state management and execution model

Reviewed Changes

Copilot reviewed 53 out of 53 changed files in this pull request and generated 4 comments.

Show a summary per file

File	Description
src/rcu.rs	Updates RCU synchronization to use new runtime and adds call_rcu function
src/lib.rs	Major kernel initialization changes to use new runtime and task context switching
src/kernel/task.rs	Introduces new block_on and stackful functions, core of the new tasking model
crates/eonix_runtime/src/scheduler.rs	Complete rewrite from Scheduler to Runtime with simplified execution model
crates/eonix_runtime/src/task.rs	Simplified task structure using direct future polling instead of complex state machine
Multiple filesystem/driver files	Migration from Task::block_on to new block_on function

[Copilot]

The todo!() macro will panic when reached, making this code path unusable. This should be replaced with proper implementation or removed if not needed.

Suggested change

	todo!();
	// Arc is dropped here after RCU grace period.

[Copilot]

[nitpick] The Debug trait was removed from the derive macro but a custom Debug implementation was added later. This could be confusing - consider keeping Debug in the derive macro and removing the custom implementation, or add a comment explaining why the custom implementation is needed.

Suggested change

	#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
	#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug)]

[Copilot]

[nitpick] Using let Ok(old) = ... pattern and then ignoring the error case with early return could mask unexpected states. Consider handling the error case explicitly or adding a comment explaining when this is expected to fail.

Suggested change

	};
	match self.state.update(|state| match state {
	TaskState::BLOCKED => Some(TaskState::READY),
	TaskState::RUNNING => Some(TaskState::READY | TaskState::RUNNING),
	TaskState::READY | TaskState::READY_RUNNING => None,
	state => unreachable!("Waking a {state:?} task"),
	}) {
	Ok(old) => {
	if old == TaskState::BLOCKED {
	// If the task was blocked, we need to put it back to the ready queue.
	self.rq().put(self.clone());
	}
	}
	Err(e) => {
	// This should not happen; log, assert, or handle as appropriate.
	debug_assert!(false, "Failed to update task state in wake_by_ref: {:?}", e);
	// Optionally, you could log or handle the error here.
	}
	}

[Copilot]

[nitpick] Architecture-specific inline assembly blocks are scattered throughout the function. Consider extracting these into architecture-specific helper functions to improve readability and maintainability.

Suggested change

	core::arch::asm!("break 1");
	arch_breakpoint();