O SOIA liga numa área de trabalho, e a janela mostra foto.

Camada essencial

Free guarda para o próximo pedido.

Pequenos blocos vizinhos são unidos. As páginas continuam no processo para evitar trabalho repetido e voltam ao kernel no exit.

Camada técnica

Break lógico + páginas físicas.

base   0x100008000
break  base + 6.288 B
mapa   2 × 4 KiB
limite 0x100018000

Camada essencial

Duas telas em vez de uma.

Os aplicativos desenham em uma cópia da tela guardada na RAM. O cursor nem existe lá: ele é pintado só na hora de copiar a cópia para a tela de verdade. Assim a seta nunca suja o que está embaixo dela.

Camada técnica

Pacote de três bytes.

byte 0 = YO XO YS XS 1 BM BR BL
byte 1 = deslocamento X
byte 2 = deslocamento Y
cursor = 8 × 12 px, 2 bits/px

Fatia 4 · o gerenciador de janelas

O que barateou o mosaico.

O terminal do SOIA nunca guardou texto: ele escreve pixels e rola por cópia de pixels. Isso parecia uma limitação e virou vantagem. O conteúdo de cada janela já mora no back buffer, na região dela, então não foi preciso inventar um buffer de caracteres por janela. Bastou reapontar quatro variáveis de origem e grade a cada escrita.

Mosaico, não sobreposição

A limitação que protege.

As três janelas dividiam a tela sem se cruzar, e era justamente isso que impedia uma tarefa de pintar pixel de outra. Janelas que se cobrem exigem uma superfície por janela e um compositor empilhando em ordem z: mais 2 MiB por janela e uma cópia extra por quadro.

A dívida foi paga nos Marcos 25 e 26. Cada janela ganhou superfície própria, o mosaico deu lugar a janelas flutuantes, e o compositor as monta na ordem de profundidade. Ver como ↓

Camada essencial

Foco é quem escuta, não quem aparece.

Antes, F1, F2 e F3 escolhiam qual programa ocupava a tela inteira; os outros dois congelavam. Agora os três aparecem sempre, e o clique escolhe apenas para onde vai a tecla. A distinção entre "estar visível" e "ter o teclado" só existe quando há mais de uma janela viva.

Camada técnica

A COM1 é um terminal só.

Com três tarefas escrevendo, a saída serial virou uma trança de textos. A serial passou a espelhar só a janela em foco, como faria um console físico. Isso quebrou a verificação: o texto das janelas de fundo não passa mais por lá. A resposta foi um contador de caracteres por janela, exposto pela syscall 27.

O que o teste não pega

Botão que não fecha nada é pior que botão nenhum.

O SOIA desenhava um X vermelho na barra de título, em uma coordenada literal da época de 1024 × 768. A 1920 ele caía no meio da barra, e nunca houve clique ligado a ele. Somado ao X real da janela do QEMU, eram dois botões de fechar, um deles falso. Ele volta na fatia 4, quando existir janela para fechar.

Relativo contra absoluto

Por que o ponteiro escapa pela borda de cima.

O PS/2 informa deslocamento; um tablet USB informaria coordenada. Com dispositivo relativo existem dois ponteiros independentes, o do Windows e o do SOIA, que nunca se reconciliam. Sem pilha USB, a saída é pedir ao QEMU que prenda o ponteiro na janela com grab-on-hover=on. Ctrl+Alt+G solta.

Camada essencial

Porta corta-fogo.

Um prédio sem porta corta-fogo queima inteiro quando um apartamento pega fogo. O privilégio guardado no seletor de código é a porta: valor 3 significa que quem errou foi o programa, e só o apartamento dele precisa ser isolado.

Camada técnica

Quatro instruções decidem tudo.

mov rax, [rsp + EXCEPTION_CS_OFFSET]
and eax, 0x03
cmp eax, 0x03
jne exception_kernel_panic_64

Fatia 3 · Camada essencial

O extintor não pode ficar dentro do quarto em chamas.

Para contar que houve um acidente, a CPU precisa de um papel onde anotar. Ela anota na pilha. Quando o problema é a pilha, não há onde anotar, e a máquina reinicia sem dizer nada. A IST é um papel guardado em outro lugar, reservado só para essa hora.

Fatia 3 · Camada técnica

IST1 troca o RSP antes de empilhar.

mov eax, DOUBLE_FAULT_STACK_TOP
mov [tss64 + TSS_IST1_OFFSET], rax

mov byte [abs IDT_BASE + (8 * 16) + 4], 1

Duas metades distantes: a porta do vetor 8 guarda o índice, o TSS guarda o ponteiro. Ter uma sem a outra não serve de nada, e é por isso que a prova serial sai depois do TSS.

Fatia 3 · Ctrl+C

Desistir não é o mesmo que quebrar.

Até aqui todo encerramento vinha de um erro. Ctrl+C é o primeiro caminho em que ninguém errou: o programa está funcionando, esperando entrada, e você simplesmente não quer mais. Por isso ele tem código de saída próprio, -7, e o terminal diz uma frase diferente da frase de falha.

Fatia 3 · Quem executa o pedido

A IRQ1 registra, o timer encerra.

