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.

O aplicativo virou galeria

Espaço troca de imagem, e há uma foto de verdade.

O FOTO.ELF mostra duas imagens: a de prova, com os quadrantes, e uma foto real convertida de um PNG qualquer. A ordem é deliberada, porque a bateria fotografa a tela logo depois da abertura e mede cores exatas em posições calculadas, e nenhuma cor de uma paisagem serve para isso. Quem quer ver a foto aperta espaço; o teste não aperta nada.

O desktop ganhou o quinto atalho, FOTOS. Ele usa o desenho genérico de ícone, que pinta a inicial do rótulo: arte própria para cada programa novo não escala.

O relógio que virou corrida

O teste esperava por tempo; passou a esperar por sinal.

O terminal fica bloqueado em WAIT enquanto o programa aberto existir, e digitar antes de ele sair perde as teclas. Foi o que aconteceu: a bateria mandou run disco.elf e o log registrou n disco.elf, com o ru caindo no vazio.

Aumentar a espera só empurra o problema, porque o programa vive dez segundos depois de terminar de desenhar, e desenhar depende da máquina. O sinal certo já existia: a frase que ele imprime ao sair.

Fatia 2 · o PNG é decodificado

Inflate e cinco filtros, em ring 3.

abrindo FOTO.PNG...
PNG 642 x 482, 8 bits RGB; 3 chunks com CRC conferido
inflate: 928895 bytes comprimidos viraram 928332 de pixel, com Adler-32 conferido

A prova é a mesma cena duas vezes. O teste confere os mesmos seis pontos, com as mesmas cores, na imagem que veio do BMP e na que veio do PNG. O BMP não passa por nada: os bytes do arquivo são os pixels. O PNG passa por descompressão, cinco filtros de linha e troca de ordem de canais. Cor igual nos dois prova que o decodificador novo não inventou nada.

Três verificações, três perguntas diferentes. A assinatura pergunta "é um PNG?"; o CRC de cada chunk pergunta "este pedaço chegou inteiro?"; o Adler-32 pergunta "a descompressão chegou ao mesmo resultado que o compressor tinha?". Um arquivo truncado no meio de um IDAT passa em todas as checagens de cabeçalho e morre no CRC.

Os filtros erram em silêncio

A imagem aparece, e só o olho denuncia.

Antes de comprimir, o codificador escolhe por linha uma previsão que deixa os bytes parecidos entre si, porque bytes parecidos comprimem melhor: nada, o pixel da esquerda, o de cima, a média dos dois, ou o Paeth, que escolhe entre três vizinhos o mais perto de uma previsão linear.

Errar um deles não trava nada. A imagem aparece, com faixas ou arrasto de cor, e nenhuma verificação de integridade reclama, porque os bytes descomprimidos estavam certos. É por isso que a prova confere cores exatas em posições calculadas, e não "a imagem apareceu".

Um atalho por foto

O que faltava era o argumento, e ele virou a syscall 33.

A área de trabalho tem oito atalhos, e três abrem uma foto cada. Os quatro últimos usam o mesmo FOTO.ELF: o que muda é o argumento guardado na entrada do dock. Sem isso, um ícone por foto exigiria um binário por foto, ou uma lista fixa que ninguém muda sem recompilar o sistema.

O kernel copia o argumento para a vaga da tarefa, e não guarda o ponteiro. Hoje a string vive numa tabela do kernel, que não morre; no dia em que ela vier de ring 3, o ponteiro seria de outra tarefa, e o bug apareceria longe daqui. A vaga tem 16 bytes, o mesmo que um nome de arquivo, e argumento maior vira string vazia em vez de nome truncado: truncar produz pedido a um arquivo que não existe.

O mesmo argumento pelo teclado

run FOTO.ELF FOTO2.PNG, e o corte no primeiro espaço.

O clique já sabia dizer qual foto abrir; a linha digitada não. Agora sabe, e é o mesmo caminho: quem recebe o pedido não faz ideia se veio de um ícone ou de uma tecla.

