6 ms·
Committing to Rust in the Kernel
- joelignaatius 2y ago[flagged]
- slater 2y agoHN automatically changes some titles, to counteract against SEO'd clickbait titles. dunno about the link, but the part after "si=" isn't required, e.g.: https://youtu.be/_wc7ujflrnI https://youtu.be/_wc7ujflrnI works fine
- airstrike 2y agoYou can also edit the post after submission to revert the automatic title changes
- jsheard 2y agoOn a semi-tangent, does anyone happen to know how Microsofts push to use Rust in the Windows kernel is coming along? They rewrote some components in Rust and rolled them out to production about a year ago but it has seemed pretty quiet on that front since then, unless I missed something.
- tsujamin 2y agoI noticed the other morning that they’ve either re-written or are growing the win32k driver in rust. This was either in Server ‘25 or vNext though I can’t remember. Given win32k implements a good chunk of the kernel-mode graphics and windowing system it’s a pretty good place to start that effort. edit: win32kbase_rs.sys was what it was called, and I’m pretty sure it was 2025 I pulled it from but it might be on earlier versions too
- okwubodu 2y agoOut of curiosity, how did you notice this?
- tsujamin 2y agoI was hunting for what Windows libraries used a particular new API and saw it in my scrolling! You can see all the panic and error strings, and some internal package paths if you run strings over it. Win32k looks like it got split pretty hard into a couple of sub libraries in recent versions though (win32k, win32kbase, win32kbase_rs etc)
- npalli 2y agoI googled for this file and I LOL'ed as the first link was a crash report linked to this one. https://www.elevenforum.com/t/latest-beta-causing-program-crash-culprit-win32kbase_rs-sys.21375/ https://www.elevenforum.com/t/latest-beta-causing-program-cr...
- steveklabnik 2y agoThey haven’t spoken publicly about it. As a Windows user, I am very intrigued!
- pjmlp 2y agoThey have, provided you pay attention to Windows developer channels, see my reply, https://news.ycombinator.com/item?id=41645415 https://news.ycombinator.com/item?id=41645415
- steveklabnik 2y agoThanks! I’m aware of most, but not all of that. But that stuff isn’t kernel stuff, though obviously much of it is serious systems work. That’s what I was referring to specifically.
- pjmlp 2y agoBesides GDI regions and CoreWrite, there isn't much public info. They dumped Rust bindings to DDK, but it is more a over the fence kind of thing. WinDev is culturally against anything not C++, see .NET adoption for key Windows features versus what happens on Apple/Google OS land. I am quite curious on how WinDev will proceed with Rust and .NET versus C++, given the new security mandate tied to job evaluation.
- pjmlp 2y agoWhile they are rather quite on that front, Rust is now the official systems language for new projects in Azure infrastructure, with C#, Java and Go as alternative is a managed language is also possible. "Decades of vulnerabilities have proven how difficult it is to prevent memory-corrupting bugs when using C/C++. While garbage-collected languages like C# or Java have proven more resilient to these issues, there are scenarios where they cannot be used. For such cases, we’re betting on Rust as the alternative to C/C++. Rust is a modern language designed to compete with the performance C/C++, but with memory safety and thread safety guarantees built into the language. While we are not able to rewrite everything in Rust overnight, we’ve already adopted Rust in some of the most critical components of Azure’s infrastructure. We expect our adoption of Rust to expand substantially over time." From https://azure.microsoft.com/en-us/blog/microsoft-azure-security-evolution-embrace-secure-multitenancy-confidential-compute-and-rust/ https://azure.microsoft.com/en-us/blog/microsoft-azure-secur... Several key projects have been migrated to Rust, or started from Rust althogether. => Azure Boost https://learn.microsoft.com/en-us/azure/azure-boost/overview https://learn.microsoft.com/en-us/azure/azure-boost/overview "Rust serves as the primary language for all new code written on the Boost system, to provide memory safety without impacting performance. Control and data plane operations are isolated with memory safety improvements that enhance Azure’s ability to keep tenants safe." => OpenHCL, Azure's para-virtualization https://techcommunity.microsoft.com/t5/windows-os-platform-blog/openhcl-evolving-azure-s-virtualization-model/ba-p/4248345 https://techcommunity.microsoft.com/t5/windows-os-platform-b... "OpenHCL is a para-virtualization layer built from the ground-up in the Rust programming language. Rust is designed with strong memory safety principles, making it ideally suited for the virtualization layer." => Security processor Pluton firmware (used by XBox, Azure and CoPilot+ PC hardware) https://learn.microsoft.com/en-us/windows/security/hardware-security/pluton/microsoft-pluton-security-processor https://learn.microsoft.com/en-us/windows/security/hardware-... Post from David Weston, Microsoft's vice president of OS security regarding the Rust rewrite and TockOS adoption, https://x.com/dwizzzleMSFT/status/1803550239057650043 https://x.com/dwizzzleMSFT/status/1803550239057650043 => CoPilot+ UEFI firmware https://techcommunity.microsoft.com/t5/surface-it-pro-blog/rust-support-for-uefi-development-through-project-mu/ba-p/3970582 https://techcommunity.microsoft.com/t5/surface-it-pro-blog/r... "Surface and Project Mu are working together to drive adoption of Rust into the UEFI ecosystem. Project Mu has implemented the necessary changes to the UEFI build environment to allow seamless integration of Rust modules into UEFI codebases. Surface is leveraging that support to build Rust modules in Surface platform firmware. With Rust in Project Mu, Microsoft's ecosystem benefits from improved security transparency while reducing the attack surface of Microsoft devices due to Rust’s memory safety benefits. Also, by contributing firmware written in Rust to open-sourced Project Mu, Surface participates in an industry shift to collaboration with lower costs and a higher security bar. With this adoption, Surface is protecting and leading the Microsoft ecosystem more than ever."
- stonethrowaway 2y agoWith the Rust team falling apart, who is actually long term going to maintain it? I want to use it but I just see drama.
- mynameisash 2y agoWho says the Rust team is falling apart?
- brcmthrowaway 2y agoThe project lead left after being admonished by Theodore T'so
- mardifoufs 2y agoNot sure I'd agree they are falling apart but just to be clear, I think you're referring to the rust Linux team, not the actual rust language team, right?
- stonethrowaway 2y agoNot sure why the downvoting. It’s a serious question. Who is ensuring that this project has a future and isn’t going to collapse tomorrow?
- steveklabnik 2y agoAsserting that a team is collapsing with no evidence will get downvotes. This work is funded by Google and I believe others. So that’s a positive signal towards maintainability. Regardless of a specific person being involved or not, Google has significant Rust components in Android and a vested interest in all this. But also on some level, it’s too early for these questions. Stuff is still an experiment. It could all get removed tomorrow. Once it’s closer to being permanent, then “how do we continue to maintain this” becomes a more important question.
- brotchie 2y agoThought that ThePrimeTime in his video https://youtu.be/62oTu9hjxL4?si=E98WZ0zJSNUC8TEH&t=287 https://youtu.be/62oTu9hjxL4?si=E98WZ0zJSNUC8TEH&t=287 hit the nail on the head re: Rust versus C. Max level C programmers, have designed their programming style around control down to the absolute bit. C derives control from absolute control over behavior. Max level Rust programmers have complete mastery of types. Rust derives control from types. Seems somewhat philosophically incompatible.
- 01HNNWZ0MV43FF 2y agoIDK, I thought well-written c and c++ had the same notions of ownership and lifetimes, just not enforced by the compiler
- bsder 2y agoC and C++ are very different. I think Casey Muratori hits the nail on the head here: https://youtu.be/xt1KNDmOYqA https://youtu.be/xt1KNDmOYqA In short, RAII and smart pointers and borrow checker are all signs of "individual element thinking" and that way lies madness. You smear out lifetime and ownership so badly that it practically by definition becomes a problem. Your goal is to think about this stuff in groups to make thinking about allocation way, way easier. Programming is all about abstracting to the next layer. I'm not sure he has quite gotten to the heart of the issue, yet. However, a bunch of smart people (Casey Muratori, Jonathan Blow, Andrew Kelley, etc.) are all dancing around something that Rust and C++ don't seem to fit the bill on. Hopefully they can crystallize it out so that everybody can see it.
- dboreham 2y agoOh interesting. I was expecting to see nonsense in that video (probably triggered by the first line -- C and C++ are basically the same thing, in that you can, and folks did forever, implement all the C++ fancy stuff in C -- just because something isn't in the core language, doesn't mean it wasn't done). But actually it's suggesting how I've been wanting memory to be managed for a couple decades (and have achieved long ago in C projects). Basically some sort of "domain-orientated arena allocator". A simple example is in a network server -- you receive a request from a client, do a bunch of stuff to service that request, and now you're done. Please blow away the memory used to service the request, thanks, all at once. Of course it's not quite that simple because there will be some "chaff" objects thrown off in processing the request that we need to keep around for a while later (e.g. for logging to drain). I suppose the reference to Jonathan Blow should have been a clue that this would be something worthwhile.
- cozzyd 2y agoWhy can't all symbols exported to modules maintain a C ABI, obviating (if I understand correctly) the genksyms problem?
- kelnos 2y agoBecause then when you want to write a module in Rust, all your interfacing with the rest of the kernel will be done through C function calls, with C semantics, and C expectations of ownership. There's really little point to adding Rust abstractions to the kernel, then, at least when it comes to modules.
- cozzyd 2y agoBut without a stable ABI can you expect modules to realistically work across versions? It seems like a similar problem to shared libraries, which rust punts on.
- deleted 2y ago[deleted]
- tasn 2y agoThe kernel doesn't offer a stabke ABI for modules regardless of Rust. So what you're describing is already the case.
- cozzyd 2y agoSure, it changes when something changes, but with rust it changes (in theory) without any code changes but with a tool chain change.
- steveklabnik 2y agoThe point is that there’s no requirement at all, so the rate of change is irrelevant.
- 2y ago
- aero-glide2 2y agoEven though I don't use Linux in my projects, Rust on Linux is extremely important to convince others to use Rust. I hope it succeeds.
- iLemming 2y agoEven though I don't write any Rust, I still think Rust on Linux is important. I rather learn and deal with Rust than with C/C++, and I too, hope it succeeds.
- nine_k 2y agoC/C++ is like water/alcohol; certainly they look very similar to an uninvolved observer, and one can mix them easily, but they differ drastically. One is an utterly simple life substrate, another is a toxic and hallucinogenic but potent rocket fuel. For the record, Torvalds has always vehemently resisted any attempts to use C++ in the kernel. I completely support his position.
- jupp0r 2y agoYou are probably writing your comment via lots of software written in C++. It's a great language with lots of flaws introduced by legacy decisions that would be made differently today.
- nine_k 2y agoRocket fuel, as I said. Dangerous, powerful, indispensable in certain kinds of projects. Up until the advent of Rust, there was no viable alternative for C++ in large, long-running, performance-critical codebases, like browsers or game engines. (I say this as a fan of Haskell and Rust, and a daily user of Python, Typescript, and elisp. Last time I wrote production C++ was in 2021, like 50 lines.)
- p1necone 2y ago"Torvalds said that it is not necessary to understand Rust to let it into a subsystem; after all, he said, nobody understands the memory-management subsystem, but everybody is able to work with it." Chuckled a bit at this line, anyone have context on how true this is?
- syndicatedjelly 2y agoIt’s an opinion, but it sounds very good from the perspective of treating the relationships between system and subsystems as an interface to be managed.
- j16sdiz 2y agoFor most driver or subsystem, maybe you don't need to know how mm works. Rust is different. The kernel Rust teams are trying to encode some safety invariant. If any of those mismatch with the C side, it breaks. Those invariant need some non trivial knowledge of rust to understand
- nine_k 2y agoIs there an example of what you're describing?
- steveklabnik 2y agoThere’s a recent drama where the Rust folks asked some people to clarify some of the semantics of some of the filesystem APIs, and this request wasn’t taken well. There’s been a bunch of hn threads about it.
- asne11 2y agolike which?
- steveklabnik 2y agoI apologize, I am on my phone, so rather than curating links, check out https://hn.algolia.com/?dateRange=all&page=0&prefix=false&query=rust%20linux&sort=byDate&type=story https://hn.algolia.com/?dateRange=all&page=0&prefix=false&qu..., most of which are about this situation.
- duped 2y agoWhat is the value in relying on distro authors to publish rust compiler versions, when the bespoke release channel for rustc is kept much more up to date?
- cozzyd 2y agoHow can you build a new kernel with distro tools otherwise?
- johnny22 2y agoI think the point is that maybe you shouldn't. (i'm not agreeing or disagreeing with that position). If you used a distro that provided multiple versions of something and kept them up to date or used nix or guix you wouldn't have this problem at all.
- MobiusHorizons 2y agoYou definitely need to be able to build the kernel that shipped with the distro using tools from the distro. Thats basic table stakes. Needing newer tools for building from the latest upstream repository is fine though
- duped 2y agoWith rustup? Why do you need the distro to be the be and end all of package management when it's more concerned with user space and not real development?
- csande17 2y agoDistros have historically been very concerned with "real development"! Debian, for example, packages all of the tools and libraries needed to build any package in Debian, so users can easily modify and recompile any package. Because there are a lot of packages in Debian, it's become a great, stable, vetted source for general-purpose compilers and libraries. Rust really is an outlier here -- its marketing has managed to walk a delicate tightrope to be considered "stable" and "mature" enough to use for important projects like Linux, while also still being new and fast-moving enough that it's unreasonable to expect those projects to use anything but the most recent bleeding-edge nightly build. And that will create problems, if only for distros trying to build the kernel binaries that they ship to their users.
- debo_ 2y agoAs a side note, does anyone know what the backup plan is if Linus is suddenly no longer able to lead in his current capacity? I think it's likely there is one, but am not sure what it is.
- klysm 2y agoNo, but as long as it doesn't land in Microsoft's hands I'm happy. edit: Not Oracle either
- arp242 2y agoIn a previous interview (several years ago) Linus said "there are at least a dozen people who can take over tomorrow if I get hit by a bus", or something to that effect. I don't think there's a specific concrete plan. Realistically, what will probably happen is that all the core maintainers will end up in a big room and discuss what to do next. Maybe they will do something with white smoke from a chimney. It's also very possible the nature of the leadership will change, rather than a simple s/Linus/…/.
- PKop 2y ago>there are at least a dozen people who can take over tomorrow Well, this is its own sort of problem though [0]. A good thing about a BDFL is unambiguously having someone in charge, accountable and responsible with power to "decide" as opposed to no one or too many fighting for it. When people ask this question I think they intend to know "who does Linus want or will he put in charge?" https://en.wikipedia.org/wiki/Succession_crisis https://en.wikipedia.org/wiki/Succession_crisis [0]
- strken 2y agoDoes Rust support the same range of architectures as C? Or is there some way to compile Rust to C to support weird obscure systems? Forgive me if this is something commonly known by the people involved. It just strikes me as the most obvious objection to Rust in the kernel and I haven't seen any explanation of what's going to happen.
- raggi 2y agorustc does not yet no, there's a lot of hope in the gcc rust frontend to help bridge the gap, but also there is increasing support in llvm for more architectures and things like this should drive interest in accelerating those projects.
- boulos 2y agoRustc lowers to LLVM IR, so it can target anything LLVM can. For a long while, that meant there were obscure architectures that were excluded, but IIRC coverage has improved and the Linux kernel has decided to drop support for them. The main push has actually been from the BSD family pushing clang (and thus LLVM) to support a broader swath of less common architectures.
- Palomides 2y agorust doesn't support alpha, parisc, or super-h, but afaict there are at least nominally functional back ends for the other platforms modern linux runs on
- steveklabnik 2y agoCurrently Rust is only acceptable in drivers. These are inherently platform specific, so there’s no issue with platform support. If Rust doesn’t support the platform, the driver won’t be written in it. Rust’s platform support is better than you might assume, but it is missing some platforms the kernel itself supports, so until that’s resolved, it can’t be in the core of things.
- BD103 2y agoCheck out the Rust's documentation page on platform support[0]. You'll be able to find the full list of supported platforms, as well as the target tier policy, and specific target requirements and maintainers. [0]: https://doc.rust-lang.org/rustc/platform-support.html https://doc.rust-lang.org/rustc/platform-support.html
- saagarjha 2y agoAside: LWN is basically what ChatGPT summarization as advertised itself to be, except it's actually good and coherent and useful. I can trust Jonathan to summarize the conversation in a way that is mostly sane and reasonable in a way that I can never hand off the job to generative AI. It's an important area where humans seem to excel over computers. Also, just to have some content that is actually on-topic: is anyone actually shipping upstream Linux Rust code yet? I understand that some stuff is slowly merging in but I'm not sure if it's actually being exercised yet.
- patmorgan23 2y agoI believe the kernel graphics drivers for the Apple M1 are written in rust, and are upstreamed.
- rnrn 2y agoAFAIU the asahi rust gpu driver is shipping in asahi but not upstreamed yet (torvalds/linux.git doesn’t have drivers/gpu/drm/asahi)
- josefx 2y agoFrom what I understand those drivers currently cannot be merged since the devs. rewrote various kernel APIs to match their expectations.
- steveklabnik 2y agoThis is true in a literal sense, but there’s some nuance. They were working on upstreaming them, but there was some strong disagreement about one of the earlier patches and so at least for now they’ve given up. And that patch was pretty small, it’s not like a massive change was required.
- rc00 2y ago> I can trust Jonathan Given the clear bias in the writing and the coverage, how do you reconcile this? LWN isn't a news site staffed with reporters any more than Fox News is and it is much more closely defined by being a personal infoblog these days. Phoronix, Linuxiac, and DistroWatch are a few examples closer to actual news without trying to lead the reader. The Register, even with snark, is more representative of a news site these days. I used to be a fan of Jonathan and LWN but in recent times, he seems less interested in being a reporter and more interested in being a Rust evangelist. That isn't a source I can trust.
- newpavlov 2y ago>Changing C interfaces will often have implications for the Rust code and may break it; somebody will the have to fix the problems. Torvalds said that, for now, breaking the Rust code is permissible, but that will change at some point in the future. I think this is the main technical change needed from the Linux kernel. It needs a layer of quasi-stable well documented subsystem APIs, which ideally would be "inherently safe" or at least have clear safe usage contracts. And it's fine for these interfaces to have relaxed stability guarantees in the early (pre-1.0, if you will) experimental stages. Changing them would involve more work and synchronization (C maintainers would not be able to quickly "refactor" these parts), but it's a familiar problem for many large projects. It's the only reasonable point from the infamous tantrum by Ted Ts'o during the Rust for filesystems talk, everything else, to put it mildly, was a really disappointing behavior from a Linux subsystem maintainer.
- BD103 2y agoFor those curious, this is the link[0] to the filesystems talk with the relevant timestamp. A bit more was discussed in this[1] article as well about Wedson Almeida Filho leaving. [0]: https://youtu.be/WiPp9YEBV0Q?t=1529 https://youtu.be/WiPp9YEBV0Q?t=1529 [1]: https://lwn.net/Articles/987635/ https://lwn.net/Articles/987635/
- josephcsible 2y agoWhy do we need quasi-stable anything within the kernel? Wouldn't a much better long-term solution be changing the rule to "break whatever APIs you want, but you have to fix all of the in-tree Rust uses too"?
- newpavlov 2y agoThe problem is that some high-profile people who want to preserve their right to "break whatever", do not want to shoulder responsibility of fixing Rust code which depends on the broken stuff. Even worse, they even do not want to explain and document semantics of existing APIs (sic)! See the video linked in the sibling comment. Speaking more broadly, freely breaking stuff in large projects is dangerous, since fixing stuff may require a more specialized expertise and knowledge, e.g. being well-versed in Rust safety rules, knowing some obscure information about hardware behavior, or being aware about some tricky invariant which must be preserved by the code. This is why changes in API boundaries often require synchronization between different teams.
- Waterluvian 2y agoI’ve read many times that a goal is to see if the use of Rust can work out in the kernel. What does this experiment for? What exactly is the evaluation? What are some example findings, both pro and con?
- steveklabnik 2y agoYou can find the home of the project here: https://rust-for-linux.com/ https://rust-for-linux.com/ Linus has been talking publicly over the last few years about how it’s getting harder and harder to find maintainers. There are various reasons for this, but C is part of the problem. If there are newer technologies that would be appropriate for the kernel, they should be investigated. At the same time, more and more downstream users of the kernel have been adopting Rust, and more kernel devs have been checking out Rust and have liked what they’ve seen. Many also don’t, to be clear, but the point is that a group of people were willing to put in the work to give Rust a real shot, and so did some initial work to sketch it out. Linus agreed to give it a try, but there are some caveats: Rust code cannot hold up improvements to the C code. Changes to the C are allowed to break the Rust, in other words. Then, it was discussed that the right first place to try Rust would be in driver code. This has the advantage of being a real project, but also sidesteps another issue: today, Rust doesn’t support every platform Linux does. Drivers are platform specific, so you just simply only write drivers for platforms Rust supports. So far, there have been some successes: some example drivers have been written. There’s also been some struggles: there are some experimental features of Rust and its standard library that the code relies on. But the Rust project has committed to trying to get those finished sometime soon, so that’s not a permanent issue. There have also been some… skepticism of both Rust and the experiment by some members of the kernel development community, and that’s caused some problems. Hopefully those can be worked out too.
- Waterluvian 2y agoThanks for the thorough details. That really helped my mental model of the topic. > ...some experimental features of Rust and its standard library that the code relies on. In my work I've experienced this, which can cause a sort of inversion where usage of experimental (or non-documented) features become so relied upon that I lose most control over how the experiment might resolve (ie. sorry, now it must find its way into main). Any concerns of the same kind of thing?
- ristos 2y agoCan anyone explain to me why these two issues aren't considered deal breakers for introducing Rust into the kernel? 1. It doesn't map almost 1:1 to assembly the way C does, so it's not inherently clear if the code will necessarily do what it says it does. That seems questionable for something as important as a kernel and driver. 2. Only one real Rust compiler, that's a recursive compiler, which reminds me of the Trusting Trust problem: https://dl.acm.org/doi/abs/10.1145/358198.358210 https://dl.acm.org/doi/abs/10.1145/358198.358210
- jcranmer 2y ago> 1. It doesn't map almost 1:1 to assembly the way C does, so it's not inherently clear if the code will necessarily do what it says it does. As someone who works on a C compiler, I will tell you that Rust maps marginally better 1:1 to assembly than C does. No major C compiler goes 1:1 to assembly; it all gets flushed into a compiler IR that happily mangles the code in fun and interesting ways before getting compiled into the assembly you get at the end. Rust code does that too, but at least Rust doesn't pull anything silly on you like the automatic type promotion that C does. If C maps 1:1 to assembly in your view, then (unsafe) Rust does; if Rust doesn't map 1:1 to assembly, nor does C. It's as simple as that.
- ristos 2y agoI get that GCC and Clang does all sorts of optimizations, but doesn't unoptimized C map closely to 1:1? I've heard it being called a high level assembly that maps closely to assembly many times at this point, it makes sense to me why people would say that. > If C maps 1:1 to assembly in your view, then (unsafe) Rust does; if Rust doesn't map 1:1 to assembly, nor does C. It's as simple as that. I thought the mapping issue was unrelated to the borrow checker, and that it's possible to write a borrow checker for a restricted subset of C. I thought the thing that was making it not map 1:1 was actually all of the extra features in Rust, like the ADTs and async and all of that. Is that not actually the case?
- josefx 2y ago> but doesn't unoptimized C map closely to 1:1 What is a variable in C? A register? A memory location? The language doesn't have basic concepts needed to map anything 1:1 to assembly and the ones it has usually come with half a dozen standards worth of required error handling, because having single instruction features like sqrt return -1 on error wasn't enough.
- duped 2y agoTotally unrelated comment to my previous one I think it's folly to encode the semantics of APIs in the Rust type system and memory model and that's the impedance mismatch that has people riled up. unsafe code isn't incorrect code, and trying to add abstraction where there wasn't one before is encoding principles where they didn't previously exist and should be an obvious problem. I've written a lot of systems-type Rust using unsafe and I think the design pattern of -sys bindings and then a higher level safe wrapper is mostly incorrect because callers should always use the -sys bindings directly. It's more workable and doesn't suffer from changes that the detractors complain about.
- ozgrakkurt 2y agoTotally agree with this. In performance critical code this is a problem always. Even zstd bindings in rust is slow compared to directly using sys version. People don’t want to acknowledge this but it is the truth. Not sure why this comment is flagged. I have been writing performance critical code for production in rust for several years now. And generics/traits usage and needless atomics/copy/abstraction is very much an issue. Biggest concrete one is memory allocation api and work stealing everywhere kind async apis. It is understandable these make sense for general development but they are just a problem when doing performance critical and low level code
- duped 2y agoMy point is not about performance at all, you should raise that as an issue in the zstd wrapper crate.
- deivid 2y agoNot exactly rust-in-kernel, but I've been using Aya[0] to write ebpf programs in Rust and it is quite nice. The verifier is still a bit trigger-happy with some constructs, but it is manageable. [0]: https://aya-rs.dev/ https://aya-rs.dev/
- pjmlp 2y agoRegardless of what upstream decides, downstream on ChromeOS and Android land, it is already being used.
- IshKebab 2y ago> he also is unable to work with Rust until a suitable compiler is available in RHEL What an arse. Best to ignore these people.