O teclado empilha seis registradores, não o quadro completo que o escalonador precisa para recarregar RSP. Encerrar a tarefa ali quebraria o despacho, então a tecla só deixa o alvo anotado e o tick seguinte faz o trabalho. A latência máxima é um pulso de 50 ms.

calc>
[SOIA] processo encerrado: Ctrl+C do teclado.
Processo encerrado por Ctrl+C; o programa nao errou.
soia> ps

Sem tratador, o que acontecia

Triple fault não deixa bilhete.

Uma exceção que a CPU não consegue entregar vira double fault; sem tratador para esse, vira triple fault, e o processador reinicia. De fora, os três casos pareciam idênticos: a janela sumia. Nomear a falha é a diferença entre depurar e adivinhar.

Um bug que o marco encontrou

Despachar por inicial quebra no oitavo.

O anúncio de cada programa escolhia a frase pela primeira letra do nome. FAULT.ELF começa com F, não batia com nenhum caso e era anunciado como CALC.ELF. Agora o nome vem da tabela de tarefas.

O que o BIOS precisa fazer

Nove etapas, do zero.

Setor de 512 bytes terminando em 0x55AA, segundo estágio porque 512 bytes não bastam, modo real de 16 bits, linha A20, GDT, CR0.PE, INT 13h para ler o disco, INT 15h/E820 para a memória e INT 10h para o vídeo.

O que o UEFI já entrega

Nenhuma delas.

A CPU já está em long mode de 64 bits, com paginação ligada e pilha válida, antes da primeira instrução do SOIA. O firmware leu o arquivo de uma partição FAT e chamou uma função C.

Camada essencial

Por que os dois caminhos ficam.

O boot BIOS é o material dos marcos 1 a 4. Apagá-lo apagaria a explicação de como um computador acorda do nada. Manter os dois transforma o marco em comparação: a mesma máquina, dois jeitos de ligar.

Camada técnica

Três armadilhas silenciosas.

A ABI do UEFI passa argumentos em RCX/RDX/R8/R9, e o alvo errado no compilador só falha na primeira chamada ao firmware. As tabelas são vetores de ponteiros, onde um campo faltando desloca todos os seguintes. E o mapa de memória avança por descriptor_size, nunca por sizeof: o OVMF publica 48 bytes contra os 40 da estrutura.

O que a primeira execução ensinou

Retornar apaga o próprio trabalho.

O carregador terminava com sucesso e o firmware seguia para a próxima entrada da lista de boot: o menu de configuração do OVMF, que limpava a tela. Do lado de fora, parecia que o SOIA não tinha feito nada. Um carregador de verdade nunca retorna: ele chama ExitBootServices, toma posse da máquina e salta para o kernel.

Um efeito colateral de não retornar

O firmware tem um watchdog.

Ele arma um temporizador de cinco minutos ao iniciar um aplicativo. Um carregador que nunca devolve o controle levaria um reset com o sistema já rodando, e pareceria um travamento aleatório. set_watchdog_timer(0, ...) desarma.

A troca de CR3 quase matou o carregador

Quem troca o mapa some do mapa.

A primeira tabela de páginas cobria 2 GiB, o mesmo teto do caminho BIOS. Só que o firmware havia carregado o próprio BOOTX64.EFI perto dos 2 GiB: no instante do mov cr3, a instrução seguinte deixou de existir. A correção é mapear 4 GiB, o que também traz o framebuffer do GOP, o LAPIC e o IO-APIC para dentro do mapa.

Contar memória livre não basta

Emprestada também é utilizável.

Contar só EfiConventionalMemory abria um buraco justo onde o back buffer precisa de 8 MiB contíguos, e o kernel recusava o contrato. Memória de LoaderCode, LoaderData e BootServices* volta a ser livre no instante do ExitBootServices: ela entra no mapa entregue ao kernel.

Camada essencial

Puxar o cabo não é desligar.

Até o Marco 21, encerrar o SOIA era fechar a janela do QEMU: o equivalente a tirar da tomada. kernel_halt era três instruções, cli e um laço de hlt eterno. Agora o sistema pede a própria energia de volta, e a janela fecha sozinha.

Camada técnica

Achar a assinatura não basta.

Oito bytes RSD PTR podem aparecer por acaso em qualquer lugar da memória. A defesa é o checksum: a soma de todos os bytes da tabela tem que fechar em zero. Toda tabela ACPI carrega esse campo, e o SOIA confere em todas.

Por que ACPI veio antes do resto

Ela não depende do UEFI.

O plano era UEFI carregar o kernel primeiro. Mas o RSDP também é encontrável pelo caminho BIOS, varrendo dois lugares: o UEFI só entrega o ponteiro de graça. Fazendo ACPI antes, ela roda no kernel que já funciona, é coberta pela bateria de testes existente e serve os dois caminhos de boot desde o primeiro dia.

Uma prova de tipo novo

O log não podia provar isso.

O kernel escreve a intenção antes de escrever no PM1a. Uma máquina que ignorasse a ordem produziria exatamente o mesmo log. Então a prova do desligar é o processo do QEMU terminar, verificado de fora. Quando o efeito acontece fora do sistema, a prova precisa vir de fora também.

O Marco 21 pagou por si mesmo

A falha disse exatamente onde doía.