soia> run foto.elf foto.bmp
aberto pelo argumento FOTO.BMP

O SPAWN passou a ler o argumento em RDX, e o terminal a cortar a linha no primeiro espaço. Sem o corte, run FOTO.ELF FOTO2.PNG vira um nome de programa de 18 caracteres e é recusado antes de existir. Zero em RDX significa "sem argumento" e não erro, então nenhum aplicativo antigo mudou.

A bateria digita o nome da imagem em que a galeria já começaria sozinha. Assim o argumento é provado sem mexer em nenhuma das capturas seguintes, que dependem da ordem BMP → espaço → PNG e conferem seis cores exatas. Prova nova que reorganiza a prova velha custa duas vezes.

O erro que essa mudança causou

RIP perto de zero é pilha desequilibrada.

SOIA excecao: instrucao invalida | vetor 6 | RIP 0x0000000000000007
SOIA excecao: falha em ring 0; o kernel nao tem a quem devolver o controle.

A rotina que lança programa ganhou um registrador salvo a mais, e o push ficou de fora numa edição enquanto os dois pop entraram: a função passou a voltar para um endereço tirado do lixo.

O relatório de exceção do Marco 21 resolveu isso em um minuto. Sem ele, o sintoma seria a máquina parada sem nenhuma pista. Ao mexer no prólogo de uma rotina em Assembly, conferir todos os caminhos de saída: as deste kernel costumam ter dois, um de sucesso e um de falha.

Duas medições, e nenhuma onde eu apostei

O gargalo não era o inflate.

Abrir uma foto de 1,9 MiB levava quase um minuto, e a suspeita óbvia era o decodificador. Medido no PC, o inflate dessa mesma foto custa 20 ms: o tempo estava em 486 leituras de 4 KiB, cada uma descendo ao disco ATA em PIO. O pedaço virou 64 KiB, que é o teto da fronteira das syscalls, e foram 31 chamadas.

A segunda: a imagem aparecia descendo linha a linha, com o texto do programa visível por baixo do que ainda não fora pintado. O compositor copia a superfície a cada quadro, e o desenho leva segundos. Agora o programa pinta um quadro fora da tela e copia de uma vez; a cópia de 2,2 MiB custa menos que o desenho de uma linha.

O algoritmo foi testado fora do sistema

Duzentos ciclos de dois minutos viraram trinta linhas.

Um ciclo no QEMU custa dois minutos e não tem depurador. O mesmo arquivo do inflate foi compilado para Windows num harness pequeno e rodado contra um PNG real, comprimido com Huffman dinâmico:

descomprimido: 4720997 bytes (esperado 4720997)
adler32 calculado: 18d8b04b | declarado: 18d8b04b

O Adler batendo sobre 4,7 MB é prova completa: cada byte saiu no lugar certo. O algoritmo entrou no SOIA já correto, e o que sobrou para depurar lá foi só a integração.

O bug que o atalho encontrou

Cinco das seis janelas não entregavam superfície.

Abrir o visualizador pelo atalho respondeu FALHA: o kernel nao entregou a superficie desta janela. A faixa de superfícies era repartida avançando largura × altura × 4, que não é múltiplo de 4.096, e quem entrega a superfície a ring 3 monta uma PTE, que aponta para página e não para byte. A primeira janela nascia alinhada porque a faixa é; as outras cinco, não.

Isso estava lá desde o Marco 25. O único aplicativo que pedia superfície era aberto por run, e nesse caminho o filho herda a janela do pai, que é a do terminal, que é a janela 0, a única alinhada. Recurso testado sempre pelo mesmo caminho é recurso testado num caso só, e o caso que a bateria escolhe costuma ser o mais fácil.

O arquivo de prova é montado à mão

zlib byte a byte, sem biblioteca.

