--- title: "Rust no Linux Kernel: O Avanço da Linguagem no Núcleo em 2026" url: "https://rustlang.com.br/blog/rust-linux-kernel-2026/" markdown_url: "https://rustlang.com.br/blog/rust-linux-kernel-2026.MD" description: "Acompanhe o progresso do Rust no kernel Linux em 2026: novos drivers, abstrações de subsistemas e o impacto na segurança do sistema operacional." date: "2026-03-23" author: "Equipe Rust Brasil" --- # Rust no Linux Kernel: O Avanço da Linguagem no Núcleo em 2026 Acompanhe o progresso do Rust no kernel Linux em 2026: novos drivers, abstrações de subsistemas e o impacto na segurança do sistema operacional. ## Introdução A integração do Rust no kernel Linux é, sem exagero, uma das transformações mais significativas na história do desenvolvimento de sistemas operacionais. Desde a inclusão inicial do suporte a Rust no Linux 6.1, em dezembro de 2022, o progresso tem sido constante e acelerado. Em 2026, o Rust deixou de ser um experimento no kernel para se tornar uma ferramenta de produção usada em subsistemas críticos. Neste artigo, vamos acompanhar a trajetória do Rust no kernel Linux, analisar o estado atual de drivers e subsistemas, examinar exemplos de código e discutir os desafios e o futuro dessa integração histórica. ## Histórico: Da Proposta à Inclusão ### As Origens (2020–2022) A ideia de usar Rust no kernel Linux ganhou tração em 2020, quando Linus Torvalds expressou abertura para experimentar a linguagem em drivers e módulos não críticos. O projeto **Rust for Linux**, liderado por Miguel Ojeda, começou a desenvolver as abstrações necessárias para que código Rust pudesse interagir de forma segura com a infraestrutura existente em C. Em dezembro de 2022, o Linux 6.1 marcou o momento histórico: o merge da infraestrutura básica de Rust no kernel. Não havia ainda drivers em produção, mas a base estava pronta — suporte ao compilador, sistema de build e abstrações fundamentais. ### Evolução nas Versões Seguintes (2023–2025) - **Linux 6.2–6.4**: Melhorias nas abstrações, suporte a módulos loadable em Rust - **Linux 6.5–6.8**: Primeiros drivers experimentais para NVMe e dispositivos de rede - **Linux 6.9–6.12**: Expansão significativa das APIs disponíveis para código Rust - **Linux 6.13+** (2025): Drivers Rust aceitos para subsistemas de produção A [retrospectiva de Rust em 2025](/blog/rust-2025-review/) documenta em detalhe os marcos alcançados nesse período. ## Estado Atual em 2026: Subsistemas com Suporte Rust Em 2026, o kernel Linux conta com suporte a Rust em múltiplos subsistemas, incluindo: ### Drivers de Armazenamento (NVMe) O driver NVMe em Rust foi um dos primeiros a demonstrar viabilidade em produção. Implementado como alternativa ao driver C existente, ele mostrou: - **Zero regressões** de performance em benchmarks de I/O - **Eliminação de classes inteiras** de vulnerabilidades de memória - **Código significativamente mais legível** para novos contribuidores ### Drivers de Rede Drivers de interface de rede em Rust começaram como prova de conceito e evoluíram para soluções de produção. Em 2026, há drivers Rust funcionais para adaptadores Intel e Realtek, com suporte a features como: - Offloading de checksums - RSS (Receive Side Scaling) - Gerenciamento assíncrono de pacotes ### Drivers GPU e DRM O subsistema DRM (Direct Rendering Manager) recebeu abstrações Rust que permitem a escrita de drivers de GPU. O projeto **Nova** (driver Rust para GPUs NVIDIA) avançou substancialmente, utilizando as garantias de segurança de Rust para simplificar o gerenciamento de memória de GPU — historicamente uma das áreas mais propensas a bugs. ### Filesystems Experimentos com implementações de filesystems em Rust demonstraram que é possível escrever código de filesystem seguro e performático. Protótipos de ext2 em Rust servem como base educacional e referência para futuros desenvolvimentos. ## Abstrações Rust para APIs do Kernel ### O Desafio da Interoperabilidade O kernel Linux possui milhões de linhas de código em C com APIs que evoluíram ao longo de décadas. A integração de Rust não significa reescrever tudo, mas criar **bindings seguros** — camadas de abstração que traduzem as APIs C em interfaces Rust idiomáticas. ### Safe Wrappers sobre Unsafe O padrão fundamental é encapsular operações `unsafe` em abstrações seguras: ```rust // Abstração segura para alocação de memória no kernel pub struct KBox { ptr: NonNull, } impl KBox { /// Aloca memória no kernel com GFP_KERNEL pub fn new(value: T) -> Result { // O unsafe é encapsulado aqui, uma vez let ptr = unsafe { let raw = bindings::kmalloc( core::mem::size_of::(), bindings::GFP_KERNEL, ); if raw.is_null() { return Err(AllocError); } let ptr = raw as *mut T; core::ptr::write(ptr, value); NonNull::new_unchecked(ptr) }; Ok(Self { ptr }) } pub fn as_ref(&self) -> &T { // Seguro: ptr é sempre válido enquanto KBox existe unsafe { self.ptr.as_ref() } } } impl Drop for KBox { fn drop(&mut self) { unsafe { core::ptr::drop_in_place(self.ptr.as_ptr()); bindings::kfree(self.ptr.as_ptr() as *mut core::ffi::c_void); } } } ``` ### Registro de Drivers O framework Rust no kernel oferece macros para registro de drivers, tornando o processo declarativo: ```rust module! { type: MeuDriver, name: "meu_driver_rust", author: "Desenvolvedor Rust", description: "Driver de exemplo em Rust", license: "GPL", } struct MeuDriver { // estado do driver } impl kernel::Module for MeuDriver { fn init(_module: &'static ThisModule) -> Result { pr_info!("Driver Rust carregado com sucesso!\n"); Ok(Self {}) } } impl Drop for MeuDriver { fn drop(&mut self) { pr_info!("Driver Rust descarregado.\n"); } } ``` ## Benefícios de Segurança de Memória no Kernel Os bugs de segurança de memória em código C do kernel são responsáveis por uma parcela significativa das vulnerabilidades do Linux. Estudos do Google e da Microsoft indicam que **60–70% das vulnerabilidades de segurança** em software de sistemas são causadas por problemas de memória. O Rust elimina, em tempo de compilação, as seguintes classes de bugs: - **Use-after-free**: O sistema de ownership impede uso de memória após liberação - **Buffer overflow**: Verificação de limites em tempo de compilação e execução - **Double free**: O sistema de ownership garante que cada valor tem exatamente um dono - **Data races**: O sistema de tipos impede acessos concorrentes inseguros - **Null pointer dereference**: O tipo `Option` substitui ponteiros nulos Para empresas que dependem do kernel Linux em infraestrutura crítica, a adoção de Rust representa uma redução mensurável na superfície de ataque. Se você tem interesse em [segurança com Rust](/artigos/seguranca-rust/), temos um artigo dedicado ao tema. ## Desafios da Adoção ### Curva de Aprendizado O kernel Linux possui uma comunidade de desenvolvedores majoritariamente experiente em C. A adoção de Rust exige: - Aprendizado de conceitos como ownership, borrowing e lifetimes - Familiaridade com o ecossistema de ferramentas Rust (cargo, rustup, clippy) - Adaptação a um paradigma diferente de gerenciamento de memória Para quem está nessa transição, nosso guia sobre [ownership e borrowing](/tutoriais/ownership-borrowing/) e o artigo sobre [lifetimes em profundidade](/artigos/lifetimes-em-profundidade/) são excelentes pontos de partida. ### Interoperabilidade com C A integração entre código Rust e C no kernel não é trivial. Desafios incluem: - **Geração de bindings**: Ferramentas como `bindgen` precisam de adaptações para o ambiente do kernel - **Diferenças de ABI**: Garantir compatibilidade entre estruturas de dados C e Rust - **Callbacks**: Traduzir ponteiros de função C em closures Rust de forma segura - **Macros do kernel**: Muitas APIs do kernel são implementadas como macros C, que não têm tradução direta para Rust ### Ferramentas e Build System O kernel utiliza o Kbuild/Kconfig como sistema de build, que precisou ser estendido para suportar compilação de módulos Rust. Em 2026, a integração está madura, mas ainda exige versões específicas do compilador Rust (nightly em alguns casos). ## Exemplos de Código: Unsafe vs Safe Wrappers A filosofia no kernel é minimizar a superfície de código `unsafe`, concentrando-o em abstrações bem auditadas: ```rust // ❌ Código inseguro espalhado (estilo C traduzido) fn processar_buffer_inseguro(ptr: *mut u8, len: usize) { unsafe { for i in 0..len { let byte = *ptr.add(i); // Sem verificação de limites! // processar byte... } } } // ✅ Código Rust idiomático com abstração segura fn processar_buffer_seguro(dados: &[u8]) { for byte in dados { // Verificação de limites garantida pelo compilador // processar byte... } } ``` Essa abordagem permite que a maior parte do código de drivers seja escrita sem `unsafe`, delegando as operações sensíveis a abstrações testadas e auditadas. Nosso artigo sobre [unsafe Rust](/artigos/unsafe-rust/) detalha quando e como usar `unsafe` de forma responsável. ## O Futuro: Mais Subsistemas e Componentes Críticos ### Próximos Passos (2026–2028) As direções futuras para Rust no kernel incluem: - **Expansão para subsistemas de scheduling**: Componentes de agendamento de processos em Rust - **Implementações de protocolo de rede**: Stack TCP/IP com módulos Rust - **Drivers para hardware emergente**: Aceleradores de IA, dispositivos CXL - **Ferramentas de verificação formal**: Aproveitando o sistema de tipos de Rust para provas de correção ### A Possibilidade de Reescrita de Componentes Críticos Embora a reescrita completa do kernel em Rust não seja viável nem desejável, há discussões sobre reescrever componentes críticos de segurança. Subsistemas como gerenciamento de memória virtual, firewalls (netfilter) e criptografia são candidatos naturais, dada a sensibilidade a bugs de memória. ## Conclusão O Rust no kernel Linux em 2026 já não é mais uma promessa — é realidade. Com drivers em produção, abstrações robustas e uma comunidade crescente de desenvolvedores contribuindo código Rust para o kernel, estamos presenciando uma mudança de paradigma no desenvolvimento de sistemas operacionais. Para desenvolvedores Rust interessados em contribuir, o momento é oportuno. O projeto Rust for Linux tem documentação extensiva, issues marcadas para iniciantes e uma comunidade acolhedora. Se você quer explorar o desenvolvimento de sistemas em Rust, confira nossos artigos sobre [Rust para sistemas embarcados](/artigos/rust-para-embarcados/) e [Rust vs C](/artigos/rust-vs-c/) para entender as vantagens da linguagem nesse domínio. A segurança de memória no nível do kernel não é apenas uma melhoria técnica — é uma questão de segurança para bilhões de dispositivos que rodam Linux. E o Rust está provando ser a ferramenta certa para esse desafio. --- Se você se interessa por programação de sistemas, confira também: - Zig Brasil — conheça Zig, outra linguagem de sistemas moderna que busca substituir o C - Go Brasil — Go para ferramentas de sistemas e infraestrutura em português