O LAPIC fica em 0xFEE00000, perto de 4 GiB, e o mapa identidade do kernel para em 2 GiB. A primeira escrita virou falha de página, e o tratador de exceções entregou o diagnóstico inteiro: vetor 14, CR2 = 0xFEE000F0. Sem ele, teria sido um triple fault silencioso e a janela do emulador sumindo.

A segunda falha, mais sutil

Dois dispositivos disputando o mesmo GiB.

O PDPT tem quatro entradas, uma por GiB. O LAPIC, o IO-APIC e o framebuffer VBE caem todos no quarto. Como cada tarefa tem um page directory próprio para o vídeo, apontar o slot para o do APIC apagaria a tela, e o contrário apagaria o APIC. A saída foi comparar os slots antes de escolher: coincidindo, as duas regiões de 2 MiB cabem lado a lado no mesmo diretório.

Camada essencial

Roteamento fixo contra roteamento escolhido.

No 8259, qual dispositivo usa qual linha foi decidido pelo fabricante da placa em 1981, e o sistema operacional apenas obedece. No IO-APIC, cada linha é programada: o SOIA escolhe o vetor, e numa máquina com vários núcleos escolheria também qual deles atende.

Camada técnica

Registrador não é memória.

As páginas do APIC são mapeadas com PWT e PCD, que desligam o cache. Uma escrita retida no cache nunca chegaria ao controlador, e uma leitura poderia devolver o valor antigo. É a mesma correção que o framebuffer ainda não recebeu, e que lá continua registrada como dívida.

O erro que parecia conservador

LoaderData também é memória livre.

Contar só EfiConventionalMemory parece a leitura segura e é a errada: a especificação diz que o código e os dados do carregador e dos boot services deixam de ter dono quando ExitBootServices é chamado. Descartá-los abria um buraco em 0x800000, justo onde o back buffer de 8 MiB precisa caber contíguo.

Um campo novo no contrato

Zero significa "procure você mesmo".

No UEFI a assinatura RSD PTR não está na memória baixa, e a varredura não acha nada. O campo em +136 carrega o ponteiro que o firmware entregou; o estágio 2 do BIOS deixa zero. E o ponteiro vindo de fora não é aceito de graça: assinatura e checksum são conferidos igual aos da varredura.

Camada essencial

Duas pessoas, uma mesa de oito gavetas.

Dois funcionários se alternam na mesma mesa a cada 50 milissegundos e nenhum sabe que o outro existe. Se ninguém guardar as gavetas na troca de turno, o segundo mexe nas contas do primeiro, e o primeiro volta e continua sem perceber que os números mudaram. O resultado não é um erro visível: é uma conta errada com cara de conta certa.

Camada técnica

O je que evita um bug intermitente.

cmp rbx, [current_task]
je .load                  ; mesma tarefa: nada a fazer

call fpu_save_current_64
mov [current_task], rbx
call fpu_restore_current_64

Quando o escalonador escolhe a mesma tarefa de novo, restaurar carregaria a cópia do despacho anterior e apagaria toda conta feita desde então. O erro seria proporcional à carga do sistema.

O bug que o marco encontrou

Oito bytes dormindo desde o Marco 12.

Ligar SSE quebrou o boot antes do shell aparecer, com protecao geral | vetor 13 | codigo 0x0 em duas tarefas. Código de erro zero em #GP não é violação de segmento: é instrução SSE alinhada operando em endereço que não é múltiplo de 16.

A ABI diz que, na entrada de uma função, RSP % 16 vale 8, porque o CALL empurrou o endereço de retorno. O kernel entregava USER_STACK_TOP, múltiplo de 4096, e o frame inteiro ficava deslocado em oito bytes. Estava errado desde o primeiro programa em C, e ficou invisível dez marcos porque nenhuma instrução exigia alinhamento.

USER_STACK_ENTRY_RSP equ USER_STACK_TOP - 8

A lição é geral: habilitar um recurso não só adiciona o que ele faz, também passa a cobrar contratos que ninguém verificava.

Por que a prova é assembly

Em C, o teste passaria com o kernel errado.

A ABI trata XMM como registradores voláteis. Escrito em C, o compilador salvaria os valores na pilha antes da syscall e os recarregaria depois: o programa compararia a pilha com ela mesma e imprimiria OK sobre um kernel que não salva nada.

movsd 0x00(%[src]), %%xmm0
...
int $0x80          ; a tarefa dorme aqui
movsd %%xmm0, 0x00(%[dst])

Mantendo os valores nos registradores através do int 0x80, o único responsável por preservá-los é o FXSAVE do escalonador, e mais ninguém.

Camada essencial

Três coisas que batiam juntas agora batem separadas.

Uma única interrupção fazia três trabalhos ao mesmo tempo: trocar de programa, desenhar a tela e contar o tempo. Como era a mesma batida, mudar o ritmo de um mudava o dos outros três. Agora cada um tem seu próprio compasso, e o do meio, o que conta o tempo, continua igual de propósito: tudo que já existia foi escrito contra ele.

Camada técnica

O tick de 20 Hz é contrato, não conservadorismo.

dec byte [timer_tick_divider]
jnz .acknowledge
mov byte [timer_tick_divider], 5
inc qword [timer_ticks]