O PNG de teste sai de um script que monta o fluxo zlib inteiro: CMF/FLG, blocos stored e Adler-32. Um bloco stored carrega os bytes crus com cinco bytes de cabeçalho, então o arquivo é um PNG legítimo, que qualquer visualizador abre, e a metade mais simples do inflate já dá conta dele.

Usar a biblioteca pronta do sistema produziria o fluxo comprimido e esconderia justamente o que o exercício quer mostrar.

Fatia 3 · o JPEG

A primeira perda deliberada do sistema.

abrindo FOTO.JPG...
JPEG 642 x 482, croma 2x2; 1271 MCUs decodificados de 1271
IDCT: 8621 bytes comprimidos viraram 928332 de pixel

Os três arquivos desenham exatamente a mesma coisa. O primeiro ocupa 929 KB, o segundo também, e o terceiro cabe em 8,6 KB. A diferença é que o JPEG joga fora informação antes de guardar, e escolhe jogar fora justamente o que o olho não cobra.

Huffman, DC diferencial e marcadores são exatos; a única etapa com perda é a divisão pela tabela de quantização, que aconteceu no codificador e não tem volta. É por isso que o PNG fecha com Adler-32 e o JPEG não tem equivalente: não existe resultado esperado para conferir.

Onde o MCU entra

Croma menor obriga a intercalar em pedaços.

Com a crominância subamostrada, os três componentes têm tamanhos diferentes e não dá para alternar bloco a bloco. O arquivo intercala em minimum coded units: em 4:2:0, um pedaço de 16 × 16 pixels com quatro blocos de luminância e um de cada crominância. Uma imagem de 642 × 482 tem 41 × 31 = 1.271 deles, e a bateria confere essa conta em vez de aceitar o número que o programa imprimiu.

A IDCT é separável: em duas passadas de oito, 1.024 multiplicações por bloco em vez de 4.096. E há o atalho do bloco constante, quando só o coeficiente 0 sobrevive: aí o bloco é uma cor chapada e as 1.024 viram uma.

A prova mudou de forma

Igualdade virou distância, com o número medido.

Nas duas primeiras fatias o teste exige cor exata nos seis pontos. Aqui isso reprovaria um decodificador correto, porque o formato guarda uma aproximação. A asserção passou a ser distância máxima de 8 níveis por canal.

O 8 saiu de medição, não de gosto: o erro real nos cinco pontos de quadrante é de 0 a 1 nível. Oito dá folga para outra versão do encoder e continua reprovando de longe qualquer erro de verdade, porque trocar canais ou inverter linhas muda dezenas.

O diagnóstico que a média escondia

Separar por componente transformou dúvida em resposta.

contra a referencia: erro medio 1.6572, pior 71
erro medio luma 0.2099 | Cb 1.4915 | Cr 1.1890

Comparado com o decodificador do Windows, o resultado divergia em média 1,66 por byte. Esse número serve tanto para "está correto" quanto para "está errado", e por isso não decide nada.

Separado por componente, ele decide. A luminância, que não passa por reamostragem, bate com 0,21: Huffman, quantização, IDCT e DC diferencial estão certos. Todo o desvio está na crominância, e a causa é conhecida: o SOIA reamostra por vizinho mais próximo e a implementação madura interpola. Regra que fica: diferença agregada não vira diagnóstico até ser separada pelas partes que a produzem.

Por que este gerador NÃO é escrito à mão

O par escrito pela mesma cabeça concorda com os próprios enganos.

O gerador do PNG monta o fluxo zlib byte a byte de propósito, porque um bloco cru cabe em trinta linhas. JPEG não tem equivalente: não existe bloco cru, então qualquer arquivo válido exige DCT, quantização e Huffman no gerador, o que seria escrever o decodificador ao contrário.

O arquivo de prova sai do codec que já vem no Windows. Abrir o que outra implementação produziu é prova de interoperabilidade; abrir o que eu mesmo gerei seria prova de coerência interna, que é bem mais barata e vale bem menos.

