Emulace Linuse Torvaldse: Vytvořte si svůj vlastní operační systém od nuly (I)

Nejprve poznamenejte, že toto je můj první článek a že doufám, že se vám všem líbí.

V této sérii budeme napodobovat Linus Torvalds, vytvoříme náš operační systém od 0. V této první epizodě uvidíme boot a vložíme text na obrazovku z našeho jádra.

V mém případě se volá operační systém DalšíDivel. První rozhodnutí, které musíme učinit, jakmile vezmeme v úvahu operační systém, je to, co bude bootloader?

Zde existuje několik variant a jednu bychom si dokonce mohli vytvořit sami; nicméně v tomto tutoriálu budu používat GRUB, protože většina o něm ví víceméně něco. Vytvoříme složku, která bude kořenem našeho operačního systému, a tam vytvoříme složku / boot / grub

mkdir nextroot && cd nextroot

mkdir -p boot/grub

Tam vytvoříme soubor grub.cfg následovně:

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


V tomto souboru jsme viděli jak GRUB načte naše jádro, v tomto případě do /next/START.ELF. Nyní musíme vytvořit naše jádro.

K tomu budeme potřebovat GCC y GAS (asembler projektu GNU, obvykle přichází s gcc). Takže vytvoříme jádro.

Nejprve vytvoříme soubor s názvem kernel.asm. Tento soubor bude obsahovat počáteční bod našeho jádra a bude také definovat multiboot (funkce některých bootloaderů, jako je GRUB). Obsah souboru kernel.asm bude:

.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

Vše, co souvisí s multibootem, je jednoduše sledovat specifikaci, nic víc. Všechno začne na začátku, zavolá multiboot_entry, v první 4k budeme mít definovanou hlavičku multiboot a dáme ji (s movl).

Později zavoláme NextKernel_Main, což je naše funkce jádra C. Ve smyčce zastavíme počítač. Toto se kompiluje s:

as -o kernel.o -c kernel.asm

Nyní se chystáme vstoupit do programování v C. Budete si myslet, že teď je všechno hračka, dali jsme a printf en hlavní a to je vše, dokázali jsme to.

No, protože printf y hlavní jsou to funkce, které jsou definovány operačním systémem, ale vytváříme je! Můžeme používat pouze funkce, které sami definujeme.

V dalších kapitolách budu hovořit o tom, jak dát svou vlastní knihovnu C (glibc, bionic, newlibc), ale čas od času. Mluvili jsme, že chceme umístit text na obrazovku, uvidíme, jak to uděláme.

Existují dvě možnosti, jedna je zavolat na BIOS a další je přímá správa paměti obrazovky. Uděláme to druhé, protože je to jasnější z C a také nám to umožní, když vstoupíme do chráněného režimu.

Vytvoříme soubor s názvem NextKernel_Main.c s následujícím obsahem:

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

Tím přímo manipulujeme s pamětí VGA a znak po znaku to píšeme. Zkompilovali jsme deaktivací stdlib:
gcc -o NextKernel_Main.o -c NextKernel_Main.c -nostdlib -fPIC -ffreestanding

Pokud jste se dostali až sem, budete chtít vyzkoušet svůj zbrusu nový operační systém hned, ale ještě jsme neskončili. Potřebujeme malý soubor, který řekne kompilátoru, kde v souboru opustí každou sekci. To se provádí pomocí linkerového skriptu. Vytvoříme 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 = .;
}


Tímto definujeme pozici každé sekce a vstupního bodu, start, který jsme definovali v kernel.asm. Nyní můžeme spojit všechny tyto výmysly:

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

Nyní zkopírujeme START.ELF do / další uvnitř naší složky, která simuluje kořen našeho operačního systému. Pomocí konzoly přejdeme do kořenové složky našeho nového operačního systému a ověříme, zda existují dva soubory: jeden /boot/grub/grub.cfg a další /next/START.ELF.

Přejdeme do horního adresáře a zavoláme nástroj pro vytváření ISO s názvem GRUB grub-mkrescue

grub-mkrescue -o nextdivel.iso nextroot

Jakmile to uděláme, budeme mít ISO. Tuto ISO lze otevřít na počítačích x86 (64 bitů příliš) a virtuální stroje. Abych to otestoval, použiji QEMU. Voláme QEMU z příkazového řádku:

qemu-system-i386 nextdivel.iso

Začne SeaBIOS a později budeme mít GRUB. Později, pokud je vše v pořádku, uvidíme naši frázi.
Budete si myslet, že je to obtížné, odpovídám, ano, je.

Skutečné vytvoření operačního systému je obtížné a že tento zde nedělá nic užitečného. V dalších kapitolách uvidíme, jak zacházet s barvami na obrazovce, rezervovat paměť a pokud mohu, jak získávat data z klávesnice.

Pokud sem někdo nechce všechno kopírovat, mám úložiště na GitHub (propracovanější) s operačním systémem DalšíDivel. Pokud chcete kompilovat DalšíDivel stačí mít git a 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


Doporučuji vám spolupracovat na NextDivel, pokud máte čas a chuť vytvořit operační systém. Možná dokonce lepší než Linux ... čas ukáže.