SLEEP recebe ticks. Um soia_sleep(10) que passasse a valer 100 ms em vez de 500 ms mudaria o comportamento de todos os aplicativos de uma vez, sem nenhum deles ter sido tocado.

O erro que custou quatro rodadas

Um relógio conferido contra si mesmo mente sem se contradizer.

Depois de ligar o timer, o uptime relatado parecia ser metade do de uma execução anterior. Conclusão imediata: pulsos estavam se perdendo. E os números internos pareciam confirmar, porque 3 ticks e 150 ms fechavam perfeitamente.

Só que uptime_milliseconds e timer_ticks derivam os dois do pulso. Se pulsos se perdessem, ambos errariam junto, na mesma proporção, e continuariam coerentes: eles nunca poderiam detectar o próprio defeito.

$sw = [System.Diagnostics.Stopwatch]::StartNew()
.\scripts\Test-QemuBoot.ps1 -MemoryMiB 64
$sw.Stop()

parede: 41 s | uptime do SOIA: 37 s | diferenca: o boot

O relógio sempre estivera certo, e os "74 s de referência" vinham de uma execução que demorou mais por disputar a máquina com outros testes. No caminho, o pulso chegou a ser reduzido para 40 Hz e o código chegou a afirmar que 100 Hz não era sustentável. Era falso, e foi revertido.

A regra que fica: contador derivado de um sinal não valida esse sinal. A referência precisa ser independente, e a mais independente disponível costuma ser o mundo de fora.

O próximo marco se anunciou aqui

As quatro páginas de texto acabaram.

A primeira tentativa foi mostrar o relógio novo no status do terminal. O linker recusou:

ld.lld: error: section .text virtual address range
overlaps with .data

Cada processo recebe 16 KiB de texto, e o TERMINAL.ELF não aceita mais nenhuma função nem string sem perder outra. A prova foi para o FPU.ELF, que tinha folga, e o limite ficou registrado onde será resolvido: o Marco 24, com binário de tamanho variável, demand paging e heap em MiB.

Resolvido na fatia 1 do Marco 24. O relógio está no status, e o TERMINAL.ELF passou a ocupar 5 páginas de texto. Ver como ↓

Camada essencial

Prateleira serrada contra prateleira ajustável.

Imagine uma estante em que todas as divisões foram serradas do mesmo tamanho antes de saber o que ia ser guardado. Um livro grosso não entra. Um panfleto entra e sobra um espaço que ninguém mais pode usar, porque a divisão é fixa e está ali para sempre.

A estante continua do mesmo tamanho, e o limite total continua existindo. O que mudou é que agora quem precisa de mais recebe mais, e quem precisa de menos devolve a diferença.

Camada técnica

A página que existe para não existir.

USER_STACK_GUARD_PAGE_COUNT equ 1
USER_HEAP_PAGE_CEILING equ USER_STACK_FIRST_PAGE \
                         - USER_STACK_GUARD_PAGE_COUNT

Entre o teto do heap e a base da pilha fica uma página que nunca recebe PTE. Pilha que transborda cai nela e vira falha de página, ou seja, fim declarado da tarefa culpada pelo caminho do Marco 21. Sem a guarda, o transbordo escreveria no heap em silêncio e o dano apareceria longe da causa.

Conferir a ausência dela é a única prova possível de uma página que nunca deve estar lá, e é o que o boot faz.

A decisão que a fatia forçou

Duas verdades sobre o mesmo endereço.

Existia uma tabela, task_user_pages, com o endereço físico de cada página de cada tarefa. As PTEs já guardam exatamente esse endereço, e é a PTE que a MMU consulta: a tabela era uma cópia.

Com tamanho fixo, isso era só redundância. Com tamanho variável ela teria que ser dimensionada para o teto de páginas vezes oito tarefas, e as duas listas passariam a ter como discordar. Ela saiu, e no lugar entrou uma leitura da própria PTE.

mov rax, [rbx + rsi * 8]
test rax, 0x01          ; bit de presenca
jz .not_present
mov rdx, PAGE_FRAME_MASK
and rax, rdx

A liberação de uma vaga ganhou de graça: eram três laços, um por região, cada um sabendo de cor quantas páginas procurar. Virou uma varredura das 512 entradas devolvendo o que estiver presente, que não depende de tamanho nenhum.

O bug que a mudança quase deixou passar

A pilha saiu da faixa sem ninguém escrever isso.

As duas rotinas que validam ponteiro de userland aceitavam de USER_TEXT_VIRTUAL até o break do heap. No layout antigo isso cobria a pilha, porque o heap vinha depois dela. Uma comparação, e cobria tudo.

Com a pilha no fim da região, a mesma comparação passaria a recusar exatamente o caso mais comum que existe: um buffer declarado como variável local dentro de uma função C. Toda syscall com buffer teria começado a devolver erro.

    cmp rdi, rdx           ; parte baixa: imagem + heap
    jb .try_stack
    cmp rax, r9            ; ate o break
    jbe .success

.try_stack:                ; parte alta: a pilha
    mov rcx, USER_STACK_VIRTUAL
    cmp rdi, rcx
    jb .failure

