Lino Torvaldso mėgdžiojimas: sukurkite savo operacinę sistemą nuo nulio (I)

Visų pirma pakomentuokite, kad tai yra mano pirmasis straipsnis ir tikiuosi, kad jums visiems tai patiks.

Šioje serijoje mes imituosime Linus Torvalds, mes sukursime savo operacinę sistemą nuo 0. Šiame pirmame epizode pamatysime įkrovą ir ekrane iš savo branduolio įdėsime tekstą.

Mano atveju vadinama operacine sistema „NextDivel“. Pirmasis sprendimas, kurį turime priimti, kai tik apsvarstysime operacinę sistemą, yra koks bus įkrovos tvarkyklė?

Čia yra keli variantai, ir mes netgi patys galėtume jį sukurti; tačiau šioje pamokoje ketinu naudoti GRUB, nes dauguma apie jį daugiau ar mažiau ką nors žino. Sukuriame aplanką, kuris bus mūsų operacinės sistemos šaknis, ir ten sukursime aplanką / boot / grub

mkdir nextroot && cd nextroot

mkdir -p boot/grub

Čia mes sukuriame failą grub.cfg taip:

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


Šiame faile matėme kaip GRUB šiuo atveju įkels mūsų branduolį į /next/START.ELF. Dabar turime sukurti savo branduolį.

Tam mums reikės GCC y DUJŲ (projekto surinkėjas GNU, paprastai pateikiama kartu su gcc). Taigi mes sukursime branduolį.

Pirmiausia padarome failą, pavadintą kernel.asm. Šiame faile bus mūsų branduolio pradinis taškas, taip pat bus apibrėžtas daugkartinis įkrovimas (kai kurių įkrovos elementų, tokių kaip GRUB). Kernel.asm turinys bus:

.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

Viskas, kas susiję su „multiboot“, yra tik tai, kad laikytumėtės nieko kito. Viskas prasidės iš pradžių, jis iškvies multiboot_entry, mes nustatysime multiboot antraštę per pirmuosius 4k ir įdėsime (su movl).

Vėliau mes vadiname „NextKernel_Main“, kuri yra mūsų branduolio C funkcija. Kilpoje mes sustabdome kompiuterį. Tai sudaro:

as -o kernel.o -c kernel.asm

Dabar eisime į programavimą C. Jūs manysite, kad dabar viskas yra pyrago gabalas, mes įdėjome a printf en pagrindinis ir viskas, mes tai padarėme.

Na ne, nuo tada printf y pagrindinis tai yra operacinės sistemos apibrėžtos funkcijos, bet mes jas kuriame! Mes galime naudoti tik tas funkcijas, kurias mes patys apibrėžiame.

Vėlesniuose skyriuose kalbėsiu apie tai, kaip sukurti savo C biblioteką (glibc, bionic, newlibc), bet laikas nuo laiko. Aptarėme, kad norime įdėti tekstą į ekraną, gerai pamatysime, kaip tai darysime.

Yra dvi galimybės, viena yra paskambinti BIOS o kitas yra tiesiogiai valdyti ekrano atmintį. Mes ketiname padaryti pastarąjį, nes tai aiškiau iš C ir tai taip pat leis mums tai padaryti, kai įeisime į apsaugotą režimą.

Sukuriame failą pavadinimu NextKernel_Main.c su tokiu turiniu:

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

Tuo mes tiesiogiai manipuliuojame atmintimi VGA ir po simbolį mes jį rašome. Mes sudarome išjungdami „stdlib“:
gcc -o NextKernel_Main.o -c NextKernel_Main.c -nostdlib -fPIC -ffreestanding

Jei tai padarėte iki šiol, norėsite išbandyti savo naują operacinę sistemą dabar, bet mes dar ne viskas. Mums reikia nedidelio failo, kuris kompiliatoriui nurodo, kur faile palikti kiekvieną skyrių. Tai daroma naudojant susiejimo scenarijų. Mes kuriame 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 = .;
}


Tuo mes apibrėžiame kiekvieno skyriaus poziciją ir pradžios tašką, kurį apibrėžėme kernel.asm. Dabar mes galime sujungti visą šią sumanymą:

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

Dabar kopijuojame START.ELF į / kitą aplanke, kuris imituoja mūsų operacinės sistemos šaknį. Su konsole einame į naujos operacinės sistemos šakninį aplanką ir patikriname, ar yra du failai: vienas /boot/grub/grub.cfg ir kitas /next/START.ELF.

Einame į viršutinį katalogą ir iškviečiame ISO sukūrimo įrankį, kai iškviečiamas GRUB grub-mkrescue

grub-mkrescue -o nextdivel.iso nextroot

Tai padarę turėsime ISO. Šį ISO galima atidaryti kompiuteriuose x86 (64 bitai taip pat) ir virtualios mašinos. Norėdami tai išbandyti, aš ketinu naudoti QEMU. Mes skambiname QEMU iš komandinės eilutės:

qemu-system-i386 nextdivel.iso

Pradės „SeaBIOS“ o vėliau turėsime GRUB. Vėliau, jei viskas bus teisinga, pamatysime savo frazę.
Jūs manysite, kad tai sunku, aš jums atsakau, taip yra.

Tikrai sukurti operacinę sistemą yra sunku ir kad ši čia nepadaro nieko naudingo. Ateityje skyriuose pamatysime, kaip elgtis su spalvomis ekrane, rezervuoti atmintį ir, jei galiu, kaip gauti duomenis iš klaviatūros.

Jei kas nors nenori čia kopijuoti visko, turiu saugyklą GitHub (išsamiau) su operacine sistema „NextDivel“. Jei norite sudaryti „NextDivel“ jūs tiesiog turite turėti git ir 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


Jei turite laiko ir noro sukurti operacinę sistemą, raginu bendradarbiauti „NextDivel“. Galbūt net pranašesnis už „Linux“ ... laikas parodys.