O byte que quase virou bug

Recuar um byte antes de parar.

Dentro da varredura, todo 0xFF é seguido de outro: 0x00 quer dizer "é um 0xFF de verdade" e qualquer outra coisa é marcador. Sem esse enchimento, um coeficiente qualquer poderia formar a assinatura de um marcador no meio da imagem.

Ao encontrar um marcador, o leitor precisa recuar um byte, para que a busca pelo reinício seguinte ache o 0xFF e não o byte depois dele. A primeira versão não recuava, e o sintoma não apareceria em nenhum arquivo da galeria: apareceria no primeiro arquivo de câmera com intervalo de reinício, com a imagem escorregando na horizontal a partir do meio.

Como é

Dezesseis bytes por letra, o bit 7 à esquerda.

O handler valida a faixa com validate_user_write_range_64 e copia 256 × FONT_GLYPH_HEIGHT bytes. Cada byte é uma linha do glifo. Escalar é repetir cada bit num quadrado N × N, e é isso que dá um título em corpo triplo sem fonte nova.

O texto de prova sai em (37, 61), escala 3: 37 não é múltiplo de 8 e 61 não é múltiplo de 16, e 24 × 48 não é um corpo que a syscall de texto tenha como produzir. Um texto ali só pode ter vindo do desenho por pixel.

Por que fizemos assim

Copiar, nunca mapear. E uma vez, não por glifo.

Mapear 0x6000 no espaço da tarefa entregaria uma página da memória baixa do kernel a um processo que só precisa dos bytes. O kernel copia.

E é uma cópia só: com a fonte e a superfície na mão, um título em corpo dobrado custa zero ida ao kernel. Por uma syscall de desenho por glifo, custaria 8.192.

O cld antes do rep movsb é defesa, não estilo: o iretq não limpa DF, e um programa que executasse std antes do INT 0x80 faria a cópia andar para trás em ring 0, escrevendo abaixo do buffer aprovado.

O que muda

Texto onde quiser; letra nova, ainda não.

Passa a existir: título maior que o corpo, legenda fora da linha, texto centralizado por pixel, desenho de texto num quadro fora da tela no heap.

Continua impossível: outro desenho de letra e meio tamanho. A fonte é uma só, 8 × 16, e a escala é inteira. Fonte vetorial com contorno e curva é marco próprio.

A prova tem duas metades que não se falam

Contar bits e desenhar pixel são códigos diferentes.

glyph_text_pixels percorre a fonte; glyph_draw_text percorre o alvo, com passo de linha, posição e recorte. Exigir que as duas deem o mesmo número transforma erro de pitch, de posição e de recorte numa asserção só.

A captura da tela é a outra metade: ela prova que os 1.863 pixels chegaram ao framebuffer, na cor certa. E cada elemento tem balde próprio na contagem — com uma cor só, um erro no texto poderia ser compensado por um erro no quadrado e a soma continuaria fechando.

O bug que essa fatia encontrou

Não era captura cedo demais. Era o pai escrevendo por cima.

A bateria acusou Nenhuma amostra da superficie esta inteira, com as três amostras idênticas e 1.920 pixels de barra faltando. A explicação óbvia, e registrada no roteiro desde julho, era captura tirada antes de o desenho terminar.

Separando os pixels estranhos por posição e cor, a resposta veio em um minuto: 464 pixels de largura na altura 224, na cor do texto sobre a cor do console. O padrão de palavras era 8 9 3 2 1 8 9 3 6, e isso é uma frase: Processo iniciado; PID 4. O terminal aguardara sua saida.

O pai. O terminal faz SPAWN, imprime a linha e só então entra em WAIT; o filho começa a rodar no meio disso, e os dois escrevem na mesma superfície. A correção é do filho: dormir vinte ticks antes de desenhar, quatrocentas vezes a folga que o pai precisa. Diferença agregada não vira diagnóstico até ser separada.

Como é