A regra que fica: mudar layout de memória é mudar todas as afirmações implícitas sobre vizinhança. As que estão escritas o assembler aponta; as que só existiam como consequência de duas coisas serem vizinhas não aparecem em lugar nenhum.

O endereço que saiu da userland

Uma constante compilada sobre conta alheia.

#define SOIA_HEAP_BASE 0x0000000100008000UL
#define SOIA_HEAP_CAPACITY (16UL * 4096UL)

As duas saíram do soia.h. Com imagem de tamanho variável elas errariam em silêncio no primeiro binário que crescesse: o soia_malloc montaria a lista de blocos num lugar e o kernel mapearia as páginas em outro. No lugar entraram dois seletores de get_system_info, que respondem sobre a tarefa que perguntou.

soia> run heap.elf
heap base: 0x0000000100003000
teto do heap: 0x0000000100013000
primeiro bloco: 0x0000000100003020

O HEAP.ELF confere três coisas: que a base informada é igual ao break inicial, que ela fica acima do segmento de dados do próprio programa, e que crescer o heap consome exatamente duas páginas físicas.

O erro estava no teste

Quando a bateria recusa código que o sistema aceita.

O Test-BootImage.ps1 passou a conferir o mapa derivado e recusou o TERMINAL.ELF com "não cabe no mapa de imagem". O binário estava correto; a conta do teste, não.

# Errado: a divisao devolve double e [int] ARREDONDA
[int]((16288 + 4095) / 4096)              # -> 5

# Certo
[int][math]::Floor((16288 + 4095) / 4096) # -> 4

Um texto de 16.288 bytes ocupa quatro páginas. O teste calculava cinco, concluía que os dados começavam antes do fim do texto e acusava uma sobreposição que não existia. Fica o aviso: quando um teste novo recusa código que o sistema aceita, o suspeito é o teste.

Camada essencial

A reserva do restaurante.

Reservar dez mesas para um grupo que talvez venha não ocupa mesa nenhuma: ocupa uma linha no caderno. As mesas só saem de circulação quando as pessoas chegam e sentam.

Antes, o SOIA arrastava as dez mesas para o canto no instante da reserva, e elas ficavam lá vazias. Por isso a reserva máxima era pequena: mesa parada é mesa perdida.

Camada técnica

O privilégio não decide, e é de propósito.

O Marco 21 estabeleceu que o RPL do CS salvo decide o destino de uma exceção. Aqui a regra não se aplica, e repeti-la seria um bug grave:

char *buffer = soia_malloc(4096);
soia_read_file("README.TXT", 10, buffer, 4096);

A syscall escreve no buffer pelo endereço virtual, com o CR3 da tarefa carregado, e quem executa é o kernel. A primeira falha nessa página chega em ring 0, e é legítima. Filtrar por privilégio faria toda leitura de arquivo para um buffer recém-alocado derrubar o sistema.

O bug que a fatia encontrou

Ficar rápido acordou uma corrida que dormia.

Depois da fatia 2, o FAULT.ELF passou a ser encerrado com código -4 em vez de -6, e só no perfil de 64 MiB. Nenhuma linha do encerramento tinha sido tocada.

Quando um filho morre e o pai não está bloqueado em WAIT, o kernel liberava a vaga na hora, e o código de saída ia junto. O WAIT seguinte respondia "não encontrado" sobre um processo que tinha acabado de morrer.

A corrida existia desde o Marco 16 e nunca aparecia porque criar um processo era lento: oito páginas alocadas e zeradas. Com imagem derivada do ELF e heap sem alocação antecipada, são três, e o filho passou a alcançar a própria falha antes de o pai chegar no WAIT.

A regra que fica: otimizar não só acelera, também muda quais interleavings acontecem. Uma corrida latente não precisa de código novo para virar bug; basta o código antigo ficar rápido.

O segundo bug, na saída

Uma linha cortada ao meio por outra tarefa.

bytes reservados no break: Processo iniciado;
PID 4. O terminal aguardara sua saida.

O app imprimia número dígito a dígito, uma syscall por caractere, e o terminal escreve na mesma janela enquanto espera o filho. Entre duas syscalls cabe uma preempção, e a 100 Hz ela cabe com folga.

A saída é montar a linha inteira num buffer e emitir com uma chamada só: a syscall roda com interrupções desabilitadas, então a linha sai inteira. Vale para qualquer asserção de teste sobre linha com número interpolado.

Camada essencial

A portaria que só deixava passar duas caixas.

Não adianta ter um depósito grande se a porta só aceita duas caixas por viagem: mudar de sala vira o trabalho, e não carregar. A porta ficou trinta e duas vezes mais larga, e a conferência passou a ser caixa por caixa em vez de olhar só a primeira e a última da pilha.

Conferir mais dá mais trabalho, e é justamente por a porta ser larga que ele passou a valer: uma pilha grande tem mais lugares onde algo errado se esconde no meio.

Camada técnica

Duas razões para uma página passar.

cmp r9, r12          ; antes do heap?
jb .require_pte
cmp r9, r13          ; dentro do prometido?
jb .advance          ; passa sem PTE

.require_pte:
test rcx, 0x01       ; presente?
jz .failure
test r11, r11        ; e escrita?
jz .advance
test rcx, 0x02       ; gravavel?
jz .failure

