Histórico do kernel Linux: decisões que ficaram
Entenda como GPL, microkernel, Git e o modelo LTS, da versão 0.01 à 7.x, ainda afetam servidores Linux e suas escolhas de manutenção hoje.
A história resumida do kernel Linux
A história do kernel Linux vai da versão 0.01, em setembro de 1991, à série 7.x, que arranca atualmente em servidores. A lista de versões é a parte menos interessante. Um pequeno número de decisões definiu a forma do projeto, e cada uma ainda tem consequências numa máquina que alugue esta tarde. A razão pela qual foi necessário um novo kernel em 1991 faz parte de uma história mais longa sobre Unix, o licenciamento da AT&T e o processo judicial que atrasou o BSD.
As datas e os números de versão apresentados aqui vêm de kernel.org e do histórico de versões que o site publica. O estado atual, em 13 de novembro de 2026, é o seguinte: a versão 7.0 foi lançada em 12 de abril de 2026, a 7.1 em 14 de junho de 2026, a 7.2 em meados de agosto de 2026 e a 7.3 em 18 de outubro de 2026. O kernel.org lista a 7.4-rc2 como versão mainline e a 7.3.4 como a versão estável atual. A ramificação 7.2 chegou ao fim de vida com a 7.2.15, em 1 de novembro de 2026.
Por que a escolha da GPL em 1992 ainda é importante
A versão 0.01 foi publicada em 17 de setembro de 1991 sob uma licença que Torvalds escreveu. Ela exigia a distribuição do código-fonte e acrescentava uma linha ainda mais importante: "You may not distribute this for a fee, not even 'handling' costs." Em 1991, o software era distribuído em disquetes, e copiar e enviar disquetes tinha custos. Essa cláusula tornava impossível uma distribuição comercial do Linux.
Ele mudou a licença. A migração para a GNU General Public License (GPL) foi anunciada nas notas de versão da 0.12 em janeiro de 1992 e entrou em vigor em 1 de fevereiro de 1992. A versão 0.95, em março de 1992, foi a primeira versão publicada sob essa licença. Todas as empresas criadas posteriormente com base no Linux dependem dessa mudança.
O kernel está sob a GPL versão 2 apenas e nunca passou para a versão 3. Torvalds recusou a mudança em 2007, principalmente por causa da regra anti-tivoização da GPLv3. Essa regra exige que as informações necessárias para instalar versões modificadas do código abrangido sejam fornecidas com um dispositivo de consumo, exceto quando nem o fornecedor nem terceiros podem instalar código modificado, como no caso de código instalado em ROM. Ele considerava o hardware bloqueado uma decisão comercial do próprio fabricante. Em 2017, os desenvolvedores do kernel publicaram a Kernel Enforcement Statement, que incorpora, ainda assim, uma parte da GPLv3: quem recebe uma primeira notificação de violação do titular dos direitos de autor e corrige a violação no prazo de 30 dias recupera permanentemente a licença, em vez de a perder na primeira infração.
Num servidor, isso tem duas consequências. O binário do kernel que arranca inclui o direito ao código-fonte correspondente. Portanto, ninguém pode fornecer um kernel Linux que não possa ser inspecionado ou recompilado. Além disso, o aviso de direitos de autor do kernel declara que a licença não abrange os programas de utilizador que usam os serviços do kernel através de chamadas de sistema normais. É por isso que bases de dados proprietárias e agentes de monitorização são distribuídos para Linux sem causar problemas de licenciamento. Uma licença permissiva cria uma pressão oposta, e vale a pena compreender essa diferença antes de escolher uma plataforma: consulte Linux e FreeBSD como plataformas de servidor.
Por que o kernel monolítico venceu na prática
Em 29 de janeiro de 1992, Andrew Tanenbaum publicou uma mensagem intitulada "LINUX is obsolete" no newsgroup comp.os.minix. Ele fez duas afirmações. Kernels monolíticos, nos quais drivers e sistemas de arquivos executam dentro de um único espaço de endereçamento privilegiado, eram um projeto dos anos 1970, enquanto microkernels, nos quais essas partes executam como processos comuns, eram o futuro. E o Linux estava preso ao Intel 386, portanto nunca seria portável.
A afirmação sobre portabilidade foi respondida com portabilidade para outras arquiteturas. Quando a versão 1.2 foi lançada, em março de 1995, as versões para DEC Alpha, MIPS, SPARC e a família Motorola 68000 ainda estavam em desenvolvimento. A versão 2.0, em junho de 1996, foi a primeira release estável a oferecer suporte ao Alpha de 64 bits junto com o 386. No início de 1997, o SPARC também havia sido integrado.
A afirmação sobre o projeto foi respondida com um compromisso. O Linux nunca se tornou um microkernel. Ele ganhou módulos de kernel carregáveis: arquivos de objeto que você insere em um kernel em execução e remove novamente, permitindo que um driver seja distribuído separadamente do binário do kernel.
lsmod | head
modinfo virtio_net | head -5lsmod lista o que está carregado no momento. modinfo exibe o arquivo de origem do módulo e os parâmetros que ele aceita. Em um servidor virtual, a maior parte do caminho de armazenamento e rede é composta por módulos. Por isso, uma única imagem de kernel inicializa em hardware que ela nunca encontrou. O kernel apenas anuncia o novo hardware. Um daemon do user space decide qual módulo carregar e qual nome atribuir ao dispositivo. Foi assim que o gerenciamento de dispositivos passou a fazer parte do sistema de inicialização. Isso também explica em parte por que o systemd se tornou difícil de evitar.
Os módulos ofereceram essa flexibilidade sem o custo do projeto de microkernel. Isolar um driver em seu próprio processo exige pagar o custo de uma troca de contexto e de uma mensagem em cada chamada. Em 1992, esse custo era alto.
O custo mantido pelo Linux é aquele que você precisa considerar: um módulo executa com privilégios completos do kernel. Portanto, um módulo com defeito pode derrubar a máquina inteira, em vez de apenas um processo. O problema aparece principalmente com módulos externos à árvore principal. Um driver de fornecedor que não está no mainline precisa ser recompilado para cada novo kernel. É isso que o DKMS faz durante uma atualização. Quando essa compilação falha, o dispositivo simplesmente não está disponível depois da reinicialização.
Por que o SMP levou quinze anos para ser concluído
O Linux 2.0, em junho de 1996, foi o primeiro kernel estável a oferecer suporte a multiprocessamento simétrico (SMP), ou seja, mais de uma CPU executando um único kernel. A primeira implementação usava um único lock, o big kernel lock (BKL), de modo que apenas um processador pudesse executar código do kernel por vez. Portanto, uma segunda CPU ajudava uma carga de trabalho que fazia cálculos no espaço de usuário, mas ajudava muito pouco uma carga de trabalho composta por system calls, porque elas ficavam enfileiradas atrás do mesmo lock.
A remoção desse lock levou quinze anos. Os usos restantes foram convertidos para locking de granularidade fina, em grande parte por Arnd Bergmann, e o BKL foi removido na versão 2.6.39, lançada em 18 de maio de 2011. O scheduler avançou na mesma escala lenta: o scheduler O(1) na versão 2.6.0, o Completely Fair Scheduler (CFS) a partir da versão 2.6.23, em 2007, e o EEVDF, que substituiu o CFS na versão 6.6, em outubro de 2023.
Esse trabalho explica por que um plano com 4 vCPUs é algo comum hoje. Ele também mostra um limite que vale a pena conhecer. Em um servidor virtual compartilhado, o seu kernel agenda suas threads, e o hypervisor agenda o seu kernel. Execute top e leia o campo %st. Steal time é o tempo de CPU que o seu kernel estava pronto para usar, mas que o host entregou a outro guest. Nenhum ajuste dentro do seu kernel pode recuperar esse tempo.
Por que a série 2.6 mudou a forma como o kernel é compilado
Antes da 2.6, os números de versão vinham em pares. Um segundo número par indicava uma série estável (2.4); um número ímpar indicava desenvolvimento (2.5). A versão 2.4 foi lançada em 4 de janeiro de 2001 e a 2.6 em 17 de dezembro de 2003, por isso os utilizadores esperaram quase três anos pela série estável seguinte. As distribuições não podiam esperar e fizeram backport de correções. Dois fornecedores que distribuíam a versão "2.4" podiam fornecer kernels separados por milhares de patches.
A separação foi abandonada depois da 2.6. Atualmente, a mainline abre uma merge window de cerca de duas semanas, aceita trabalho novo, depois executa release candidates até o desenvolvimento estabilizar e lança uma nova versão a cada 9 a 10 semanas, conforme continua documentado em kernel.org. A outra metade do modelo surgiu em 4 de março de 2005, com o primeiro lançamento da stable tree: uma atualização que continha apenas correções para a 2.6.11, mantida por Greg Kroah-Hartman e Chris Wright. A stable tree aceita correções e recusa funcionalidades.
Um efeito secundário foi o número da versão deixar de ser uma promessa. As versões 3.0, 4.0, 5.0 e 7.0 não são reescritas. Torvalds aumenta o primeiro número quando o segundo cresce o suficiente para o incomodar, razão pela qual a 7.0 sucedeu à 6.19 em abril de 2026. Para um servidor, o que importa é qual branch a distribuição acompanha e se essa branch ainda recebe correções.
Como a ruptura com o BitKeeper deu origem ao git em abril de 2005
A partir de fevereiro de 2002, o kernel foi desenvolvido no BitKeeper, um sistema proprietário de controle de versão distribuído da empresa BitMover, de Larry McVoy, começando pela série 2.5. A BitMover concedeu aos desenvolvedores do kernel uma licença gratuita com condições: eles não podiam trabalhar em uma ferramenta de controle de versão concorrente nem fazer engenharia reversa do BitKeeper. Muitos desenvolvedores não gostavam de desenvolver um kernel livre com uma ferramenta cujo código não podiam ler.
A ruptura ocorreu em abril de 2005, depois que Andrew Tridgell demonstrou um programa que se comunicava com repositórios BitKeeper. A BitMover considerou isso engenharia reversa e retirou a licença gratuita. O kernel ficou sem seu sistema de controle de versão no meio de um ciclo de desenvolvimento.
O trabalho no git começou em abril de 2005. Torvalds anunciou a ruptura com o BitKeeper em 6 de abril. Em 7 de abril, o git já era autossuficiente, o que significa que o próprio histórico do git já era mantido no git. Torvalds anunciou o primeiro merge bem-sucedido do git em 17 de abril. Em junho de 2005, o git gerenciou o lançamento da versão 2.6.12. Pouco depois, Torvalds transferiu a manutenção para Junio Hamano e voltou ao kernel.
O design surgiu diretamente do problema: milhares de colaboradores e mantenedores que fazem pull uns dos outros por uma rede em que ninguém confia. Cada objeto recebe um nome baseado no hash do seu conteúdo, portanto alterar um único byte do histórico antigo altera o nome de cada commit posterior. Por isso, um clone é uma evidência, não uma afirmação. Cada pipeline de deploy, cada repositório de configuração, o host de código para o qual a maioria das equipes faz push e o servidor git que você pode executar por conta própria surgiram de uma discussão sobre licenciamento envolvendo um kernel.
O que o modelo LTS promete e o que não promete
Mainline não é a versão que você executa. Uma versão mainline é substituída 9 a 10 semanas depois. A árvore stable recebe correções até a próxima versão mainline, a menos que uma ramificação seja mantida como longterm. As ramificações longterm, normalmente chamadas de LTS, recebem correções durante anos, e são elas que muitas distribuições usam como base.
A versão 2.6.32, lançada em dezembro de 2009, foi onde o modelo provou seu valor. RHEL 6, Debian 6, SUSE Linux Enterprise 11 SP1 e Ubuntu 10.04 LTS a distribuíram, e a ramificação foi mantida até março de 2016, mais de seis anos depois de seu lançamento. A Red Hat foi além e manteve seu kernel baseado em 2.6.32 com seus próprios backports até o RHEL 6 sair da fase de manutenção em 2020. Ela ainda vende correções de segurança selecionadas e correções urgentes de bugs para o RHEL 6 por meio de um complemento pago Long-Life, com contratos anuais até o fim de 2030. Reproduzir gratuitamente esse suporte de uma década é exatamente o motivo pelo qual o CentOS existia e o Rocky Linux e o AlmaLinux o substituíram.
A promessa mudou mais de uma vez. Primeiro eram dois anos; depois, seis anos para algumas ramificações. Em 2023, os maintainers do stable reduziram o padrão novamente para dois anos, porque fazer backport para árvores antigas consome tempo dos maintainers e as ramificações antigas recebem poucos testes reais. Em 25 de fevereiro de 2026, Greg Kroah-Hartman publicou projeções mais longas novamente, após conversar com as empresas que dependem dessas ramificações, mas os novos kernels longterm ainda costumam começar com um fim de vida projetado de dois anos.
Os dados por trás deste gráfico
[
{
"kernel": "5.10",
"released": "2020-12-13",
"eol_projected": "Dec 2026",
"maintained_for": 6.0
},
{
"kernel": "5.15",
"released": "2021-10-31",
"eol_projected": "Dec 2026",
"maintained_for": 5.1
},
{
"kernel": "6.1",
"released": "2022-12-11",
"eol_projected": "Dec 2027",
"maintained_for": 5.0
},
{
"kernel": "6.6",
"released": "2023-10-29",
"eol_projected": "Dec 2027",
"maintained_for": 4.2
},
{
"kernel": "6.12",
"released": "2024-11-17",
"eol_projected": "Dec 2028",
"maintained_for": 4.1
},
{
"kernel": "6.18",
"released": "2025-11-30",
"eol_projected": "Dec 2028",
"maintained_for": 3.1
}
]O kernel.org lista 6 ramificações longterm em outubro de 2026. A mais antiga, 5.10, terá recebido correções durante 6.0 anos quando chegar ao fim em Dec 2026. A mais nova, 6.18, tem execução projetada até Dec 2028, o que representa 3.1 anos de correções.
Interprete essas datas como projeções, não como um contrato. As projeções para 6.6 e 6.12 foram estendidas em fevereiro de 2026, mas uma ramificação que ninguém usa pode ser abandonada. Normalmente, sua distribuição faz essa escolha por você: Debian 13 distribui 6.12, e Ubuntu 26.04 LTS distribui 7.0. Essa diferença é o conteúdo prático de a questão do LTS contra a versão interim em um servidor e é o que realmente muda sob você quando você atualiza o Ubuntu 24.04 para o 26.04.
Uma armadilha decorre disso. uname -r no Ubuntu 24.04 exibe algo como 6.8.0-51-generic. Isso é uma base upstream com os próprios backports da distribuição, portanto o número informa onde a ramificação começou, mas não quais correções ela contém. Scanners que avaliam um kernel pela string de versão geram falsos alertas contra kernels de distribuições exatamente por esse motivo.
Sobre o que o kernel está a discutir neste momento
Há duas discussões em curso, e ambas dizem respeito a quem executa o trabalho.
O Rust entrou na infraestrutura na versão 6.1, em dezembro de 2022. Na versão 7.0, deixou de ser considerado experimental, pelo que as linguagens principais do kernel são C, assembly e Rust. A compilação com um compilador Rust estável já era suportada na versão 6.1: o Makefile define RUSTC_BOOTSTRAP=1 para ativar funcionalidades instáveis em compiladores estáveis. A discussão diz respeito à manutenção. Um maintainer de C que altere uma interface pode quebrar bindings Rust que não lê, e a discussão centra-se em quem tem a responsabilidade de os corrigir.
A segunda discussão diz respeito às contribuições feitas com IA. Sasha Levin propôs uma política em julho de 2025, depois de um volume crescente de patches assistidos por máquinas ter chegado às listas. O documento foi submetido em 6 de janeiro de 2026 e encontra-se agora na documentação do próprio processo do kernel, em docs.kernel.org/process/coding-assistants.html. Um agente de IA não pode adicionar uma tag Signed-off-by, porque essa linha certifica o Developer Certificate of Origin (DCO) e apenas uma pessoa pode fazer essa certificação. A documentação atual do kernel já não exige uma tag Assisted-by e encaminha os contribuidores para as orientações sobre conteúdo gerado por ferramentas. Ainda se espera que os contribuidores expliquem a utilização das ferramentas nas cover letters e nos changelogs. O código gerado tem de ser compatível com GPL-2.0-only. A pessoa que envia o patch revê-o e assume a responsabilidade por ele.
A pressão que está na origem da política é o tempo de revisão. Gerar um patch demora segundos, enquanto revê-lo pode ocupar uma tarde de um maintainer. Uma tag não resolve esse desequilíbrio. A assinatura humana preserva a proveniência: o histórico continua a registar quem assinou cada alteração, que é precisamente a propriedade que o DCO foi criado para proteger em 2004.
O que esse histórico significa para o servidor que você aluga
- A licença explica por que você pode ler e recompilar o kernel iniciado pelo seu provedor e por que software proprietário continua funcionando nele.
- O design monolítico explica por que um erro em um driver pode derrubar a máquina inteira e por que um módulo externo precisa ser recompilado a cada atualização do kernel.
- O modelo de releases explica por que o número da versão informa pouco, enquanto a branch e a data de fim de vida informam quase tudo.
- O tipo de virtualização determina o que você pode fazer: no KVM, você inicia seu próprio kernel e carrega módulos, enquanto na virtualização por contêineres, que compartilha o kernel do host,
uname -rmostra a versão do host, e a permissão para usarmodprobeou alterar sysctls depende dos privilégios e da configuração concedidos pelo host.
FAQ
Por que o kernel Linux continua sob a GPLv2, e não sob a GPLv3?
Torvalds rejeitou a GPLv3 em 2007, principalmente por causa do requisito anti-tivoização, que exige informações de instalação para versões modificadas do código abrangido distribuídas com um dispositivo para consumidores, exceto quando nem o fornecedor nem terceiros podem instalar código modificado, como acontece com código instalado em ROM. Ele considera que o hardware bloqueado é uma decisão comercial do fabricante. Na prática, também é quase impossível alterar a licença, porque os direitos de autor do kernel pertencem a milhares de contribuidores e não existe um acordo de cessão ao qual recorrer. O kernel está licenciado apenas sob a GPL-2.0, portanto código oferecido exclusivamente sob a GPLv3 não pode ser integrado.
O kernel Linux é monolítico ou um microkernel?
É monolítico, com módulos carregáveis. Os controladores e os sistemas de ficheiros executam no espaço de endereçamento do kernel, e lsmod mostra os que estão carregados neste momento. O resultado é mais velocidade, por um lado, e um maior raio de impacto, por outro: um módulo com falhas pode provocar o panic de toda a máquina, enquanto num microkernel seria perdido apenas um processo. Esta distinção tornou-se menos rígida desde 1992, com sistemas de ficheiros FUSE no espaço do utilizador e programas eBPF que o kernel verifica antes de os executar.
Qual é a diferença entre os kernels mainline, stable e longterm?
Mainline é a árvore de Torvalds, publicada a cada 9 a 10 semanas, e é onde as novas funcionalidades são introduzidas primeiro. Stable parte de uma versão mainline e recebe correções de erros até à publicação da versão mainline seguinte, exceto quando o ramo é mantido como longterm. Os ramos longterm continuam a receber correções durante anos, e muitas distribuições baseiam neles os seus kernels. O kernel.org lista os ramos longterm atuais, com a data prevista de fim de vida de cada um.
O kernel Linux aceita código escrito por IA?
Sim, ao abrigo de uma política adotada em January 2026. A documentação atual do kernel já não exige uma etiqueta Assisted-by; espera-se que os contribuidores expliquem a origem do conteúdo gerado por ferramentas nas cartas de apresentação e nos changelogs. Um agente de IA não pode adicionar uma linha Signed-off-by, e o código gerado tem de ser compatível com a GPL-2.0-only. O responsável humano pela submissão assina o patch, o que significa que o analisou e assume a responsabilidade por ele ao abrigo do Developer Certificate of Origin.
Que versão do kernel devo executar num servidor?
Na quase totalidade dos casos, a versão mantida pela sua distribuição. Um kernel de distribuição é um ramo upstream com correções portadas de volta e os testes do fornecedor. É também a versão pressuposta pelas imagens do seu fornecedor e pelos acordos de suporte. Compile um kernel mainline mais recente quando precisar de um controlador ou funcionalidade específica. Antes de o adotar, confirme a data de fim de vida do ramo para o qual está a migrar.