Posnemanje Linusa Torvaldsa: ustvarite svoj operacijski sistem iz nič (I)

Najprej komentirajte, da je to moj prvi članek in upam, da je vsem všeč.

V tej seriji bomo posnemali Linus Torvalds, svoj operacijski sistem bomo ustvarili od 0. V tej prvi epizodi si bomo ogledali zagonski sistem in na jedro bomo dali besedilo na zaslon.

V mojem primeru se pokliče operacijski sistem NextDivel. Prva odločitev, ki jo moramo sprejeti takoj, ko pomislimo na operacijski sistem, je, kakšen bo zagonski nalagalnik?

Tu obstaja več različic in eno bi lahko celo ustvarili sami; vendar bom v tej vadnici uporabil GRUB, ker večina ve več ali manj nekaj o njem. Ustvarimo mapo, ki bo koren našega operacijskega sistema, in tam ustvarimo mapo / boot / grub

mkdir nextroot && cd nextroot

mkdir -p boot/grub

Tam ustvarimo datoteko grub.cfg, kot sledi:

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


V tej datoteki smo videli, kako GRUB bo naše jedro naložil v tem primeru v /next/START.ELF. Zdaj moramo ustvariti svoje jedro.

Za to bomo potrebovali GCC y GAS (monter projekta GNU, ponavadi je priložen gcc). Torej bomo ustvarili jedro.

Najprej naredimo datoteko z imenom kernel.asm. Ta datoteka bo vsebovala začetno točko našega jedra in bo opredeljevala tudi večzagon (značilnost nekaterih zagonskih nalagalnikov, kot je npr. GRUB). Vsebina kernel.asm bo:

.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

Vse, kar je povezano z multibootom, je preprosto slediti specifikaciji nič drugega. Vse se bo začelo v startu, poklicalo bo multiboot_entry, v prvih 4k bomo definirali glavo več zagonov in ga postavili (z movl).

Kasneje pokličemo NextKernel_Main, ki je naša funkcija jedra C. V zanki ustavimo računalnik. To je sestavljeno iz:

as -o kernel.o -c kernel.asm

Zdaj bomo vstopili v programiranje v C. Mislili boste, da je zdaj vse skupaj, smo postavili printf en Glavni in to je to, to smo že storili.

No ne, saj printf y Glavni so funkcije, ki jih določa operacijski sistem, vendar jih ustvarjamo! Uporabljamo lahko samo funkcije, ki jih določimo sami.

V naslednjih poglavjih bom govoril o tem, kako postaviti lastno knjižnico C (glibc, bionic, newlibc), vendar občasno. Razpravljali smo o tem, da želimo postaviti besedilo na zaslon, pa bomo videli, kako bomo to storili.

Obstajata dve možnosti, ena je, da pokličete BIOS drugo pa je neposredno upravljanje pomnilnika zaslona. Slednje bomo storili, ker je bolj jasno od C in nam bo to tudi omogočilo, ko vstopimo v zaščiten način.

Ustvarimo datoteko z imenom NextKernel_Main.c z naslednjo vsebino:

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

S tem neposredno manipuliramo s spominom VGA in znak za znakom pišemo. Zberemo tako, da onemogočimo stdlib:
gcc -o NextKernel_Main.o -c NextKernel_Main.c -nostdlib -fPIC -ffreestanding

Če ste prišli tako daleč, boste zdaj želeli preizkusiti svoj popolnoma nov operacijski sistem, vendar še nismo končali. Potrebujemo majhno datoteko, ki prevajalniku pove, kje v datoteki naj zapusti vsak odsek. To se naredi s povezovalnim skriptom. Ustvarimo 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 = .;
}


S tem določimo položaj vsakega odseka in vstopno točko, start, ki smo jo določili v kernel.asm. Zdaj lahko združimo vso to domislico:

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

Zdaj kopiramo START.ELF v / zraven v našo mapo, ki simulira koren našega operacijskega sistema. S konzolo odpremo korensko mapo našega novega operacijskega sistema in preverimo, ali obstajata dve datoteki: ena /boot/grub/grub.cfg in druga /next/START.ELF.

Gremo v zgornji imenik in pokličemo pripomoček za ustvarjanje ISO s klicem GRUB grub-mkrescue

grub-mkrescue -o nextdivel.iso nextroot

Ko bomo to storili, bomo imeli ISO. Ta ISO je mogoče odpreti v računalnikih x86 (Tudi 64 bitov) in navidezni stroji. Da ga preizkusim, bom uporabil QEMU. Mi kličemo QEMU iz ukazne vrstice:

qemu-system-i386 nextdivel.iso

Bo začel SeaBIOS in kasneje bomo imeli GRUB. Kasneje, če je vse pravilno, bomo videli naš stavek.
Mislili boste, da je to težko, odgovorim, da je.

Resnično je ustvariti operacijski sistem težko in da ta tukaj ne naredi nič koristnega. V prihodnjih poglavjih bomo videli, kako ravnati z barvami na zaslonu, si rezervirati pomnilnik in, če lahko, kako pridobiti podatke s tipkovnice.

Če nekdo ne želi vsega kopirati tukaj, imam na tem mestu skladišče GitHub (bolj dodelano) z operacijskim sistemom NextDivel. Če želite prevesti NextDivel samo imeti moraš git in 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


Svetujem vam, da sodelujete pri NextDivelu, če imate čas in željo po ustvarjanju operacijskega sistema. Morda celo boljši od Linuxa ... čas bo pokazal.