Página no heap prometido passa sem PTE, porque a cópia do kernel vai gerar a falha e ela será atendida. É esse caminho que faz um buffer recém-alocado por malloc ser um destino válido mesmo sem nenhuma página física.

O erro que quase passou

Um jmp que roubava o RCX de quinze chamadas.

A direção da transferência virou parâmetro em RCX, e os wrappers montavam o argumento antes de saltar:

validate_user_read_range_64:
    xor ecx, ecx      ; destrói o RCX de quem chamou
    mov rdx, USER_TEXT_VIRTUAL
    jmp validate_user_range_64

São quinze chamadas espalhadas pelo despacho de syscalls, e nenhuma espera perder RCX. O assembler não avisa, e o dano apareceria em uma syscall qualquer, longe daqui.

Os wrappers passaram a salvar e restaurar tudo, com call e ret no lugar do jmp. pop não altera flags, então o CF da validação atravessa a restauração intacto.

A prova que encadeia tudo

As três fatias numa linha só.

O HEAP.ELF aloca 40 KiB no heap, o que só existe pela fatia 2, e pede o MONITOR.ELF inteiro numa chamada, o que só existe pela fatia 3.

As dez páginas do buffer estão prometidas e nenhuma foi tocada. Quem toca primeiro é o rep movsb do kernel, ou seja, a falha legítima acontece em ring 0.

É exatamente o cenário que decidiu não filtrar o demand paging por privilégio. Se a decisão olhasse o RPL, esta prova não imprimiria nada: o sistema teria parado ao ler um arquivo.

Camada essencial

O limite que ninguém via porque os dois números eram iguais.

O mapa de blocos ocupados cabia em um setor. Um setor tem 512 bytes, ou seja 4.096 bits, ou seja descreve 4.096 blocos. E o disco tinha exatamente 4.096 blocos.

O limite existia desde sempre e nunca apareceu, porque a régua tinha o mesmo tamanho da coisa medida. Ele só se manifesta quando você tenta aumentar a coisa.

Camada técnica

Ler depois do fim devolve zero, e não erro.

; Depois do fim nao e erro: e o fim.
cmp r12, r10
jae .end_of_file

É o sinal de parada de qualquer leitor sequencial. Tratá-lo como falha faria todo programa confundir o fim normal de um arquivo com um problema, e o laço de leitura precisaria saber o tamanho de antemão para nunca chegar lá.

O DISCO.ELF confere justamente isso depois de ler o último bloco: pede mais 64 KiB no deslocamento 1 MiB e exige zero de volta.

O bug que só apareceu num dos caminhos

O kernel cresceu e o UEFI parou sozinho.

Subir o kernel de 96 para 112 setores foi anunciado pelo NASM, no lugar certo: TIMES value -65 is negative, o padding que empurra a mensagem final para o último setor ficando sem espaço.

Só que o carregador UEFI tem o tamanho do kernel escrito dentro dele:

#define KERNEL_IMAGE_SIZE (96ULL * 512ULL)

Ele carregou 49.152 dos 57.344 bytes, e o kernel respondeu contrato de boot invalido. O sintoma engana porque é assimétrico: o BIOS continuava bootando normalmente, já que lá o estágio 2 usa o valor montado no próprio binário.

A regra que fica: os dois caminhos de boot não compartilham arquivo nenhum, e é exatamente isso que faz um número duplicado passar despercebido. Ao mexer no tamanho do kernel, os dois lados precisam ser tocados.

Como a prova evita se enganar

Um padrão que depende da posição.

static soia_byte_t pattern_at(soia_size_t position) {
    return (soia_byte_t)((position * 31UL
        + (position >> 8)) & 0xFFUL);
}

Se todos os bytes fossem iguais, um bloco gravado no deslocamento errado passaria despercebido, e é justamente esse o erro que a escrita com deslocamento pode cometer.

E o teste de persistência confere o arquivo de fora, lendo a imagem no PowerShell com a fórmula reescrita ali. Comparar o arquivo com um valor lido do próprio arquivo seria compará-lo consigo mesmo, que é a mesma armadilha do relógio do Marco 23.

Camada essencial

Pixel não cabe numa conversa com o kernel.

Um quadro de 1920 × 1080 tem 8,29 MB. Mandar isso por syscall trinta vezes por segundo seriam 250 MB/s atravessando a fronteira, com conferência em cada travessia.

A saída é a mesma de todo sistema real: o kernel entrega o endereço uma vez, o programa escreve direto, e a syscall só carrega o retângulo que mudou.

Camada técnica

O dano do texto não pode ir para a caixa da tela.

cmp qword [draw_target_window], WINDOW_COUNT
jb .surface_damage

Quando o alvo é superfície, a coordenada é local e vai para a caixa daquela janela. Misturar as duas na mesma caixa marcaria o canto do desktop como sujo toda vez que alguém escrevesse uma letra.

É a mesma variável que o compositor consulta para saber que precisa forçar o back buffer antes de copiar: ele roda por interrupção e pode pegar uma tarefa no meio de uma linha.

O bug que o recurso encontrou

A rolagem nunca marcou dano, e acertava por acidente.

terminal_scroll_64 move o console inteiro com rep movsd, e mover pixel não passa por nenhuma rotina que marque dano. O único retângulo marcado era o da última linha.

