Como o Linux funciona: kernel, boot, processos e arquivos

O Linux funciona como uma ponte entre o hardware e os programas. No centro está o kernel, que controla processador, memória, discos, rede e dispositivos e decide quem usa cada recurso e em que momento. Em volta dele fica o chamado espaço de usuário: bibliotecas, serviços, terminal, interface gráfica e aplicativos. Os programas não falam direto com o hardware. Eles fazem pedidos ao kernel por meio de chamadas de sistema, e o kernel executa esses pedidos com segurança. Saber como o Linux funciona é, basicamente, entender essa divisão em camadas e o que acontece em cada uma delas, do boot até o momento em que você abre um navegador.

Daqui em diante, cada parte é explicada com exemplos práticos e comandos para você ver tudo isso acontecendo no seu próprio sistema.

Linux é o kernel, a distribuição é o sistema completo

Muita confusão some quando fica clara uma distinção: em sentido estrito, “Linux” é só o kernel, o núcleo criado por Linus Torvalds no início dos anos 1990 e mantido até hoje por milhares de desenvolvedores, sob a licença GPL versão 2. Sozinho, o kernel não tem terminal, gerenciador de arquivos nem área de trabalho.

O que a gente instala no dia a dia é uma distribuição (ou “distro”), como Ubuntu, Debian, Fedora, Linux Mint ou Arch. Ela junta o kernel com:

• ferramentas básicas do sistema (muitas vindas do projeto GNU, como o shell Bash e utilitários como ls, cp e grep);
• a biblioteca C padrão (normalmente a glibc), que faz a ponte entre os programas e o kernel;
• um sistema de inicialização (na maioria das distros atuais, o systemd);
• um gerenciador de pacotes para instalar e atualizar programas;
• opcionalmente, um servidor gráfico (Wayland ou X11) e um ambiente de desktop como GNOME, KDE Plasma ou Xfce.

Por isso duas distros podem parecer bem diferentes e, mesmo assim, rodar o mesmo kernel por baixo.

As camadas do Linux, de baixo para cima

Pense no sistema como um prédio. Cada andar só conversa com o andar imediatamente vizinho, e isso deixa tudo mais estável e seguro.

Como o kernel do Linux funciona por dentro

O kernel do Linux é monolítico e modular: as funções principais rodam todas no mesmo espaço privilegiado de memória, o que ajuda no desempenho, mas partes como drivers podem ser carregadas e descarregadas sob demanda, na forma de módulos. Veja as tarefas principais.

Gerenciamento de processos

Todo programa em execução vira um processo, com um número de identificação (PID). O kernel tem um escalonador que divide o tempo dos núcleos do processador entre todos os processos e threads. Ele troca de tarefa milhares de vezes por segundo, e é por isso que dá a impressão de tudo estar rodando ao mesmo tempo, mesmo com poucos núcleos.

No Linux, processos novos nascem de processos que já existem. Um processo se duplica (chamada fork) e a cópia carrega outro programa no lugar do seu (chamada exec). Quando você digita um comando no terminal, o shell faz exatamente isso. O resultado é uma árvore de processos, que você pode ver com pstree.

Gerenciamento de memória

Cada processo enxerga um espaço de memória virtual só seu, como se tivesse a RAM inteira para ele. O kernel, com a ajuda da MMU do processador, traduz esses endereços virtuais em endereços físicos, organizados em páginas. Com isso:

• um programa não consegue ler nem corromper a memória de outro;
• bibliotecas compartilhadas ficam carregadas uma vez só e servem a vários processos;
• páginas pouco usadas podem ir para a swap (no disco ou comprimidas na própria RAM, com zram) quando a memória aperta.

Um detalhe que assusta iniciantes: o Linux usa a RAM livre como cache de disco. Por isso o comando free -h costuma mostrar pouca memória “livre”. O número que interessa é a coluna “available”, porque esse cache é liberado na hora em que algum programa precisa.

Drivers e módulos

