Greg Kroah-Hartman, who is responsible for maintaining the stable and 'staging' branches of the Linux kernel and serves as the maintainer for 16 subsystems, delivered a talk at the Rust Week 2026 conference, discussing how the Rust language can help prevent vulnerabilities in the kernel arising from typical developer errors in C related to memory management, locks, error handling, and working with untrusted data. The main advantage of Rust is its ability to identify such errors at the assembly stage rather than through human code reviews. However, Rust is not seen as a panacea that can solve all issues, and there are no plans to rewrite the kernel in Rust; gradual adoption of Rust is expected through its use in new drivers and subsystems.<\/p>\n
As an example of kernel errors that could have been avoided with Rust, a Bluetooth subsystem issue that went unnoticed for 15 years and a problem in the Xen hypervisor were mentioned. In the first case, the developer dereferenced a pointer without checking it, while in the second case, a lock was forgotten in the error handling code.
\nAccording to Greg, most kernel errors are caused by such small oversights that accumulate over time and emerge as vulnerabilities. In Rust, many of these issues are prevented by the compiler; for instance, Rust abstractions for locks in the kernel allow access to internal structure pointers only after acquiring the corresponding lock, which is released automatically. Without acquiring the lock, accessing structure pointers in Rust is impossible. <\/p>\n
Greg believes that such features of Rust could have prevented 60% of the errors identified in the kernel, and the checks performed by the compiler would save maintainers time discussing the correctness of error handling and the justification for placing locks properly. Moreover, the introduction of Rust support has already positively impacted the C code in the kernel by tidying up C code and interfaces, as well as adopting some development practices (for example, scoped locking has been implemented).<\/p>\n
Thanks to the type system that ensures adherence to specified rules and the implementation of continuous integration systems that check code at the build stage, reviewers of changes in Rust can focus on evaluating the logic of operations rather than tracking manipulations with resources. The use of Rust also allows for a more careful approach to data coming from hardware or external systems. This is achieved through a clear distinction between trustworthy and untrustworthy data at the type system level: a developer only needs to perform an analysis when transitioning from an untrusted to a trusted state.<\/p>\n
Recently, the team responsible for kernel security has been publishing about 13 vulnerability reports every day, which, compared to the previous dynamics of vulnerability detection, feels like some kind of madness (for example, 277 vulnerability reports in the kernel were published just yesterday). According to Greg, using Rust is one of the real ways to reduce the number of errors in the kernel caused by traditional mistakes in error handling and resource management. Support for Rust in the kernel has already gone beyond experimentation and was recognized as a standard feature of the kernel at the end of last year. <\/p>\n
![\"Play](\"https:\/\/img.youtube.com\/vi\/0vhGWclF7LU\/hqdefault.jpg\")
\r\n