Isso nunca apareceu porque as células escritas em seguida iam ampliando a caixa até cobrir quase tudo. Com o texto na superfície o acidente acabou, e a rolagem passou a marcar o console inteiro. O preço é real: ela ficou cara, e foi essa lentidão que expôs a corrida do item ao lado.

A corrida que a lentidão revelou

A fila de teclado tem dono no instante da leitura.

O roteiro do teste digitava run calc.elf, esperava 350 ms e apertava F2. Se o terminal ainda não tivesse lido o Enter quando o foco mudasse, quem recebia a tecla era o bloco de notas: o comando ficava ecoado na tela sem nunca executar.

A corrida sempre existiu. Ela ficou visível porque escrever caractere ficou mais caro. Nenhuma linha de kernel mudou para resolver: a espera do roteiro subiu, com o motivo escrito ao lado.

Camada essencial

O garçom e o cardápio na parede.

O terminal é um garçom: você precisa saber o nome do prato e pedir com as palavras certas. Os atalhos e o menu Iniciar são o cardápio com fotos: você aponta.

Os dois levam ao mesmo prato. A lista de programas mora no kernel, e é a mesma que o SPAWN aceita: dois caminhos diferentes para executar arquivo seria um a mais para esquecer de proteger.

Camada técnica

Quem desenha por último é testado primeiro.

window_hit_test_64:
    mov rax, WINDOW_COUNT
.next:
    dec rax

As molduras são desenhadas na ordem da tabela, então as flutuantes cobrem as do sistema. A varredura do clique precisa ser a inversa, senão um clique numa janela de cima é atribuído à que ela está cobrindo.

Pelo mesmo motivo, os atalhos passaram de primeiro para último teste: agora qualquer janela passa por cima deles.

O bug que o dock encontrou

Processo sem pai vazava a vaga inteira.

O EXIT marcava a tarefa como zumbi e deixava a coleta para o WAIT do pai. Isso estava certo desde o Marco 16, porque todo processo tinha um pai que o pediu.

O programa aberto pelo clique não tem pai: ninguém vai chamar WAIT. Cada clique vazava uma vaga e uma janela flutuante, e em quatro cliques o desktop parava de abrir programa. Agora, sem pai, a vaga é coletada no próprio EXIT; com pai, ela continua zumbi de propósito.

O bug que a bateria verde escondeu

O cursor deixou um rastro de setas pela tela.

O present marca as duas posições do cursor, a velha e a nova, como danificadas. Com o texto na superfície, essa marcação passou a cair na caixa da superfície que estivesse sendo escrita no momento da interrupção, e o lugar antigo nunca era limpo.

A bateria estava verde: o cursor do teste parava dentro da janela do monitor, que se repinta duas vezes por segundo e apagava o rastro antes da captura. A asserção nova leva o cursor para um console ocioso e conta os pixels: uma seta tem exatamente 30.

E essa asserção nasceu certa pela metade, o que só apareceu no dia seguinte. Ver por que ela reprovou código correto ↓

Arrastar sem repintar sessenta vezes por segundo

O contorno anda; a janela só muda de lugar no fim.

Mover a janela a cada pacote do mouse custaria um repintado do desktop a 100 Hz. Durante o arrasto o kernel desenha só um retângulo de contorno, direto no front buffer, como faz com o cursor. Ao soltar, a janela muda de lugar e o desktop é repintado uma vez.

É o que o Windows 95 fazia por padrão, e pelo mesmo motivo. O contorno some sozinho: o present marca as quatro tiras dele como danificadas e as recopia do back buffer no quadro seguinte.

Isso durou um dia. A janela inteira passou a seguir o mouse a 25 Hz, e o que tornou o repintado barato foi o papel de parede virar uma cópia. Ver o que mudou ↓

Três estados, não dois

Minimizada sai da tela e fica na barra.

fechada     window_in_taskbar=0  window_open=0
minimizada  window_in_taskbar=1  window_open=0
na tela     window_in_taskbar=1  window_open=1

A primeira versão usava só um estado, e minimizar fazia o programa sumir da barra: sem botão e sem janela, a única forma de trazê-lo de volta era o atalho, o que transformava minimizar em fechar.

Para janela de programa há uma condição a mais: a tarefa dona precisa estar viva. Quando ela morre, o botão some sozinho, sem ninguém avisar a barra.

O limite honesto do compositor

Ele não recorta, então quem está por cima é reposto.

A superfície de cada janela é copiada inteira para a área dela, sem recortar contra as vizinhas. Uma janela de baixo que escreve o tempo todo, como o monitor, apagava a de cima duas vezes por segundo.

O conserto acontece na mesma passada: a moldura da janela de cima é redesenhada na hora, porque moldura não está em superfície nenhuma, e a superfície dela é marcada como suja, sendo composta em seguida na ordem de profundidade. Custa uma cópia a mais na área sobreposta, e nenhuma lista de retângulos.

Esconder não é encerrar

O mesmo botão, duas ações diferentes.

cmp rax, STATIC_WINDOW_COUNT
jae .close_program
mov [pending_hide_window], al

