Or you could just implement the linux syscalls directly in the kernel, but that seems a bit self-defeating if you want to explore new ideas.
Just seems like a good starting point than reworking the entire world.
Also, on the question of "how" you'd do this, I'm not a kernel hacker, but I thought it would be possible to expose FFI, i.e. the shim you talk about, that would allow drivers to be used from something like NetBSD. But you're right that it could be self-defeating in that supporting all of those interfaces might end up constraining the OS in it's attempt to deliver on these features.
On a side note, it seems like it would be nice to expose POSIX FFI hooks to make porting software to a Rust OS easier.
I dunno about performance impact, but I bet it is fairly negligible in the grand scheme of things. In the rump kernel case, these shims really don't do anything, they just pass the call through. Think of it as an API facade. In a hobby OS it might be heavier, if your OS doesn't have a 1:1 mapping of the POSIX/linux syscall to an equivalent.
Also, we virtualize this stuff all the time in cloud environments. Your java app uses the JVM to execute a linux syscall which the kernel translates into a Xen hypercall which Xen uses to call a native driver which talks to the disk, etc etc. You obviously do pay a performance penalty for stacking more and more layers, but it isn't as bad as you'd think (or as good as you hope, take your pick).
But the point is that layering abstractions like this is very much alive and tolerated today in moderately high performance systems :)
How is that possible? An intermediate layer? The kernel is going to be written in rust. You can't just put C code in there and expect it to work. I'm not even sure how you could transcode these drivers into rust considering rust uses a completely different memory model. I suspect a 'real' RustOS will require new drivers to be written from scratch. From a mass adoption perspective, how would have linux worked out if Linus decided to write windows driver shims?
I wonder if its feasible to rewrite things like apache, nginx, php, mysql, gnu utils, etc in Rust but keep the linux kernel as-is. Seems like you'd get the best of both worlds there - a mature and powerful kernel and a Rust userland that's hard to exploit. Most exploited vulnerabilities and stability issues aren't kernel related anyway.
Mozilla's servo project is also interesting. Maybe I don't need a RustOS (yet), but just my internet facing applications in Rust.