Emulând Linus Torvalds: Creați-vă propriul sistem de operare de la zero (I)

În primul rând, comentează că acesta este primul meu articol și că sper să vă placă tuturor.

În această serie vom emula Linus Torvalds, vom crea sistemul nostru de operare de la 0. În acest prim episod vom vedea boot-ul și vom pune un text pe ecran din nucleul nostru.

În cazul meu se numește sistemul de operare NextDivel. Prima decizie pe care trebuie să o luăm imediat ce luăm în considerare sistemul de operare este ce va fi bootloader-ul?

Aici există mai multe variante și am putea chiar să creăm una singură; cu toate acestea, în acest tutorial voi folosi GRUB, pentru că majoritatea știu mai mult sau mai puțin ceva despre el. Creăm un folder care va fi rădăcina sistemului nostru de operare și acolo creăm folderul / boot / grub

mkdir nextroot && cd nextroot

mkdir -p boot/grub

Acolo creăm fișierul grub.cfg după cum urmează:

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


În acest fișier am văzut cum GRUB ne va încărca nucleul, în acest caz, în /next/START.ELF. Acum trebuie să ne creăm nucleul.

Pentru aceasta vom avea nevoie de CGC y GAS (asamblatorul proiectului GNU, vine de obicei cu gcc). Deci, vom crea nucleul.

Mai întâi realizăm un fișier numit kernel.asm. Acest fișier va conține punctul de plecare al nucleului nostru și va defini, de asemenea, multiboot (o caracteristică a unor bootloadere, cum ar fi GRUB). Conținutul kernel.asm va fi:

.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

Tot ce ține de multiboot este pur și simplu să nu mai urmezi specificațiile nimic. Totul va începe la început, va apela multiboot_entry, vom avea definit antetul multiboot în primele 4k și îl vom pune (cu movl).

Mai târziu numim NextKernel_Main care este funcția noastră de nucleu C. În buclă ne oprim pentru a opri computerul. Aceasta se compilează cu:

as -o kernel.o -c kernel.asm

Acum vom intra în programare în C. Vei crede că acum totul este o bucată de tort, punem un printf en principal și atât, am făcut-o.

Nu, de atunci printf y principal sunt funcții care sunt definite de sistemul de operare, dar le creăm! Putem folosi doar funcțiile pe care le definim noi înșine.

În capitolele ulterioare voi vorbi despre cum să punem propria noastră bibliotecă C (glibc, bionic, newlibc), dar din când în când. Am discutat că vrem să punem text pe ecran, bine vom vedea cum o facem.

Există două opțiuni, una este să apelați BIOS-ul iar un altul este să gestionați memoria de ecran direct. Vom face acest lucru din urmă, deoarece este mai clar de la C și ne va permite, de asemenea, să o facem atunci când intrăm în modul protejat.

Creăm un fișier numit NextKernel_Main.c cu următorul conținut:

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;
}

Cu aceasta manipulăm direct memoria VGA și caracter cu caracter, îl scriem. Compilăm dezactivând stdlib:
gcc -o NextKernel_Main.o -c NextKernel_Main.c -nostdlib -fPIC -ffreestanding

Dacă ați ajuns până acum, veți dori să încercați sistemul dvs. de operare nou-nouț acum, dar nu am terminat încă. Avem nevoie de un mic fișier care să îi spună compilatorului unde se află fișierul pentru a părăsi fiecare secțiune. Acest lucru se face cu un script linker. Creăm 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 = .;
}


Cu aceasta definim poziția fiecărei secțiuni și punctul de intrare, start, pe care le-am definit în kernel.asm. Acum putem uni toate aceste preparate:

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

Acum copiem START.ELF în / următorul în folderul nostru care simulează rădăcina sistemului nostru de operare. Mergem în folderul rădăcină al noului nostru sistem de operare cu consola și verificăm dacă există două fișiere: unul /boot/grub/grub.cfg și altul /next/START.ELF.

Mergem în directorul superior și apelăm un utilitar de creare ISO cu GRUB numit grub-mkrescue

grub-mkrescue -o nextdivel.iso nextroot

Odată ce am făcut acest lucru, vom avea un ISO. Această ISO poate fi deschisă pe computere x86 (Și 64 de biți) și mașini virtuale. Pentru a-l testa, voi folosi QEMU. Noi sunam QEMU din linia de comandă:

qemu-system-i386 nextdivel.iso

Va incepe SeaBIOS și mai târziu vom avea GRUB. Mai târziu, dacă totul este corect, ne vom vedea fraza.
Veți crede că acest lucru este dificil, răspund, da, este.

Crearea cu adevărat a unui sistem de operare este dificilă și că acesta nu face nimic util. În capitolele viitoare vom vedea cum să gestionăm culorile pe ecran, să rezervăm memorie și dacă pot, cum să obținem date de la tastatură.

Dacă cineva nu vrea să copieze totul aici, am un depozit la GitHub (mai elaborat) cu sistemul de operare NextDivel. Dacă doriți să compilați NextDivel trebuie doar să ai git și 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


Vă încurajez să colaborați la NextDivel dacă aveți timp și dorința de a crea un sistem de operare. Poate chiar superior Linux ... timpul ne va spune.