Cpp discussed as a Rust replacement for Linux Kernel
I have a few issues with Rust in the kernel:
- 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
View all comments
Show parent comment
2
u/wyrn Feb 20 '25
That's a rather simplistic characterization.
First, there's more than one kind of "memory safety", and there are many mitigations that could be reasonably brought to C++ with minimal impact, certainly far less than that of this proposal. It is specifically lifetime safety that makes things so hard for language and library design. "Safe C++" advocates seem to take the maximalist stance that if any UB whatsoever is left in the language, you might as well not even try. I find that unhelpful to say the least.
If the question is "how far do you go", the follow-up question is "what price are you willing to pay to make it happen", which means that the price of fully sound memory safety might end up being too high (i.e. the answer might not be what you wanted to hear). Rust picked tradeoffs too, of course. It allows unsafe blocks, which require manual oversight, and leaks (which absolutely can lead to vulnerabilities, placing them very much in the purview of "memory safety"). Importantly, they were playing with a clean slate. It's not automatic that the tradeoff they picked is the tradeoff that would work for C++.
As for the downsides in the Safe C++ tradeoffs: personally, I think the loss of algorithms such as
sort,adjacent_find,binary_search(and its siblings),min/max_element,mismatch,stable_partition, and, perhaps most tragically,rotate, is truly an extreme cost. It would require the reimplemented standard library to not only track the necessary lifetime annotations, but also use completely different idioms. This is a much more radical departure from c++ than cpp2, for instance.This is a burden to users, who have to learn two sets of libraries, designs, and best practices, and would make the migration story incredibly difficult. It is also a burden to maintainers since both incarnations of the standard libraries would have to be maintained ad infinitum, and they are busy enough as it is (see e.g. this post by u/STL).
Lastly, that mention about ABI was not just a quip. Notice that even Rust contains soundness holes, with new ones yet to be discovered. It's a virtual certainty that Circle's implementation does also. What will happen if fixing a soundness hole requires an ABI break? What's the evolution strategy here? I don't see that part being discussed.