#: Trem uma sessão de treinamento para construir um sistema operacional. A partir do zero, apenas usando recursos da AMD e da Intel .
Ainda em estágio alfa
Esse repositório ainda não foi polido e ainda precisa ser considerado no estágio alfa. O código deve compilar e trabalhar, mas as mensagens de texto são apenas o primeiro rascunho que observei além de codificar e pesquisar.
O que é diferente de outros tutoriais?
Existem muitos tutoriais e uma grande parte do material que apresento também é coberta lá. Então, por que se preocupar? Eu gosto especialmente e me inspirei por estes:
- Phil ToDO: Link
- Intermezzos: TODO: Link
O que é diferente nesta versão? Quando aprendo coisas novas, muitas vezes tenho a sensação de que não sei/aprendo como poderia fazer o que fiz completamente por conta própria na próxima vez. Não sei se é assim que aprendo ou apenas uma coisa típica que é facilmente omitida ao escrever tutoriais. Aqui estão alguns pontos que estou me perguntando regularmente e que quero abordar (provavelmente vou perder outras coisas essenciais para compensar)
- Forneça mais alguns detalhes sobre quais pontos simplesmente são convenções acordadas, o que é um padrão, o que é específico da arquitetura. Ainda me lembro de quando comecei a aprender a programação, na adolescência, fiquei tipo "Uuhh ... como o computador sabe que a função principal precisa ser chamada de primeiro" e nenhum dos meus amigos ou professores novos. Era apenas "mágica". Essas coisas me incomodam , eu quero usar de onde vêm as coisas ...
- Apontar para o padrão e trabalhar a partir daí. Não vou apresentar uma solução final que você apenas copia. Pegamos o padrão e, na verdade, olhamos as coisas . Assim como teríamos que precisaríamos se gostaríamos de executar o código, digamos um córtex de braço em vez da sua máquina x86_64. Ou, emoldurado de maneira diferente, e se formos os primeiros a escrever um tutorial, como iríamos que esse carregador de inicialização iria, as interrupções configuradas ou a CPU no modo de 64 bits em primeiro lugar?
- Faça as coisas duas vezes. Primeiro, vou ir aos Barebones, isso ajuda a entender o que está acontecendo e, em seguida, usamos ferramentas para evitar o trabalho de terreno todas as vezes.
- Etapas intermediárias e "pontos de verificação"
- Dê um esboço primeiro -> para ver a imagem maior
- Dê exemplos em código real -> por exemplo, que a primeira lixeira do kernel é realmente exatamente como o Linux é construído
- Apresentar alternativas/opções para cada
dependency que começamos a usar. Para mim, é chatice se eu quiser seguir um tutorial e muitas bibliotecas externas fazem a mágica que eu realmente queria aprender.
Contorno
Um esboço aproximado do que eu quero fazer. Felizmente, em uma ordem mais ou menos cronológica. O ponto é que há tanta coisa que poderíamos fazer que é realmente difícil escolher um caminho.
Primeiro, gostaria de entender melhor o processo de inicialização. O que acontece antes que o bootloader entre. Na verdade, rolando seu próprio carregador de inicialização (link para a OSDEV) é uma tarefa enorme por si só.
Meu plano é explorar um pouco a fase inicial do processo de inicialização. O objetivo disso é entender e apreciar o que um carregador de inicialização está fazendo por nós. No final, gostaria de ter um entendimento aproximado dos diferentes modos de processador, o que eles oferecem e como mudar para o modo protegido de 32 bits. O objetivo concreto é poder mudar para o modo protegido e imprimir Hello World! para a tela. Tudo implementado na montagem e sem o uso de um carregador de inicialização.
Depois disso, pretendo alternar e usar o GRUB como um carregador de inicialização. E continue a partir daí.
Tl; dr
- Escreva uma imagem inicializável mínima.
- Bootloader que imprime
Hello World no modo real de 16 bits. - Mude manualmente para o modo protegido de 32 bin e imprima
Hello World . - Mudar manualmente para o modo de 64 lixas
- Use Grub como bootloader e imprima
Hello World . - Mude para o modo longo (novamente).
- Entre em
C , imprima Hello World . - Pilha
- Implementar driver de vídeo VGA.
- Interrupções (parte 1) - diga à CPU onde encontrar manipuladores, no ASM
- Interrupções (parte 2) - Mova o código de 10.
- Implementar melhores manipuladores
- Depuração
- Lidar com interrupções/exceções
- Implementar a paginação de memória.
- REMAP KERNEL
não especificado:
- refatorando?
- Utilitários (MEMSEST?)
Mais tarde...
- FileSystem
- processos
- programação
- chamadas do sistema
- Explore a pilha, provocará transbordamentos e exceções
- Conecte -se ao GDB via UART (para depuração e visualização incorporada)
- Compile cruzado algumas (ou muitas) peças para um processador de braço. (Eu tenho um STM e uma tábua infineon deitada em torno de não utilizada)
Pré -requisitos?
Nenhum. Sério, não fique com medo. O objetivo deste tutorial é desenvolver todo o conhecimento necessário desde o início. Presumo apenas uma condição, e é que você pode programar decentemente. Por decente, quero dizer que você pelo menos já ouviu falar sobre a pilha e a pilha e pode ser produtivo em algum idioma. Eu acho que isso deve ser suficiente. Afinal, não estamos tentando desenvolver o sistema operacional principal da próxima geração aqui, estamos mexendo em um nível de hobby.
E uma coisa que eu posso garantir: mesmo que você nunca tocar nesse código e nunca mais escreverá um sistema operacional. A experiência mudará sua compreensão dos sistemas em que você está trabalhando profundamente . O conhecimento obtido com o desenvolvimento do nível do kernel se espalha como sementes ao longo de sua carreira e as idéias serão úteis nos momentos mais inesperados.
ScratchPad (idéias não organizadas daqui em diante)
Idéias
- O que a CPU faz se você colocar instruções após os primeiros 512 bytes? Eles são executados? (CPU está no modo real de 16 bits)
Contorno
- Bootload -> Duas opções rolam suas próprias ou usam o Grub, por exemplo, Grub.
- Modo de 16 bits
- entrando no modo protegido de 32 bits
- entrando no modo longo de 64 bits
- digite c
- Escreva o módulo de gerenciamento de memória
Ciclo 0 - Chain de ferramentas de meio ambiente e compilação cruzada
- Você pode pular algumas das etapas. Não precisaremos do Cross Compilation Toolcaine antes de começarmos a escrever o código C.
- Comece a construir sua cadeia de ferramentas em algum lugar abaixo de $ Home
- Verifique se o escopo das variáveis de ambiente está correto
- Erros como "Não têm permissão para criar diretórios
/usr/lib/i686-elf " indicam que $PREFIX não está definido corretamente. - Não estamos recebendo a CPU "real" dos barebones, ainda há o BIOS diante de nós. Ele inicializa a CPU e entrega para nós com a CPU no modo real.
Ciclo 0 - Bootloader
Recursos
- Documentação do NASM https://www.nasm.us/xdoc/2.14.02/html/nasmdoc3.html
- Manuais Intel