Linus Torvalds utánzása: Készítse el saját operációs rendszerét a semmiből (I)

Először is kommentáld, hogy ez az első cikkem, és remélem, hogy mindannyian kedvelni fogjátok.

Ebben a sorozatban fogunk utánozni Linus Torvalds, 0-tól fogjuk létrehozni az operációs rendszerünket. Ebben az első epizódban megnézzük a rendszerindítást, és egy szöveget teszünk fel a képernyőre a kernelünkből.

Nálam az operációs rendszert hívják NextDivel. Az első döntés, amelyet meg kell hoznunk, amint megfontoljuk az operációs rendszert, mi lesz a bootloader?

Itt többféle változat létezik, és akár magunk is létrehozhatnánk egyet; azonban ebben az oktatóanyagban használni fogom GRUB, mert a többség többé-kevésbé tud róla valamit. Létrehozunk egy mappát, amely az operációs rendszerünk gyökere lesz, és ott létrehozzuk a / boot / grub mappát

mkdir nextroot && cd nextroot

mkdir -p boot/grub

Itt hozzuk létre a grub.cfg fájlt az alábbiak szerint:

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


Ebben a fájlban láttuk, hogyan GRUB a kernelünket ebben az esetben a /next/START.ELF fájlba tölti be. Most létre kell hoznunk a kernelünket.

Ehhez szükségünk lesz a GCC y GAS (a projekt összeállítója GNÚ, általában a gcc-vel jár). Tehát létrehozni fogjuk a kernelt.

Először készítünk egy kernel.asm nevű fájlt. Ez a fájl tartalmazza a kernelünk kiindulási pontját, és meghatározza a multibootot is (néhány bootloader egyik jellemzője, például GRUB). A kernel.asm tartalma a következő lesz:

.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

Minden, ami a multiboot-hoz kapcsolódik, egyszerűen csak a specifikáció követése. Minden elölről indul, multiboot_entry-t fog hívni, az első 4k-ban definiáltuk a multiboot fejlécet és feltesszük (movl-lel).

Később a NextKernel_Main nevet kapjuk, amely a kernel C függvényünk. A hurokban leállítjuk a számítógép leállítását. Ez összeállítja:

as -o kernel.o -c kernel.asm

Most belépünk a programozásba C-ben. Azt fogja gondolni, hogy most minden egy darab sütemény, beleteszünk egy printf en fő- és ennyi, megtettük.

Hát nem, azóta printf y fő- ezek olyan funkciók, amelyeket az operációs rendszer határoz meg, de mi létrehozzuk őket! Csak azokat a függvényeket használhatjuk, amelyeket magunk határozunk meg.

A későbbi fejezetekben arról fogok beszélni, hogyan lehet saját C könyvtárunkat (glibc, bionikus, newlibc) elhelyezni, de időről időre. Megbeszéltük, hogy szöveget akarunk felvenni a képernyőre, és meglátjuk, hogyan csináljuk.

Két lehetőség van, az egyik a BIOS a másik pedig a képernyő memóriájának közvetlen kezelése. Ez utóbbit fogjuk megtenni, mert ez egyértelműbb a C-től, és ez lehetővé teszi számunkra is, hogy amikor védett módba lépünk.

Létrehozunk egy NextKernel_Main.c nevű fájlt a következő tartalommal:

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

Ezzel közvetlenül manipuláljuk a memóriát VGA és karakterenként írjuk. Az stdlib letiltásával állítjuk össze:
gcc -o NextKernel_Main.o -c NextKernel_Main.c -nostdlib -fPIC -ffreestanding

Ha eddig elérted, akkor most kipróbálhatod a vadonatúj operációs rendszeredet, de még nem készült el. Szükségünk van egy kis fájlra, amely megmondja a fordítónak, hogy a fájl hol hagyja el az egyes szakaszokat. Ez egy linker szkript segítségével történik. Létrehozunk 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 = .;
}


Ezzel meghatározzuk az egyes szakaszok helyzetét és a belépési pontot (start), amelyet a kernel.asm fájlban definiáltunk. Most egyesíthetjük ezt a főzetet:

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

Most átmásoljuk a START.ELF fájlt a következő könyvtárba, amely az operációs rendszer gyökerét szimulálja. A konzollal megyünk új operációs rendszerünk gyökérmappájába, és ellenőrizzük, hogy van-e két fájl: egy /boot/grub/grub.cfg és egy másik /next/START.ELF.

Menjünk a felső könyvtárba, és meghívunk egy ISO létrehozó segédprogramot, amelynek GRUB-ja van grub-mkrescue

grub-mkrescue -o nextdivel.iso nextroot

Ha ezt megtettük, akkor a ISO. Ez az ISO számítógépeken megnyitható x86 (64 bit is) és virtuális gépek. A teszteléshez használni fogom QEMU. Hívjuk QEMU a parancssorból:

qemu-system-i386 nextdivel.iso

Kezdődni fog SeaBIOS és később meglesz GRUB. Később, ha minden helyes, látni fogjuk a kifejezésünket.
Azt gondolja, hogy ez nehéz, válaszolok, igen.

Az operációs rendszer valóban nehéz létrehozni, és ez itt nem tesz semmi hasznosat. A következő fejezetekben megtudhatjuk, hogyan kell kezelni a színeket a képernyőn, lefoglalni a memóriát, és ha tudok, hogyan lehet adatokat szerezni a billentyűzetről.

Ha valaki nem akar mindent ide másolni, van egy tárhelyem a címen GitHub (részletesebben) az operációs rendszerrel NextDivel. Ha össze akarsz állítani NextDivel csak git és cmake kell:

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


Arra bátorítalak, hogy működjön együtt a NextDivel, ha van ideje és vágya operációs rendszer létrehozására. Talán még felülmúlja a Linuxot ... az idő megmondja.