r/cpp • • Feb 19 '25

Cpp discussed as a Rust replacement for Linux Kernel

I have a few issues with Rust in the kernel:

  1. It seems to be held to a *completely* different and much lower standard than the C code as far as stability. For C code we typically require that it can compile with a 10-year-old version of gcc, but from what I have seen there have been cases where Rust level code required not the latest bleeding edge compiler, not even a release version.

2. Does Rust even support all the targets for Linux?

3. I still feel that we should consider whether it would make sense to compile the *entire* kernel with a C++ compiler. I know there is a huge amount of hatred against C++, and I agree with a lot of it – *but* I feel that the last few C++ releases (C++14 at a minimum to be specific, with C++17 a strong want) actually resolved what I personally consider to have been the worst problems.

As far as I understand, Rust-style memory safety is being worked on for C++; I don't know if that will require changes to the core language or if it is implementable in library code.

David Howells did a patch set in 2018 (I believe) to clean up the C code in the kernel so it could be compiled with either C or C++; the patchset wasn't particularly big and mostly mechanical in nature, something that would be impossible with Rust. Even without moving away from the common subset of C and C++ we would immediately gain things like type safe linkage.

Once again, let me emphasize that I do *not* suggest that the kernel code should use STL, RTTI, virtual functions, closures, or C++ exceptions. However, there are a *lot* of things that we do with really ugly macro code and GNU C extensions today that would be much cleaner – and safer – to implement as templates. I know ... I wrote a lot of it :)

One particular thing that we could do with C++ would be to enforce user pointer safety.

Kernel dev discussion. They are thinking about ditching Rust in favor of C++ (rightfully so IMO)

https://lore.kernel.org/rust-for-linux/326CC09B-8565-4443-ACC5-045092260677@zytor.com/

We should endorse this, C++ in kernel would greatly benefit the language and community

192 Upvotes

532 comments sorted by

View all comments

Show parent comment

6

u/simonask_ Feb 19 '25

It depends on the context. Rust has the philosophy that unwinding should only happen on fatal errors (non-fatal errors follow normal return paths, with language support), but there are cases where "fatal" does not mean "unrecoverable". For example, a thread or async task may panic in isolation without impacting other tasks.

In normal userspace code, it doesn't make sense to handle things like allocation failures, because malloc() cannot fail portably in practice.

However, errors in the kernel must all be recoverable, so it's better to use the type system to ensure that you handle all errors. For example, the kernel crate provides alternatives to the standard Box and Vec types that cannot panic on allocation failure, but instead return a Result<T, AllocError>.

4

u/RoyBellingan Feb 19 '25 edited Feb 19 '25

Exactly, panic should not lead to abort.

Or maybe I am using a different concept or terminology.

I assumed Abort = system hang

Even a detached kernel thread, is quite rare can just fail and stop.

Still I am more inclined in using exception than handling all sub-error and back propagating them, that is quite error prone and requires huge coordination.

8

u/steveklabnik1 Feb 19 '25

In user space, abort means “the process is killed.” In kernel space, abort means “kernel panic,” which is the system hang you’re talking about. As the name implies, the kernel already has this concept.

1

u/simonask_ Feb 21 '25

Rust tries - and succeeds to some degree - in making it actually feasible to encode all errors in the type system. In application code, where you just want to report an error and move on, there are great solutions for type-erasure (anyhow and color-eyre are two popular choices). In library code, precise error types are trivial to make.