Linus Torvalds emuleren: maak uw eigen besturingssysteem helemaal opnieuw (I)

Merk allereerst op dat dit mijn eerste artikel is en dat ik hoop dat jullie het allemaal leuk vinden.

In deze serie gaan we emuleren Linus Torvalds, we gaan ons besturingssysteem aanmaken vanaf 0. In deze eerste aflevering gaan we de boot bekijken en zullen we een tekst uit onze kernel op het scherm zetten.

In mijn geval heet het besturingssysteem Volgende Duik. De eerste beslissing die we moeten nemen zodra we het besturingssysteem overwegen, is: wat wordt de bootloader?

Hier zijn er meerdere varianten, en we zouden er zelfs zelf een kunnen maken; maar in deze tutorial ga ik gebruiken GRUB, omdat de meesten min of meer iets over hem weten. We maken een map die de root van ons besturingssysteem zal zijn en daar maken we de map / boot / grub aan

mkdir nextroot && cd nextroot

mkdir -p boot/grub

Daar maken we het bestand grub.cfg als volgt aan:

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


In dit bestand hebben we gezien hoe GRUB laadt onze kernel, in dit geval, in /next/START.ELF. Nu moeten we onze kernel maken.

Hiervoor hebben we de GCC y GAS (de samensteller van het project GNU, wordt meestal geleverd met de gcc). Dus we gaan de kernel maken.

Eerst maken we een bestand met de naam kernel.asm. Dit bestand bevat het startpunt van onze kernel en definieert ook de multiboot (een kenmerk van sommige bootloaders zoals GRUB). De inhoud van kernel.asm zal zijn:

.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

Alles met betrekking tot multiboot is simpelweg om de specificatie te volgen, niets meer. Alles zal starten in het begin, het zal multiboot_entry aanroepen, we hebben de multiboot-header in de eerste 4k gedefinieerd en we zullen het plaatsen (met movl).

Later noemen we NextKernel_Main, wat onze kernel C-functie is. In de loop stoppen we om de computer te stoppen. Dit compileert met:

as -o kernel.o -c kernel.asm

Nu gaan we programmeren invoeren in C. Je zult denken dat nu alles een fluitje van een cent is, we zetten een printf en hoofd- en dat is het, we hebben het gedaan.

Nou nee, sinds printf y hoofd- het zijn functies die worden gedefinieerd door het besturingssysteem, maar wij maken ze! We kunnen alleen de functies gebruiken die we zelf definiëren.

In latere hoofdstukken zal ik het hebben over hoe we onze eigen C-bibliotheek (glibc, bionic, newlibc) kunnen plaatsen, maar van tijd tot tijd. We hebben besproken dat we tekst op het scherm willen zetten, nou we zullen zien hoe we dat doen.

Er zijn twee opties, een is om het BIOS en een andere is om het schermgeheugen direct te beheren. We gaan het laatste doen omdat het duidelijker is vanaf C en het ons ook in staat stelt om het te doen wanneer we de beschermde modus openen.

We maken een bestand met de naam NextKernel_Main.c met de volgende inhoud:

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

Hiermee manipuleren we direct het geheugen VGA en karakter voor karakter schrijven we het. We compileren door de stdlib uit te schakelen:
gcc -o NextKernel_Main.o -c NextKernel_Main.c -nostdlib -fPIC -ffreestanding

Als je zover bent gekomen, wil je je gloednieuwe besturingssysteem nu proberen, maar we zijn nog niet klaar. We hebben een klein bestand nodig dat de compiler vertelt waar in het bestand elke sectie moet worden verlaten. Dit wordt gedaan met een linker script. We creëren 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 = .;
}


Hiermee definiëren we de positie van elke sectie en het startpunt, start, dat we hebben gedefinieerd in kernel.asm. Nu kunnen we al dit brouwsel verenigen:

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

Nu kopiëren we START.ELF naar / next in onze map die de root van ons besturingssysteem simuleert. We gaan met de console naar de hoofdmap van ons nieuwe besturingssysteem en controleren of er twee bestanden zijn: een /boot/grub/grub.cfg en een andere /next/START.ELF.

We gaan naar de bovenste map en bellen een ISO-aanmaakprogramma met de naam GRUB grub-mkrescue

grub-mkrescue -o nextdivel.iso nextroot

Zodra we dit hebben gedaan, hebben we een ISO. Deze ISO kan op computers worden geopend x86 (64 bits ook) en virtuele machines. Om het te testen, ga ik gebruiken QEMU. Wij bellen QEMU vanaf de opdrachtregel:

qemu-system-i386 nextdivel.iso

Zal beginnen ZeeBIOS en later zullen we hebben GRUB. Als later alles klopt, zullen we onze zin zien.
Je zult denken dat dit moeilijk is, ik antwoord je, ja dat is het.

Echt een besturingssysteem maken is moeilijk en dat dit hier niets nuttigs doet. In toekomstige hoofdstukken zullen we zien hoe om te gaan met kleuren op het scherm, geheugen te reserveren en, indien mogelijk, gegevens van het toetsenbord te krijgen.

Als iemand hier niet alles wil kopiëren, heb ik een repository op GitHub (uitgebreider) met het besturingssysteem Volgende Duik. Als je wilt compileren Volgende Duik je hoeft alleen git en cmake te hebben:

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


Ik moedig je aan om samen te werken aan NextDivel als je de tijd en de wens hebt om een ​​besturingssysteem te maken. Misschien zelfs superieur aan Linux ... de tijd zal het leren.