-
Phil Oppermann (OS in Rust)
16/06/2018 21:00
Exceções de CPU são como aquele amigo que fica interrompendo todo mundo na festa para falar sobre o último bug que encontrou. Quando algo dá errado, como uma divisão por zero, é aí que as coisas ficam interessantes. Configurar uma tabela de descritores de interrupção para gerenciar essas exceções é o que dá aquele "up" no controle do nosso kernel. Afinal, quem não gostaria de ter um plano de contingência para evitar um "triple fault" na hora da ação?
-
Phil Oppermann (OS in Rust)
14/06/2018 21:00
Implementar um framework básico de testes de integração no QEMU é como dar uma volta no parque de diversões do desenvolvimento: divertido, mas requer um pouco de coragem. A prática de executar testes em uma máquina virtual simula um ambiente mais próximo do real, permitindo verificar se nosso código se comporta bem em situações reais. "A integração entre componentes... precisa de um ambiente realista" e, embora QEMU não seja tão nostálgico quanto hardware real, é uma ferramenta bastante prática para automatizar essa tarefa sem perder o foco no que realmente importa – que tudo funcione. Boa sorte tentando não deixar nenhum bug escapar, porque todos sabemos que eles se escondem melhor que o Mario em um bloco invisível.
-
Phil Oppermann (OS in Rust)
28/04/2018 21:00
O post traz à tona a complexidade de realizar testes unitários em executáveis no_std utilizando o framework de testes embutido do Rust. Como diz o texto, "unfortunately it’s a bit more complicated for no_std applications such as our kernel". A solução parece ser a configuração condicional para evitar aquele erro bem chato de duplicidade de itens de linguagem que aparece toda vez que você tenta rodar `cargo test`. Se você está jogando no time do Rust, prepare-se para lidar com esses detalhes técnicos de uma forma que até mesmo um Jedi ficaria orgulhoso.
-
Phil Oppermann (OS in Rust)
08/03/2018 21:00
Parece que a galera resolveu dar um reboot no projeto de criar um sistema operacional em Rust, agora sem depender de ferramentas em C. Eles conseguiram simplificar o processo de build, possibilitando a criação do SO nativamente em Windows, macOS e Linux. A proposta de escrever um bootloader próprio usando o recurso global_asm do Rust é interessante, pois promete deixar tudo mais limpo e sem as complicações de código assembly. No final das contas, isso deve facilitar bastante a vida dos desenvolvedores, que já têm muitos desafios na hora de lidar com sistemas operacionais.
-
Phil Oppermann (OS in Rust)
25/02/2018 21:00
O modo de texto VGA é como o console de um jogo antigo, onde cada letra que aparece tem seu próprio 'pixel' na tela, mesmo que na verdade seja só um buffer. O post traz uma abordagem segura para trabalhar com isso no Rust, encapsulando a parte 'perigosa' que pode causar bugs - que, convenhamos, são como zumbis em jogos de survival: você nunca quer ver um. Além disso, a implementação das macros de formatação do Rust torna a tarefa ainda mais amigável para os devs. Se você estava pensando em fazer uma homenagem aos anos 80 enquanto programa, esse é o caminho certo.
-
Phil Oppermann (OS in Rust)
09/02/2018 23:00
Criar um kernel mínimo em Rust para x86 é uma abordagem interessante, especialmente se considerarmos como a linguagem tem ganhado espaço por ser segura e moderna. Como o autor menciona, "após o auto-teste, ele procura um disco inicializável," e isso traz à tona o longo caminho que o boot process percorre. Embora a compatibilidade com BIOS facilite a vida de muitos, não dá pra ignorar os desafios de mover tudo para UEFI no futuro. Um verdadeiro teste de paciência e habilidade, como escrever um código em asm no final da madrugada.
-
Phil Oppermann (OS in Rust)
09/02/2018 23:00
Começar a desenvolver um kernel de sistema operacional do zero usando Rust e sem a biblioteca padrão é como construir um computador quântico com peças de LEGO: a ideia é incrível, mas os detalhes são um verdadeiro labirinto. O post fala sobre como criar um executável 'freestanding', ou como diria o Sheldon, 'sem dependências', o que é essencial já que você está basicamente criando sua própria versão do Windows, mas sem a tela azul de erro por enquanto. Se você está a fim de pisar nesse terreno bare-metal, a dica do 'no_std' é o primeiro passo para não se perder entre as abstrações do sistema operacional.
-
Phil Oppermann (OS in Rust)
25/03/2017 21:00
Neste post, o autor mergulha no maravilhoso mundo das exceções da CPU e explica como capturá-las, mesmo que isso possa levar seu sistema a um estado de 'bootloop' se tudo der errado. Olha, se você achava que sua última reunião era caótica, tente gerenciar exceções de primeira mão: 'Triple Fault' soa como o resultado de um bug que você não consegue nem ver. E a criação da 'Interrupt Descriptor Table' seria como fazer o mapeamento da sua rede Wi-Fi: crucial, mas tem uns detalhes que se não seguir à risca, pode dar erro. No fim, é uma introdução bem interessante para quem quer ganhar um crash course em sistemas operacionais tendo uma visão prática.
-
Phil Oppermann (OS in Rust)
01/01/2017 23:00
Esse post é um verdadeiro tratado sobre o conceito de falhas duplas e como lidar com elas. Não é todo dia que você vê alguém se aprofundar na implementação de uma Interrupt Stack Table para evitar falhas tripas – uma situação mais drástica do que um loop infinito em um programa. Como mencionado, "é realmente importante fornecer um manipulador de falha dupla", e isso não pode ser subestimado. Para quem está mergulhando no lado mais baixo nível da programação, é uma leitura imprescindível.
-
Phil Oppermann (OS in Rust)
20/09/2016 21:00
O post traz uma abordagem interessante sobre como lidar com exceções, mais especificamente com a exceção de breakpoint, que é uma armadilha digna de um debug-session. A parte sobre a instrução iretq e os registradores multimídia é um prato cheio para quem curte detalhes low-level, lembrando que, às vezes, o maior inimigo do desenvolvimento é o próprio código não tratado. É sempre bom ter um 'handler' pronto para se safar dessas armadilhas antes de dar aquele 'return'.
-
Phil Oppermann (OS in Rust)
02/08/2016 21:00
O post explora a arte de lidar com exceções de forma mais informativa, explicando como imprimir dados cruciais como ponteiros de instrução e de pilha. Detalhes como o alinhamento da pilha para instruções SSE poderiam até fazer um dev mais veterano se sentir nostálgico, quase como revisitar um bom código em assembly. E não esqueça, todo o código fonte está no GitHub, então a curva de aprendizado é apenas um ‘pull request’ de distância.
-
Phil Oppermann (OS in Rust)
27/05/2016 21:00
Este post mergulha na captura de exceções, começando pela configuração da tabela de descritores de interrupção. Ao final, nosso kernel estará apto a lidar com falhas de divisão por zero, um verdadeiro "You shall not pass" da programação. A complexidade das exceções, como "double faults" e "triple faults", é um lembrete de que desenvolver um kernel é como montar um quebra-cabeça com peças faltando: um erro e você pode ficar em um bootloop eterno. E quem precisa de uma máquina do tempo quando você pode revisar tudo no GitHub?
-
Phil Oppermann (OS in Rust)
10/04/2016 21:00
Neste post, vamos criar um heap do kernel e um alocador de memória. O que me chama a atenção é a complexidade que um bom alocador possui—jemalloc, por exemplo, tem mais de 30.000 linhas de código. Aqui, a proposta é desenvolver um alocador simples, mas capaz o suficiente para atender nossas necessidades de alocação em tempo de execução. A interface de alocação em Rust, com seu toque de 'unsafe', deixa claro que lidar com memória é como jogar Tetris: um movimento em falso e seu jogo pode acabar aí.
-
Phil Oppermann (OS in Rust)
31/12/2015 23:00
Neste post, vamos fortalecer a segurança do seu kernel, criando uma nova tabela de páginas com uma "guard page". A ideia de adicionar essa proteção é evitar os terríveis transbordamentos de pilha que podem causar bugs difícies de debugar, um verdadeiro pesadelo digno dos melhores memes de programação. Lembre-se, stack overflow não é apenas um site; pode ser seu código se você não tomar cuidado. No final das contas, mexer com níveis baixos do sistema sempre exige atenção e paciência, mas o esforço vale a pena.
-
Phil Oppermann (OS in Rust)
08/12/2015 23:00
Criar um módulo de paginação em Rust para manipular tabelas de páginas de 4 níveis é como montar um quebra-cabeça que só os devs mais ousados se atrevem a encarar. Essa abordagem é uma ótima maneira de entender como a separação entre memória virtual e física realmente funciona. Como bem lembrado, a arquitetura x86 usa um formato de 64 bits para essa mágica toda, e a introdução de funções para traduzir endereços virtuais é o pontapé inicial para quem quer se aprofundar no gerenciamento de memória. No fim, um lembrete: sempre olhe no GitHub para o código-fonte e, claro, não esqueça da seção de comentários para sugestões.
-
Phil Oppermann (OS in Rust)
14/11/2015 23:00
Este post é um mergulho na alocação de quadros de memória, vital para qualquer módulo de paginação futuro. A utilização da Estrutura de Informação Multiboot para obter dados sobre a memória disponível é uma jogada inteligente e prática. Como mencionam no texto, "a memória do núcleo e da estrutura de informação multiboot em si já consome parte da RAM disponível", então é necessário gerenciar isso cuidadosamente. E se alguém tiver ideias de como melhorar esse módulo, já sabe onde deixar os comentários: no GitHub.
-
Phil Oppermann (OS in Rust)
22/10/2015 23:00
O autor faz uma transição interessante de assembly para Rust, focando na segurança "que a linguagem oferece". Ao invés de usar recursos inseguros novamente, eles estão criando um módulo que facilita a impressão no buffer de texto VGA com suporte às macros de formatação do Rust. E é sempre bom lembrar que, para aproveitar os recursos mais recentes, ter uma versão atualizada do compilador é fundamental, ou você pode acabar como um loop infinito no terminal. Pronto para fazer seu terminal brilhar com essas cores?
-
Phil Oppermann (OS in Rust)
01/09/2015 21:00
Partir para um kernel Multiboot e transitar para o Rust sem um guia é como tentar programar em Assembly e abraçar os semáforos ao mesmo tempo. O post detalha a instalação do compilador nightly e como lidar com umas boas dores de cabeça, algo bem familiar para quem já se enfiou em um projeto de baixo nível. E se você achava que criar projetos com Cargo é sempre fácil, pense de novo; neste caso, a manualidade está no pacote. No fim, a jornada é cheia de aprendizados e, quem sabe, a conquista de um código que diz 'OKAY' no final de tudo.
-
Phil Oppermann (OS in Rust)
24/08/2015 21:00
Entrar no modo longo não é só uma questão de glamour 64-bits, mas sim de garantir que o seu kernel rustiqueiro suba sem problemas, a partir do protegido. Como mencionado, "o objetivo é estender e chamar o código Rust de 64 bits". A parte de verificar se o processador suporta as funcionalidades é crucial para evitar surpresas indesejadas — quem ainda não passou pela frustração de um erro esquisito num CPU mais antigo? E que tal essa abordagem de empacotar mensagens de erro em assembly? Simples e elegante, do jeito que a vida de um dev deve ser.
-
Phil Oppermann (OS in Rust)
17/08/2015 21:00
Criar um kernel simples com o padrão Multiboot é uma ótima maneira de desbravar o mundo dos sistemas operacionais, desde que você esteja preparado para o desafio. O autor deixa claro que não vamos entrar em enrascadas com bootloaders complexos, porque, convenhamos, ninguém gosta de trabalhar no longo prazo, a menos que seja o seu 8º projeto de graduação. E olha, a promessa de usar Rust nas próximas partes está animadora, só espero que não cause uma divisão no universo como o Angular vs React.