Rust Agora e Permanente no Linux Kernel: O Fim do Experimento e o Comeco de Uma Nova Era

Ola HaWkers, uma decisao historica foi tomada no Kernel Maintainer Summit de 2025 em Toquio: o uso de Rust no Linux Kernel nao e mais experimental. Rust agora e uma linguagem oficialmente suportada e permanente no projeto mais importante do software de codigo aberto.

Esta mudanca tem implicacoes profundas para seguranca, desenvolvimento de drivers e o futuro da programacao de sistemas.

O Anuncio Oficial

Miguel Ojeda, lider do projeto Rust for Linux, confirmou a decisao:

"O experimento acabou. Rust veio para ficar."

Esta declaracao marca o fim de anos de debates e provas de conceito. O Rust passou de "vamos ver se funciona" para "esta e uma das nossas linguagens oficiais".

O Que Isso Significa na Pratica

Antes (experimental):

Rust era opcional e desabilitado por padrao
Poucos drivers usavam Rust
Suporte limitado de arquiteturas
Incerteza sobre o futuro

Agora (permanente):

Rust e uma opcao oficial para novos drivers
Subsistemas podem exigir Rust
Investimento de longo prazo garantido
Ecosistema de ferramentas dedicado

Por Que Rust no Kernel e Importante

O Problema dos Bugs de Memoria

Estudos mostram que a maioria das vulnerabilidades em sistemas operacionais sao causadas por problemas de memoria:

Estatisticas de bugs no Linux:

65-70% das vulnerabilidades sao relacionadas a memoria
Buffer overflows, use-after-free, double-free
Bugs que C permite mas Rust previne por design

Tipos de bugs que Rust elimina:

Buffer overflow
Use after free
Double free
Data races
Null pointer dereference

Rust Previne Por Design

// Exemplo de como Rust previne bugs comuns

// Em C, isso compila mas causa use-after-free:
// char* ptr = malloc(100);
// free(ptr);
// strcpy(ptr, "dados"); // BUG! Memoria ja liberada

// Em Rust, isso NAO COMPILA:
fn exemplo_seguro() {
    let dados = String::from("teste");
    let referencia = &dados;

    drop(dados); // Tenta liberar 'dados'

    // ERRO DE COMPILACAO: 'dados' foi movido/liberado
    // mas 'referencia' ainda existe
    // println!("{}", referencia); // Nao compila!
}

// A versao correta em Rust:
fn exemplo_correto() {
    let dados = String::from("teste");
    println!("{}", dados);
    // 'dados' e automaticamente liberado aqui
    // de forma segura
}

O compilador Rust garante que esses erros sejam detectados em tempo de compilacao, nao em producao.

Resultados Praticos no Kernel

Drivers Rust em Producao

Greg Kroah-Hartman, um dos principais mantenedores do kernel, relatou resultados positivos:

Observacoes:

Drivers em Rust estao provando ser mais seguros
Problemas de interacao Rust/C foram menores que esperado
Desenvolvedores estao adaptando-se bem

O Subsistema DRM

Dave Airlie, mantenedor do DRM (Direct Rendering Manager - sistema de graficos), fez um anuncio significativo:

"O projeto DRM esta a cerca de um ano de exigir Rust e proibir C para novos drivers."

Isso significa que em 2026-2027, novos drivers de GPU para Linux podem ser obrigatoriamente em Rust.

Drivers Ja Existentes em Rust

Drivers em desenvolvimento/producao:

Apple M1/M2 GPU (Asahi Linux)
Alguns drivers de rede
Drivers de bloco experimentais
Bindings para subsistemas

Como Escrever um Driver em Rust

Estrutura Basica

// Exemplo simplificado de modulo kernel em Rust

use kernel::prelude::*;
use kernel::miscdev::Registration;

module! {
    type: MeuDriver,
    name: "meu_driver",
    author: "Desenvolvedor",
    description: "Exemplo de driver em Rust",
    license: "GPL",
}

struct MeuDriver {
    _registration: Pin<Box<Registration<Self>>>,
}

impl kernel::Module for MeuDriver {
    fn init(_name: &'static CStr, _module: &'static ThisModule) -> Result<Self> {
        pr_info!("Driver Rust inicializado!\n");

        let registration = Registration::new_pinned(
            c_str!("meu_dispositivo"),
            (),
        )?;

        Ok(MeuDriver {
            _registration: registration,
        })
    }
}

