Emulando Linus Torvalds: Crie seu próprio sistema operacional do zero (I)

Antes de mais nada, comente que este é o meu primeiro artigo e que espero que gostem.

Nesta série, vamos emular Linus Torvalds, vamos criar nosso sistema operacional a partir de 0. Neste primeiro episódio veremos o boot e colocaremos um texto do nosso kernel na tela.

No meu caso, o sistema operacional é chamado PróximoDivel. A primeira decisão que devemos tomar assim que considerarmos o sistema operacional é qual será o bootloader?

Aqui existem várias variantes, e poderíamos até mesmo criar uma; no entanto, neste tutorial irei usar GRUB, porque a maioria sabe mais ou menos algo sobre ele. Nós criamos uma pasta que será a raiz do nosso sistema operacional e lá criamos a pasta / boot / grub

mkdir nextroot && cd nextroot

mkdir -p boot/grub

Lá, criamos o arquivo grub.cfg da seguinte maneira:

menuentry "NextDivel" {
echo "Booting NextDivel"
multiboot /next/START.ELF
boot
}


Neste arquivo, vimos como GRUB irá carregar nosso kernel, neste caso, em /next/START.ELF. Agora devemos criar nosso kernel.

Para isso, precisaremos do GCC y GAS (o montador do projeto GNU, geralmente vem com o gcc). Então, vamos criar o kernel.

Primeiro, criamos um arquivo chamado kernel.asm. Este arquivo conterá o ponto de partida do nosso kernel e também definirá a inicialização múltipla (um recurso de alguns gerenciadores de inicialização, como GRUB) O conteúdo de kernel.asm será:

.text
.globl start
start:
jmp multiboot_entry
.align 4
multiboot_header:
.long 0x1BADB002
.long 0x00000003
.long -(0x1BADB002+0x00000003)
multiboot_entry:
movl $(stack + 0x4000), %esp
call NextKernel_Main
loop: hlt
jmp loop
.section ".bss"
.comm stack,0x4000

Tudo relacionado à inicialização múltipla é simplesmente seguir as especificações e nada mais. Tudo vai começar no início, vai chamar multiboot_entry, teremos definido o cabeçalho multiboot nos primeiros 4k e vamos colocá-lo (com movl).

Posteriormente, chamamos NextKernel_Main, que é nossa função C do kernel. No loop, fazemos uma parada para parar o computador. Compila com:

as -o kernel.o -c kernel.asm

Agora vamos inserir a programação em C. Você vai pensar que agora tudo é moleza, colocamos um printf en principal e é isso, nós conseguimos.

Bem não, desde printf y principal são funções definidas pelo sistema operacional, mas nós as estamos criando! Só podemos usar as funções que definimos a nós mesmos.

Nos próximos capítulos, falarei sobre como colocar nossa própria biblioteca C (glibc, bionic, newlibc), mas de vez em quando. Discutimos que queremos colocar texto na tela, bem, veremos como o fazemos.

Existem duas opções, uma é chamar o BIOS e outra é gerenciar a memória da tela diretamente. Faremos o último porque é mais claro a partir de C e também nos permitirá fazer quando entrarmos no modo protegido.

Criamos um arquivo chamado NextKernel_Main.c com o seguinte conteúdo:

int NextKernel_Main()
{
char *str = "NextDivel says Hello World", *ch;
unsigned short *vidmem = (unsigned short*) 0xb8000;
unsigned i;
for (ch = str, i = 0; *ch; ch++, i++)
vidmem[i] = (unsigned char) *ch | 0x0700;
return 0;
}

Com isso, manipulamos diretamente a memória VGA e personagem por personagem estamos escrevendo. Compilamos desativando o stdlib:
gcc -o NextKernel_Main.o -c NextKernel_Main.c -nostdlib -fPIC -ffreestanding

Se você chegou até aqui, você vai querer experimentar seu novo sistema operacional agora, mas ainda não terminamos. Precisamos de um pequeno arquivo que diga ao compilador onde deixar cada seção no arquivo. Isso é feito com um script de vinculador. Nós criamos link.ld:

ENTRY(start)
SECTIONS
{
. = 0x00100000;
.multiboot_header :
{
*(.multiboot_header)
}
.text :
{
code = .; _code = .; __code = .;
*(.text)
. = ALIGN(4096);
}
.data :
{
data = .; _data = .; __data = .;
*(.data)
*(.rodata)
. = ALIGN(4096);
}
.bss :
{
bss = .; _bss = .; __bss = .;
*(.bss)
. = ALIGN(4096);
}
end = .; _end = .; __end = .;
}


Com isso definimos a posição de cada seção e o ponto de entrada, início, que definimos em kernel.asm. Agora podemos unir toda esta mistura:

gcc -o START.ELF kernel.o NextKernel_Main.o -Tlink.ld -nostdlib -fPIC -ffreestanding -lgcc

Agora copiamos START.ELF para / next dentro de nossa pasta que simula a raiz de nosso sistema operacional. Vamos para a pasta raiz de nosso novo sistema operacional com o console e verificamos se há dois arquivos: um /boot/grub/grub.cfg e outro /next/START.ELF.

Vamos para o diretório superior e chamamos um utilitário de criação de ISO com GRUB chamado grub-mkrescue

grub-mkrescue -o nextdivel.iso nextroot

Depois de fazer isso, teremos um ISO. Este ISO pode ser aberto em computadores x86 (64 bits também) e máquinas virtuais. Para testar, vou usar QEMU. Nós chamamos QEMU na linha de comando:

qemu-system-i386 nextdivel.iso

Vai começar BIOS marítimo e depois teremos GRUB. Mais tarde, se tudo estiver correto, veremos nossa frase.
Você vai pensar que isso é difícil, eu te respondo, é sim.

Realmente criar um sistema operacional é difícil e esse aqui não faz nada de útil. Nos próximos capítulos, veremos como lidar com as cores na tela, reservar memória e, se puder, como obter dados do teclado.

Se alguém não quiser copiar tudo aqui, tenho um repositório em GitHub (mais elaborado) com o sistema operacional PróximoDivel. Se você deseja compilar PróximoDivel você só precisa ter git e cmake:

git clone https://github.com/AdrianArroyoCalle/next-divel
cd next-divel
mkdir build && cd build
cmake ..
make
make DESTDIR=next install
chmod +x iso.sh
./iso.sh
qemu-system-i386 nextdivel.iso


Eu encorajo você a colaborar no NextDivel se você tiver tempo e desejar criar um sistema operacional. Talvez até superior ao Linux ... o tempo dirá.