Fechar a janela do terminal, das notas ou do monitor esconde: as três tarefas são residentes e encerrá-las deixaria o sistema sem interface, que é a mesma regra do Ctrl+C desde o Marco 21. Fechar a janela de um programa aberto por clique encerra o programa, e a janela morre junto.

Por isso o hit test do botão devolve duas coisas: a janela e a tarefa dona. Quem decide é o chamador, e não um número sozinho.

O que a área de trabalho vazia prova

A janela fechada continua trabalhando.

As três tarefas do boot rodam com a janela escondida e escrevem na superfície delas o tempo todo. Clicar no atalho do monitor mostra o painel já preenchido, com os números que ele vinha calculando enquanto ninguém olhava.

É o teste mais direto de que a superfície é memória de verdade, e não um atalho para a tela: se fosse a tela, a janela escondida teria escrito no vazio.

Camada essencial

O rolo de filme e a janela.

Uma imagem no disco é uma tira longa de pontinhos em ordem, e a tela é um retângulo. Mostrar a foto é cortar a tira em linhas e pendurar cada uma na altura certa.

Duas coisas complicam, e as duas são do formato. O rolo está de trás para frente, porque o BMP guarda a última linha primeiro, herança de quem media a tela de baixo para cima em 1990. E cada linha tem um pedaço de sobra, porque o formato exige que ela ocupe um número de bytes múltiplo de quatro.

Camada técnica

Cabeçalho é dado hostil, e são cinco perguntas.

'BM'            senao nao e imagem
bfOffBits       depois dos dois cabecalhos
biWidth/Height  1 a 16.384; altura < 0 = topo primeiro
biBitCount      24 ou 32, e nada mais
biCompression   zero, ou os pixels nao sao pixels

A que mais importa é a segunda: deslocamento apontando para antes do fim dos cabeçalhos faz o programa desenhar o próprio cabeçalho como imagem, que é o começo de todo vazamento de memória adjacente.

E há uma sexta pergunta, que não está no cabeçalho: a última linha existe mesmo? O programa a lê antes de desenhar qualquer coisa. Sem isso, uma imagem truncada desenharia lixo da metade para baixo.

A prova que separa certo de quase certo

O marcador amarelo denuncia a imagem invertida.

A imagem de teste tem quatro quadrantes de cores diferentes e um quadrado amarelo no canto superior esquerdo. Os quadrantes provam que a imagem chegou; o marcador prova a ordem das linhas.

Se o programa lesse o BMP de cima para baixo, a imagem sairia espelhada na vertical, e os quatro quadrantes continuariam parecendo certos numa olhada rápida. No lugar do amarelo estaria o verde do quadrante de baixo, e é exatamente isso que o teste mede.

As dimensões são feias de propósito: 642 × 482. A largura em bytes não é múltiplo de quatro, então cada linha carrega dois bytes de enchimento, e nenhuma metade cai em número par. Uma imagem de 640 × 480 esconderia os dois erros.

O bug que a fatia encontrou, e não é de imagem

O diretório tinha 16 vagas; o sistema precisava de 18.

Com FOTO.ELF e FOTO.BMP, o volume passou a nascer com 16 arquivos. O diretório do SOIAFS1 era um setor de 512 bytes com entradas de 32, ou seja 16 entradas, e o sistema cria mais dois arquivos em uso: NOTE.TXT e GRANDE.BIN.

O sintoma foi o bloco de notas dizendo erro: NOTE.TXT nao foi salvo num disco com 29 MiB livres. Faltava linha no catálogo, e não espaço. O diretório passou a ter dois setores, e o build reserva duas vagas: ele recusa gastar as últimas, porque quem gasta só descobre em uso.

O dano silencioso da mesma mudança

Um literal perdeu o respaldo e ninguém viu.

; a montagem le o campo do superbloco
cmp dword [... BITMAP_LBA_OFFSET], FILESYSTEM_BITMAP_LBA

; a gravacao tinha o numero na mao
mov eax, FILESYSTEM_START_LBA + 2

Crescer o diretório empurrou o bitmap do LBA 2 para o 3. A montagem passou a exigir 3; a gravação continuou mandando para o 2. O comentário do arquivo até defendia o literal, dizendo que o 2 tinha respaldo porque a montagem recusava outro valor. O respaldo existia, e sumiu no instante em que a constante mudou.

O sintoma foi cruel. O arquivo era criado, o diretório ia ao disco, o conteúdo voltava intacto no boot seguinte, e só o bit daquele setor ficava zerado no bitmap gravado: o alocador entregaria o mesmo setor a outro arquivo depois. Nenhuma mensagem de erro. Quem pegou foi o teste de persistência, que confere o bitmap além do conteúdo.

O que a fatia deixou pronto para o PNG

O decodificador entra no meio, e nada mais muda.

O caminho está inteiro: arquivo no volume, leitura por deslocamento, validação de cabeçalho, ajuste à janela, escrita na superfície e composição. A fatia 2 troca uma coisa só, entre a leitura e o desenho: onde hoje há uma troca de ordem de bytes, entra o inflate.

E ele roda em ring 3 por decisão de projeto. Decodificador de mídia é vetor clássico de invasão, e no SOIA uma falha dele encerra a tarefa culpada sem derrubar o sistema, desde o Marco 21.