Drivers são o código que sabe conversar com cada peça de hardware: placa de rede, controlador de SSD, GPU, webcam. A maioria já vem no próprio kernel, o que explica por que tanta coisa funciona logo depois de instalar a distro. Os módulos ficam em /lib/modules e são carregados automaticamente quando o hardware é detectado. O comando lsmod lista os que estão ativos.

Sistema de arquivos e o “tudo é arquivo”

O kernel tem uma camada chamada VFS (Virtual File System), que oferece a mesma interface para qualquer sistema de arquivos: ext4, Btrfs, XFS, FAT, NTFS e outros. O programa só pede “abrir”, “ler” e “gravar”, e o VFS repassa o pedido ao driver certo.

Essa ideia vai além dos discos. No Linux, muita coisa aparece como arquivo:

• /dev guarda dispositivos, como /dev/sda ou /dev/nvme0n1;
• /proc mostra informações dos processos e do kernel em tempo real (experimente cat /proc/cpuinfo);
• /sys expõe detalhes do hardware e dos drivers.

Nenhum desses diretórios ocupa espaço no disco. O kernel gera o conteúdo na hora em que você lê.

Rede

A pilha de rede (TCP/IP, roteamento, firewall com netfilter/nftables) também fica dentro do kernel. Os programas abrem sockets e o kernel cuida de montar pacotes, controlar conexões e falar com a placa de rede. É um dos motivos de o Linux ser tão usado em servidores, roteadores e VPS.

Espaço de usuário e chamadas de sistema

O processador moderno tem níveis de privilégio. O kernel roda no nível mais alto (modo kernel) e os programas rodam num nível restrito (modo usuário). Um aplicativo comum não pode acessar o disco direto nem mexer na memória de outro processo.

Quando precisa de algo, o programa faz uma chamada de sistema (syscall). Abrir um arquivo, por exemplo, segue mais ou menos este caminho:

1. o programa chama uma função da biblioteca C, como open();
2. a biblioteca prepara os parâmetros e dispara a syscall;
3. o processador muda para o modo kernel;
4. o kernel confere as permissões, chama o VFS e o driver do disco;
5. o resultado volta ao programa, que continua no modo usuário.

Se quiser ver isso ao vivo, a ferramenta strace mostra cada syscall que um programa faz. Rode strace ls e você vai ver dezenas de chamadas para listar um único diretório.

O boot do Linux, passo a passo

Entender a inicialização ajuda muito na hora de resolver problemas. Em um PC moderno, a sequência é esta:

1. Firmware (UEFI ou BIOS): testa o hardware básico e procura um carregador de boot no disco, normalmente na partição EFI.
2. Bootloader (geralmente o GRUB): mostra o menu, carrega na memória a imagem do kernel e o initramfs e passa parâmetros para o kernel.
3. Kernel: descompacta, detecta CPU e memória e inicia os drivers essenciais.
4. initramfs: um mini sistema de arquivos temporário com os módulos necessários para achar e montar a partição raiz (por exemplo, se ela estiver criptografada ou em RAID).
5. Montagem da raiz: o sistema de arquivos principal é montado em /.
6. Processo init (PID 1): o kernel inicia o primeiro processo do espaço de usuário, hoje quase sempre o systemd.
7. Serviços: o systemd sobe rede, logs, agendadores, servidor SSH e o gerenciador de login, muitos deles em paralelo.
8. Login: aparece a tela gráfica ou o prompt de texto, e sua sessão começa.

O comando systemd-analyze blame mostra quanto tempo cada serviço levou para subir, e journalctl -b exibe os registros do boot atual.

Usuários, permissões e o papel do root

O Linux nasceu multiusuário, e isso aparece em todo o sistema. Cada arquivo tem um dono, um grupo e três conjuntos de permissões: leitura (r), escrita (w) e execução (x), para o dono, para o grupo e para os demais. Você vê isso com ls -l.

