Implementation of Driver Registry RFC

[jamesmunns]

Provides an implementation of #25.

There aren't any major conceptual changes here, but some implementation tweaks were made.

Additionally, I've gone ahead and "fully broken" userspace comms (the existing structures don't totally fit, and fixing them would require fixing some other underlying details, which I will do as a follow-up in a later RFC to restore userspace comms). The largest pre-req for this fix is deciding how to do async/await notifications across the ABI barrier.

[jamesmunns]

As a note, this is what the current demo main now looks like, which I think is much closer to what I want to be possible:

mnemos/source/melpomene/src/main.rs

Lines 82 to 130 in 307b2e1

	let k = unsafe { Kernel::new(settings).unwrap().leak().as_ref() };
	// First let's make a dummy driver just to make sure some stuff happens
	let initialization_future = async move {
	// Delay for one second, just for funsies
	Delay::new(Duration::from_secs(1)).await;
	// Set up the bidirectional, async bbqueue channel between the TCP port
	// (acting as a serial port) and the virtual serial port mux.
	//
	// Create the buffer, and spawn the worker task, giving it one of the
	// queue handles
	TcpSerial::register(k, opts.serial_addr, 4096, 4096).await.unwrap();
	// Now, right now this is a little awkward, but what I'm doing here is spawning
	// a new virtual mux, and configuring it with:
	// * Up to 4 virtual ports max
	// * Framed messages up to 512 bytes max each
	SerialMux::register(k, 4, 512).await.unwrap();
	let mux_hdl = SerialMuxHandle::from_registry(k).await.unwrap();
	let p0 = mux_hdl.open_port(0, 1024).await.unwrap();
	let p1 = mux_hdl.open_port(1, 1024).await.unwrap();
	drop(mux_hdl);
	k.spawn(async move {
	loop {
	let rgr = p0.consumer().read_grant().await;
	let len = rgr.len();
	p0.send(&rgr).await;
	rgr.release(len);
	}
	}
	.instrument(tracing::info_span!("Loopback")))
	.await;
	// Now we just send out data every second
	k.spawn(async move {
	loop {
	Delay::new(Duration::from_secs(1)).await;
	p1.send(b"hello\r\n").await;
	}
	}
	.instrument(tracing::info_span!("Hello Loop")))
	.await;
	}
	.instrument(tracing::info_span!("Initialize"));
	k.initialize(initialization_future).unwrap();

[hawkw]

overall, this looks solid! i commented on some very minor nits; i'd like to look a little more closely at some of the implementation, but it looks good to me!

[hawkw]

this would be cool to have in maitake's synchronization primitives, but...i'm not sure if there's a nice way to implement it without being tightly coupled to mnemos' HeapArc type. we could do another "generic over allocation" thing but that's probably not worth the effort...

[jamesmunns]

Yeah, I was thinking about this. I don't have a great answer, but would be open to porting it if it makes sense in the future.