Memória, Paginação e a Ilusão do Hardware

No capítulo anterior, vimos algo curioso no readelf -l:

1

LOAD           ... RWE 0x1000

E o seu linker script tinha esta instrução:

1

. = 0x80000000;

Por que 0x1000? Por que o hardware se importa? E o seu código realmente vive em 0x80000000 dentro do chip físico? Vamos levantar o véu de uma das ilusões mais importantes da ciência da computação: Gerenciamento de Memória.

1. A analogia do caderno: o que é uma página?

Imagine a memória (RAM) do computador não como um “balde gigante de bilhões de bytes”, mas como um caderno de fichário.

• Cada folha desse caderno é chamada de Página.
• O processador não gerencia memória byte a byte para tudo; ele prefere mover, proteger e mapear folhas (páginas) inteiras de uma vez.

Esse sistema é chamado de Paginação (Paging). É assim que o hardware (especificamente a MMU - Memory Management Unit) impõe ordem ao caos de bilhões de células de memória.

2. Por que 4KB (4096 bytes)?

No readelf, vimos Align 0x1000. Em decimal, 0x1000 é 4096. Este é o tamanho padrão de uma página de memória. Virou padrão (desde os tempos do Intel 80386 e VAX) porque fica na “zona de ouro”:

1. Nem pequeno demais: Se as páginas fossem minúsculas (ex.: 100 bytes), seu caderno precisaria de bilhões de folhas. A “Tabela de Conteúdo” (Page Table) que precisa rastrear tudo seria gigantesca, consumindo mais RAM do que seus programas!

2. Nem grande demais: Se as páginas fossem enormes (ex.: 1MB), você desperdiçaria espaço. Imagine precisar guardar um arquivo de texto de 1KB. O sistema teria que reservar uma folha inteira de 1MB só para aquela nota. O resto da página ficaria vazio. Isso se chama Fragmentação Interna.

4KB é o ponto de equilíbrio: pequeno o suficiente para ser eficiente, grande o bastante para gerenciar facilmente.

Por isso o linker alinha segmentos em 0x1000: ele está dizendo “Comece esta seção em uma página nova.”

3. A grande ilusão: virtual vs. físico

Aqui está o segredo: seu programa está alucinando.

A visão do programa (Memória virtual)

Seu programa enxerga um bloco perfeito e contíguo de memória.

• Página 1: 0x80000000 (Seu código)
• Página 2: 0x80001000 (Seus dados)
• Página 3: 0x80002000 (Sua pilha)

“Tudo é limpo, organizado e lado a lado.”

A visão do hardware (Memória física)

A MMU pega essas páginas virtuais e as espalha onde houver espaço livre nos chips de RAM.

• Página 1 (Código) → Pode estar no Endereço Físico 0x9000F000 (perto do fim do módulo).
• Página 2 (Dados) → Pode estar no Endereço Físico 0x00004000 (bem no começo).
• Página 3 (Pilha) → Pode estar no Endereço Físico 0x12345000 (em algum lugar no meio).

O hardware mantém essa ilusão para que o SO possa desfragmentar a memória sem que o seu programa perceba.

4. O tradutor: tabelas de páginas

Como a CPU sabe que o Virtual 0x80000000 na verdade é Físico 0x9000F000? Ela usa uma tabela de consulta chamada Page Table, que fica na RAM (Memória Física).

O registrador “chefe”: satp

A CPU precisa saber onde essa tabela mora. Em RISC-V, essa localização fica num registrador privilegiado chamado satp (Supervisor Address Translation and Protection). (No x86, isso se chama CR3).

O truque de velocidade: TLB

Ler essa tabela na RAM para cada instrução deixaria o computador incrivelmente lento (dobraria o tráfego de memória). Para corrigir isso, a CPU tem um cache interno minúsculo e ultra rápido chamado TLB (Translation Lookaside Buffer). Ele lembra traduções recentes:

“Acabei de verificar 0x80000…, é 0x9000F… Não precisa ir no índice da RAM de novo.”

5. Onde está a MMU? (Hardware vs. Kernel)

A MMU (Memory Management Unit) fica na fronteira entre hardware e software. Aqui está exatamente onde ela vive e quem a controla:

5.1. No hardware (o executor)

A MMU é um circuito de silício dentro da CPU (ou SoC).

• Localização: fica entre o núcleo da CPU (que executa instruções) e o barramento de memória (RAM).
• Trabalho: intercepta todo endereço que a CPU tenta acessar. Ela traduz automaticamente “Endereço Virtual → Endereço Físico” e checa permissões (Leitura/Escrita/Execução) em hardware, sem desacelerar a CPU.

5.2. No kernel/software (o gerente)

A MMU é um hardware “burro” que segue regras. O Kernel do SO (software) cria essas regras.

• Page Tables: o Kernel escreve estruturas de dados (Page Tables) na RAM que mapeiam endereços virtuais para físicos.
• Registradores de controle: o Kernel diz à MMU física onde encontrar essas tabelas escrevendo em um registrador específico da CPU (ex.: satp no RISC-V, CR3 no x86, ou TTBR no ARM).

5.3. Resumo

• Hardware: uso → o circuito da MMU realiza a tradução em tempo real.
• Kernel: configuração → o SO preenche os “formulários” (Page Tables) que a MMU lê.

6. Kernel vs. usuário (Quem segura as chaves?)

Seu programa pode ver as Page Tables? Não.

• O Kernel (Ring 0 / Supervisor Mode): Ele possui a memória. Escreve a Page Table na RAM e configura o registrador satp. Ele decide quem vive onde. Ele precisa poder ler/escrever a tabela para lançar programas.

• O Usuário (Ring 3 / User Mode): É só um inquilino.

  • Se você tentar ler satp? Exceção de Instrução Ilegal. A CPU derruba seu programa.
  • Se você tentar ler a Page Table diretamente na RAM? Impossível. Seu programa não consegue emitir endereços físicos. Ele só emite endereços virtuais. Mesmo que você saiba que o endereço físico é 0x9000F000, se tentar ler 0x9000F000, a MMU trata isso como um endereço virtual. Page Fault. A CPU vê você acessando memória que não é sua e derruba seu programa. Você está preso na Matrix.

7. Resumo

1. Páginas: memória é gerenciada em “folhas” de 4KB, não em bytes.
2. Alinhamento: o linker busca alinhamento em 0x1000 para encaixar páginas perfeitamente.
3. Memória virtual: programas veem uma fantasia contígua e simplificada.
4. Memória física: a realidade é espalhada e fragmentada.
5. Page Tables: o dicionário que mapeia Fantasia → Realidade, gerenciado pelo Kernel.
6. MMU: o circuito de hardware que intercepta todo acesso e traduz endereços.
7. Kernel: o software que configura as Page Tables e diz à MMU onde achá-las.

Essa infraestrutura é o que permite múltiplos programas rodarem ao mesmo tempo sem trombar uns nos outros. Cada um ganha seu próprio “Caderno” (Espaço de Endereços Virtual), sem perceber que todos compartilham a mesma mesa física.