Rust's high-level standard library has a choice between APIs using panic (unwinding or abort) or reporting an error.
The low-level subset of the standard library doesn't provide dynamic allocation. If you're using that, then you can choose to only provide APIs reporting errors.
Conversation
The proof of concept kernel Rust implementation doesn't use the high-level standard library. They used the liballoc library as a placeholder and that comes with both forms of methods (panic and error reporting). They explained they'll only be providing error reporting variants.
1
Unlike C, Rust has standard support for using it as a freestanding language and with a low-level subset of the standard library.
The language fully supports implementing the allocation APIs via the kernel allocators and only providing the variants of those APIs not using panic.
1
1
It is annoying that you lose all the standard dynamically allocated collections, etc. and need to fork the libraries if you don't want method variants panicking on OOM.
So, for example, you'd want Vec::push(x) to return Option<T> or Result<T, E> to get back `x` on alloc failure.
1
1
As a language, it fully supports it. It fits well into the idiomatic error handling system based on sum types (typically Result) including syntactic sugar for bubbling up the errors.
Unlike C++, no-unwind support is standard, but high level stdlib mostly relies on panic on OOM.
1
The high level stdlib has no relevance to the kernel usage because it MUST use $![no_std] (freestanding) code. The high-level stdlib (libstd) uses lower-level standard libraries (libcore, liballoc, etc.) and they can use some of those, but they will need a stripped down liballoc.
1
So, basically, the only issue is they haven't yet forked liballoc to delete the methods doing panic on OOM. It's the same reason they need other placeholder stubs doing panic to fill in APIs used by stdlib code they've included via libcore, etc. Could fork libcore and delete it.
2
I don't know about the practicality of having to fork and maintain a likely incompatible version of rust, just for the Linux kernel.
2
Last time I checked you don't need a special C compiler for the Kernel, C is basically assembler with Macros.
2
They use a very extended version of C supported by GCC/Clang and they use their own memory model not truly implemented by GCC/Clang rather than the C11 memory model. They don't use the C standard library.
For Rust, they don't need a special dialect of the language in the kernel.
They do need their own version of the higher level standard libraries (at most they can use libcore), but for C, they can't use the standard library at all.
Rust has standardized equivalents to most of the GCC/Clang extensions they use. Standard C doesn't even have inline asm.
1
It's fairly easy to start using Rust. However, the whole point of using Rust is having most of the code in the safe dialect. In order to do that, you need substantial work making safe APIs that don't need to be marked as unsafe functions in Rust. That's most of the work.
1
Show replies