impl Drop for MeuDriver {
    fn drop(&mut self) {
        pr_info!("Driver Rust finalizado!\n");
    }
}

Interoperabilidade com C

// Chamando funcoes C existentes do kernel

use kernel::bindings;

fn usar_funcao_c() -> Result {
    // Wrapper seguro em torno de funcao C
    // O Rust garante que chamamos corretamente

    // SAFETY: documentamos por que isso e seguro
    unsafe {
        bindings::alguma_funcao_c_do_kernel();
    }

    Ok(())
}

Desafios e Proximos Passos

Desafios Restantes

Toolchain:

Rust precisa ser instalado para compilar kernel
Versao especifica do compilador necessaria
Nem todas as arquiteturas suportadas ainda

Aprendizado:

Desenvolvedores C precisam aprender Rust
Novos padroes de codigo
Diferentes praticas de debugging

Arquiteturas Suportadas

Totalmente suportadas:

x86_64
ARM64
LoongArch
RISC-V (em progresso)

Em desenvolvimento:

ARM 32-bit
PowerPC
MIPS

Roadmap do Projeto

2025-2026:

Mais drivers de producao em Rust
Melhor documentacao
Mais bindings para subsistemas

2026-2027:

DRM possivelmente exigindo Rust
Novos subsistemas escolhendo Rust
Rust como default para alguns tipos de drivers

Impacto na Industria

Empresas Investindo em Rust

Quem esta contribuindo:

Google (Android, Chrome OS)
Microsoft (drivers Windows)
Samsung (dispositivos moveis)
Arm (drivers de SoC)
Red Hat (infraestrutura enterprise)

Demanda por Desenvolvedores

A adocao de Rust no kernel aumenta a demanda por profissionais:

Habilidades valorizadas:

Rust + conhecimento de kernel
Interoperabilidade Rust/C
Desenvolvimento de drivers
Seguranca de sistemas

Faixas salariais (EUA):

Kernel Developer (Rust): $180k - $300k
Systems Engineer (Rust): $150k - $250k
Driver Developer (Rust): $140k - $220k

Como Comecar com Rust no Kernel

Pre-requisitos

# 1. Instalar Rust
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# 2. Adicionar componentes necessarios
rustup component add rust-src
rustup component add llvm-tools-preview

# 3. Clonar o kernel
git clone https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git

# 4. Configurar com suporte a Rust
cd linux
make LLVM=1 rustavailable
make LLVM=1 menuconfig
# Habilitar: General setup -> Rust support

Recursos de Aprendizado

Documentacao oficial:

rust-for-linux.com
Documentacao no kernel source
Mailing list: rust-for-linux@vger.kernel.org

Exemplos praticos:

Asahi Linux (driver GPU M1)
Drivers de exemplo no kernel
Rust book (para fundamentos)

Reflexao: O Que Isso Significa Para o Futuro

A decisao de tornar Rust permanente no Linux e mais do que tecnica - e filosofica. Significa que:

💡 Insight: O projeto de software livre mais importante do mundo reconheceu que C sozinho nao e suficiente para os desafios de seguranca modernos.

Efeito Dominó

Se o Linux adotou Rust permanentemente, outros projetos seguirao:

Projetos observando:

FreeBSD (ja experimentando)
Outros kernels Unix-like
Sistemas embarcados
Firmware de dispositivos

Conclusao

A adocao permanente de Rust no Linux Kernel marca um momento historico na evolucao da programacao de sistemas. Nao e mais uma questao de "se" Rust sera relevante para sistemas - e uma questao de "como" nos adaptaremos.

Para desenvolvedores interessados em sistemas, kernel e seguranca, aprender Rust deixou de ser opcional. E para o ecossistema como um todo, isso significa sistemas mais seguros e confiaveis no futuro.

Se voce se interessa por como Rust esta transformando a industria, recomendo que de uma olhada em outro artigo: Microsoft Quer Eliminar Todo Codigo C e C++ Ate 2030 Usando Rust e IA onde voce vai descobrir como outras gigantes estao seguindo o mesmo caminho.