Etterligne Linus Torvalds: Lag ditt eget operativsystem fra bunnen av (I)

Først av alt, kommenter at dette er min første artikkel, og at jeg håper dere alle liker det.

I denne serien skal vi etterligne Linus Torvalds, vi skal lage vårt operativsystem fra 0. I denne første episoden skal vi se oppstarten, og vi vil sette en tekst på skjermen fra kjernen vår.

I mitt tilfelle kalles operativsystemet NesteDivel. Den første avgjørelsen vi må ta så snart vi vurderer operativsystemet, er hva bootloader vil være?

Her er det flere varianter, og vi kan til og med lage en selv; men i denne opplæringen skal jeg bruke GRUB, fordi de fleste vet mer eller mindre noe om ham. Vi oppretter en mappe som vil være roten til operativsystemet vårt, og der lager vi mappen / boot / grub

mkdir nextroot && cd nextroot

mkdir -p boot/grub

Der oppretter vi grub.cfg-filen som følger:

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


I denne filen har vi sett hvordan GRUB vil laste kjernen vår, i dette tilfellet, i /next/START.ELF. Nå må vi opprette kjernen vår.

For dette trenger vi GCC y GAS (montøren av prosjektet GNU, kommer vanligvis med gcc). Så vi skal lage kjernen.

Først lager vi en fil som heter kernel.asm. Denne filen vil inneholde startpunktet til kjernen vår og vil også definere multiboot (en funksjon av noen bootloaders som GRUB). Innholdet i kernel.asm vil være:

.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

Alt relatert til multiboot er ganske enkelt å følge spesifikasjonen ingenting annet. Alt starter i start, det vil kalle multiboot_entry, vi vil ha definert multiboot-headeren i den første 4k og vi vil sette den (med movl).

Senere kaller vi NextKernel_Main som er vår C-funksjon. I sløyfen stopper vi for å stoppe datamaskinen. Dette kompileres med:

as -o kernel.o -c kernel.asm

Nå skal vi gå inn i programmering i C. Du vil tro at nå er alt et stykke kake, vi legger en printf en main og det er det, vi har gjort det.

Vel nei, siden printf y main de er funksjoner som er definert av operativsystemet, men vi lager dem! Vi kan bare bruke funksjonene som vi selv definerer.

I senere kapitler vil jeg snakke om hvordan vi kan sette vårt eget C-bibliotek (glibc, bionic, newlibc) men tid til annen. Vi har diskutert at vi ønsker å sette tekst på skjermen, og vi får se hvordan vi gjør det.

Det er to alternativer, det ene er å ringe BIOS og en annen er å administrere skjermminnet direkte. Vi skal gjøre det siste fordi det er tydeligere fra C, og det vil også tillate oss å gjøre det når vi går inn i beskyttet modus.

Vi oppretter en fil som heter NextKernel_Main.c med følgende innhold:

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

Med dette manipulerer vi minnet direkte VGA og karakter for karakter skriver vi den. Vi kompilerer ved å deaktivere stdlib:
gcc -o NextKernel_Main.o -c NextKernel_Main.c -nostdlib -fPIC -ffreestanding

Hvis du har kommet dit så langt, vil du prøve det splitter nye operativsystemet nå, men vi er ikke ferdige ennå. Vi trenger en liten fil som forteller kompilatoren hvor i filen skal forlate hver seksjon. Dette gjøres med et koblingsskript. Vi oppretter 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 = .;
}


Med dette definerer vi posisjonen til hver seksjon og inngangspunktet, start, som vi har definert i kernel.asm. Nå kan vi forene all denne sammenblandingen:

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

Nå kopierer vi START.ELF til / neste i mappen vår som simulerer roten til operativsystemet vårt. Vi går til rotmappen til vårt nye operativsystem med konsollen og bekrefter at det er to filer: en /boot/grub/grub.cfg og en annen /next/START.ELF.

Vi går til den øvre katalogen og kaller et ISO-opprettingsverktøy med GRUB kalt grub-mkrescue

grub-mkrescue -o nextdivel.iso nextroot

Når vi har gjort dette, vil vi ha en ISO. Denne ISO kan åpnes på datamaskiner x86 (64 bits også) og virtuelle maskiner. For å teste det, skal jeg bruke QEMU. Vi ringer QEMU fra kommandolinjen:

qemu-system-i386 nextdivel.iso

Vil starte SeaBIOS og senere vil vi ha GRUB. Senere, hvis alt er riktig, vil vi se frasen vår.
Du vil tro at dette er vanskelig, jeg svarer deg, ja det er det.

Det er vanskelig å lage et operativsystem, og at dette her ikke gjør noe nyttig. I fremtidige kapitler vil vi se hvordan du håndterer farger på skjermen, reserverer minne og hvis jeg kan, hvordan du får data fra tastaturet.

Hvis noen ikke vil kopiere alt her, har jeg et depot på GitHub (mer forseggjort) med operativsystemet NesteDivel. Hvis du vil kompilere NesteDivel du må bare ha git og 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


Jeg oppfordrer deg til å samarbeide om NextDivel hvis du har tid og lyst til å lage et operativsystem. Kanskje enda bedre enn Linux ... tiden vil vise.