Efterligne Linus Torvalds: Opret dit eget operativsystem fra bunden (I)

Først og fremmest skal du kommentere, at dette er min første artikel, og at jeg håber, at du alle kan lide det.

I denne serie skal vi efterligne Linus Torvalds, vi skal oprette vores operativsystem fra 0. I denne første episode skal vi se boot, og vi lægger en tekst på skærmen fra vores kerne.

I mit tilfælde kaldes operativsystemet NæsteDivel. Den første beslutning, vi skal tage, så snart vi overvejer operativsystemet, er hvad bootloaderen vil være?

Her er der flere varianter, og vi kunne endda skabe en selv; dog i denne vejledning skal jeg bruge GRUB, fordi de fleste ved mere eller mindre noget om ham. Vi opretter en mappe, der vil være roden til vores operativsystem, og der opretter vi mappen / boot / grub

mkdir nextroot && cd nextroot

mkdir -p boot/grub

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

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


I denne fil har vi set hvordan GRUB vil indlæse vores kerne, i dette tilfælde i /next/START.ELF. Nu skal vi oprette vores kerne.

Til dette har vi brug for GCC y GAS (projektets montør GNU, kommer normalt med gcc). Så vi skal oprette kernen.

Først opretter vi en fil, der hedder kernel.asm. Denne fil indeholder startpunktet for vores kerne og definerer også multiboot (en funktion i nogle bootloaders som f.eks. GRUB). Indholdet af 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 relateret til multiboot er simpelthen ikke at følge specifikationen ikke mere. Alt starter i start, det kalder multiboot_entry, vi har defineret multiboot-header i den første 4k, og vi vil sætte det (med movl).

Senere kalder vi NextKernel_Main, som er vores kernel C-funktion. I sløjfen stopper vi for at stoppe computeren. Dette kompileres med:

as -o kernel.o -c kernel.asm

Nu skal vi gå ind i programmering i C. Du vil tro, at nu er alt et stykke kage, vi sætter en printf en main og det er det, vi har gjort det.

Nå nej, siden printf y main de er funktioner, der er defineret af operativsystemet, men vi opretter dem! Vi kan kun bruge de funktioner, som vi selv definerer.

I senere kapitler vil jeg tale om, hvordan vi kan placere vores eget C-bibliotek (glibc, bionic, newlibc) men tid til anden. Vi har talt om, at vi vil lægge tekst på skærmen, og vi får se, hvordan vi gør det.

Der er to muligheder, den ene er at ringe til BIOS og en anden er at styre skærmhukommelsen direkte. Vi skal gøre sidstnævnte, fordi det er klarere fra C, og det vil også give os mulighed for at gøre det, når vi går ind i beskyttet tilstand.

Vi opretter en fil kaldet NextKernel_Main.c med følgende indhold:

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 hukommelsen direkte VGA og karakter for karakter skriver vi det. Vi kompilerer ved at deaktivere stdlib:
gcc -o NextKernel_Main.o -c NextKernel_Main.c -nostdlib -fPIC -ffreestanding

Hvis du er nået så langt, vil du prøve dit helt nye operativsystem nu, men vi er ikke færdige endnu. Vi har brug for en lille fil, der fortæller kompilatoren, hvor i filen skal forlade hvert afsnit. Dette gøres med et linkerscript. Vi opretter 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 placeringen af ​​hvert afsnit og indgangspunktet, start, som vi har defineret i kernel.asm. Nu kan vi forene al denne sammensætning:

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

Nu kopierer vi START.ELF til / næste inde i vores mappe, der simulerer roden til vores operativsystem. Vi går til rodmappen på vores nye operativsystem med konsollen og kontrollerer, at der er to filer: en /boot/grub/grub.cfg og en anden /next/START.ELF.

Vi går til den øverste mappe og kalder et ISO-oprettelsesværktøj med GRUB kaldet grub-mkrescue

grub-mkrescue -o nextdivel.iso nextroot

Når vi har gjort dette, får vi en ISO. Denne ISO kan åbnes på computere x86 (64 bit også) og virtuelle maskiner. For at teste det skal jeg bruge QEMU. Vi ringer QEMU fra kommandolinjen:

qemu-system-i386 nextdivel.iso

Vil starte SeaBIOS og senere får vi det GRUB. Senere, hvis alt er korrekt, ser vi vores sætning.
Du vil tro, at dette er svært, svarer jeg, ja det er det.

Det er svært at oprette et operativsystem, og at dette her ikke gør noget nyttigt. I fremtidige kapitler vil vi se, hvordan man håndterer farver på skærmen, reserverer hukommelse, og hvis jeg kan, hvordan man får data fra tastaturet.

Hvis nogen ikke vil kopiere alt her, har jeg et lager på GitHub (mere detaljeret) med operativsystemet NæsteDivel. Hvis du vil kompilere NæsteDivel du skal bare have 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 opfordrer dig til at samarbejde om NextDivel, hvis du har tid og lyst til at oprette et operativsystem. Måske endda bedre end Linux ... tiden vil vise det.