Linus Torvaldsi matkimine: looge oma operatsioonisüsteem nullist (I)

Kõigepealt kommenteerige, et see on minu esimene artikkel ja et ma loodan, et see teile kõigile meeldib.

Selles sarjas me jäljendame Linus Torvalds, loome oma operatsioonisüsteemi alates 0. Selles esimeses osas näeme alglaadimist ja paneme oma kernelilt ekraanile teksti.

Minu puhul nimetatakse operatsioonisüsteemi JärgmineDivel. Esimene otsus, mille peame tegema kohe pärast operatsioonisüsteemi kaalumist, on see, mis saab olema alglaadur?

Siin on mitu varianti ja me võiksime selle isegi ise luua; aga selles õpetuses kavatsen ma seda kasutada GRUB, sest enamik teab temast enam-vähem midagi. Loome kausta, mis saab olema meie operatsioonisüsteemi juur, ja seal loome kausta / boot / grub

mkdir nextroot && cd nextroot

mkdir -p boot/grub

Seal loome grub.cfg faili järgmiselt:

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


Selles failis oleme näinud kuidas GRUB laadib sel juhul meie tuuma kataloogi /next/START.ELF. Nüüd peame looma oma tuuma.

Selleks vajame GCC y GAS (projekti koostaja GNU, tavaliselt kaasas gcc). Nii et me loome kerneli.

Kõigepealt valmistame faili kernel.asm. See fail sisaldab meie kerneli alguspunkti ja määratleb ka mitme alglaadimise (mõne alglaaduri funktsioon nagu GRUB). Kernel.asmi sisu on:

.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

Kõik, mis on seotud mitme käivitusega, on lihtsalt spetsifikatsiooni järgimine. Kõik algab alguses, see kutsub multiboot_entry, oleme määranud mitme alglaadimise päise esimeses 4k-s ja paneme selle (movliga).

Hiljem kutsume NextKernel_Main, mis on meie tuuma C funktsioon. Silmus peatume arvuti peatamiseks. See koostab koos:

as -o kernel.o -c kernel.asm

Nüüd hakkame sisestama programmeerimise C.-sse. Te arvate, et nüüd on kõik koogitükk, panime a printf en põhiline ja see on kõik, me oleme seda teinud.

No ei, kuna printf y põhiline need on funktsioonid, mille operatsioonisüsteem määratleb, kuid me loome neid! Saame kasutada ainult neid funktsioone, mille ise määratleme.

Hilisemates peatükkides räägin sellest, kuidas panna oma C-teek (glibc, bionic, newlibc), kuid aeg-ajalt. Oleme arutanud, et tahame teksti ekraanile panna, eks me näe, kuidas me seda teeme.

On kaks võimalust, üks on helistada BIOS ja teine ​​on otse ekraanimälu haldamine. Teeme viimast, sest see on C-st selgem ja see võimaldab meil seda teha ka siis, kui siseneme kaitstud režiimi.

Loome järgmise sisuga faili nimega NextKernel_Main.c:

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

Sellega manipuleerime otse mäluga VGA ja tähemärgi kaupa me seda kirjutame. Koostame stdlibi keelamise abil:
gcc -o NextKernel_Main.o -c NextKernel_Main.c -nostdlib -fPIC -ffreestanding

Kui olete nii kaugele jõudnud, tahate proovida oma uhiuut operatsioonisüsteemi kohe, kuid me pole veel lõpetanud. Vajame väikest faili, mis ütleb kompilaatorile, kus failis igast osast lahkuda. Seda tehakse linkeri skriptiga. Loome 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 = .;
}


Sellega määratleme iga sektsiooni asukoha ja alguspunkti, mille oleme määratlenud failis kernel.asm. Nüüd saame ühendada kogu selle segu:

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

Nüüd kopeerime START.ELF oma kausta, mis simuleerib meie operatsioonisüsteemi juuri. Läheme konsooliga oma uue operatsioonisüsteemi juurkausta ja kontrollime, kas faile on kaks: üks /boot/grub/grub.cfg ja teine ​​/next/START.ELF.

Me läheme ülemisse kataloogi ja kutsume ISO loomise utiliidi, mille nimi on GRUB grub-mkrescue

grub-mkrescue -o nextdivel.iso nextroot

Kui oleme selle teinud, on meil ISO. Seda ISO-d saab avada arvutites x86 (64 bitti ka) ja virtuaalmasinad. Selle testimiseks hakkan kasutama QEMU. Me helistame QEMU käsurealt:

qemu-system-i386 nextdivel.iso

Algab SeaBIOS ja hiljem saame GRUB. Hiljem, kui kõik on õige, näeme meie fraasi.
Te arvate, et see on keeruline, ma vastan, jah.

Operatsioonisüsteemi loomine on keeruline ja see siin ei tee midagi kasulikku. Järgmistes peatükkides näeme, kuidas ekraanil värve käsitseda, mälu reserveerida ja kui saan, siis kuidas klaviatuurilt andmeid hankida.

Kui keegi ei taha kõike siia kopeerida, on mul aadressil hoidla GitHub (täpsemalt) koos operatsioonisüsteemiga JärgmineDivel. Kui soovite koostada JärgmineDivel teil peab lihtsalt olema git ja 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


Kui teil on aega ja soovi operatsioonisüsteemi loomiseks, soovitan teil teha koostööd NextDiveliga. Ehk isegi Linuxist parem ... näitab aeg.