O programa escolhe a faixa, e a tela nunca rola.

browser_paint pula os trechos com row < top e para no primeiro com row >= top + visible. O que sobra é preenchido com linhas vazias até fechar a faixa: sem elas, o rodapé subiria e a última tela ficaria com o texto de posição num lugar diferente do resto.

visible = window.rows - 3. As três são o título, o rodapé e uma linha livre depois dele.

Por que fizemos assim

A linha livre não é enfeite.

Sem ela, qualquer aviso (nao existe link com esse numero) rolaria a tela inteira uma linha, e o desenho passaria a mentir sobre onde a página começa.

O passo do espaço é visible - 1, com uma linha de sobreposição, pelo mesmo motivo do more: sem ela, a última linha lida some antes de ser lida de novo.

E o resumo do parser saiu da tela para a serial. css:, layout: e a lista de links são diagnóstico, não conteúdo: mantê-los no mesmo espaço da página foi o que fez uma página de 35 linhas nunca caber numa janela de 35.

O que muda

O pé da página passou a existir.

A frase Fim da pagina de prova. é a linha 35, e a bateria só a encontra depois do espaço. Antes ela aparecia de graça — e era o começo que se perdia, sem volta.

Continua fora: barra de rolagem arrastável, roda do mouse (o protocolo PS/2 básico do Marco 20 não tem) e Page Up, porque soia_read_key entrega caractere.

Como é

Três perguntas, três peças novas.

Qual janela é a minha: SYSTEM_INFO_SELF_WINDOW, que lê task_window[current_task], a mesma fonte que o kernel usa para desenhar.

Onde a grade dela pousa: WINDOW_INFO_SIZE foi de 72 para 88 bytes, com text_x e text_y.

O que está na célula: layout_run_t.link, que o layout carimba em todos os trechos do <a>, do texto ao [1].

Por que fizemos assim

Foco não responde "qual é a minha".

FOCUSED_WINDOW e SELF_WINDOW coincidem enquanto o programa em primeiro plano pergunta, e divergem no instante em que ele perde o foco — que é exatamente quando atribuir um clique corretamente importa.

O recuo da moldura e a altura da barra de título são geometria do kernel. Copiar as duas constantes para o aplicativo criaria duas verdades sobre a mesma janela, e a cópia passaria a mentir no dia em que a barra mudasse de altura.

E o clique vira a mesma tecla que o teclado produziria: dois caminhos para o mesmo destino fazem o segundo herdar os bugs do primeiro sem herdar as correções.

O bug que custou uma bateria

Zero é sucesso, e o erro passou calado.

soia_mouse_event devolve 0 em sucesso e um erro negativo quando a fila está vazia, como toda syscall deste kernel. Com if (... <= 0) break;, o laço saía no primeiro evento e o clique nunca chegava.

Sem nenhum sinal: o navegador seguia funcionando pelo teclado e a bateria inteira passava. Só o contador cliques em link: 0 denunciou. Recurso que pode falhar em silêncio precisa de contador exposto, não de asserção de comportamento.

O teste faz a conta inversa

Duas conversões independentes, e o alvo é o encontro.

O roteiro converte célula para pixel; o aplicativo converte pixel para célula. Um erro em qualquer uma erra o alvo. E o clique mira o meio de uma palavra, não a primeira letra: mirar na borda de um trecho testa arredondamento, não hit test.

De forma didática

Duas réguas para o mesmo ponto.

O mouse conta a partir do canto da tela. O programa pensa em linha da página. Entre as duas há uma janela que pode estar em qualquer lugar, e uma página que pode estar rolada: o dedo não sai do lugar e a linha apontada muda.

Por isso a conta precisa de três termos, e não de dois: origem da grade (do kernel), tamanho da célula (8 × 16) e deslocamento da rolagem (do aplicativo). Tirar qualquer um deles produz um resultado que funciona no caso mais fácil e erra assim que a janela ou a página se mexem.