O usuário root tem poder total. Por segurança, o normal é trabalhar com uma conta comum e usar sudo só quando precisa de privilégios administrativos. Essa separação faz com que um programa com problema, rodando como usuário comum, não consiga danificar o sistema inteiro. Camadas extras como SELinux e AppArmor restringem ainda mais o que cada serviço pode fazer.

Onde fica cada coisa: a árvore de diretórios

No Linux não existem letras de unidade como C: ou D:. Tudo fica numa árvore única que começa na raiz /, e outros discos são “montados” em pastas dentro dela.

Pacotes: como os programas são instalados

Em vez de baixar instaladores soltos, o Linux usa gerenciadores de pacotes que buscam software em repositórios mantidos pela distribuição. Eles resolvem dependências, conferem assinaturas digitais e atualizam tudo de uma vez, do kernel ao navegador.

Também existem formatos universais, como Flatpak, Snap e AppImage, que empacotam o aplicativo junto com suas dependências e rodam em várias distros.

Comandos para ver o Linux funcionando

A melhor forma de fixar tudo isso é observar o sistema. Abra um terminal e teste:

• uname -r: mostra a versão do kernel em uso;
• ps aux ou htop: lista os processos, com uso de CPU e memória;
• pstree: exibe a árvore de processos a partir do PID 1;
• free -h: resume o uso de RAM e swap;
• lsmod: lista os módulos do kernel carregados;
• sudo dmesg: mostra as mensagens do kernel, ótimo para diagnosticar hardware;
• systemctl status: mostra o estado dos serviços;
• df -h e lsblk: exibem discos, partições e pontos de montagem.

Mitos e erros comuns de quem está começando

• “Linux é só terminal.” As distros modernas têm interfaces gráficas completas. O terminal é uma ferramenta poderosa, mas dá para usar o sistema sem ele.
• “A memória está quase cheia.” Quase sempre é cache de disco, que sai da frente quando algum programa precisa de RAM.
• Usar root para tudo. Aumenta o risco de apagar arquivos importantes ou de rodar código malicioso com poder total.
• Misturar repositórios de distros diferentes. Costuma quebrar dependências. Prefira os repositórios oficiais ou Flatpak.
• Achar que Linux é uma coisa só. O kernel é o mesmo, mas cada distro faz escolhas diferentes de pacotes, configurações e ciclo de atualização.

Perguntas frequentes

Qual a diferença entre o kernel Linux e uma distribuição?

O kernel é o núcleo que gerencia o hardware, os processos e a memória. A distribuição é o pacote completo: kernel, ferramentas, bibliotecas, sistema de inicialização, gerenciador de pacotes e, em geral, uma interface gráfica.

O Linux funciona de forma parecida com o Windows?

Os conceitos gerais são parecidos: kernel, processos, memória virtual, drivers. As diferenças estão nos detalhes, como a árvore de diretórios única, o modelo de permissões herdado do Unix, a instalação por repositórios e o fato de o código-fonte ser aberto.

O que é o systemd e por que ele é tão importante?

O systemd é o primeiro processo do espaço de usuário (PID 1) na maioria das distribuições. Ele inicia e supervisiona os serviços, organiza os logs e gerencia montagens, rede e sessões. Algumas distros usam alternativas, como OpenRC ou runit.

Preciso atualizar o kernel manualmente?

Na maioria das distros, não. O kernel chega pelo gerenciador de pacotes junto com as outras atualizações, e basta reiniciar para usar a versão nova. Compilar o kernel na mão só faz sentido em casos específicos.

Por que o Linux é tão usado em servidores?

Por causa da estabilidade, da segurança baseada em permissões, do controle fino sobre os recursos, da pilha de rede robusta, da automação pelo terminal e da ausência de custo de licença na maioria das distribuições. Tudo isso combina com VPS, nuvem e contêineres.

Contêineres como o Docker usam o próprio kernel Linux?

Sim. Os contêineres compartilham o kernel do sistema hospedeiro e usam recursos dele, como namespaces e cgroups, para isolar processos e limitar CPU e memória. Por isso são bem mais leves que máquinas virtuais.