Linus Torvalds emulieren: Erstellen Sie Ihr eigenes Betriebssystem von Grund auf neu (I)

Kommentieren Sie zunächst, dass dies mein erster Artikel ist und dass ich hoffe, dass es Ihnen allen gefällt.

In dieser Serie werden wir emulieren Linus TorvaldsIn dieser ersten Folge sehen wir den Start und werden einen Text aus unserem Kernel auf den Bildschirm bringen.

In meinem Fall wird das Betriebssystem aufgerufen NächsterDive. Die erste Entscheidung, die wir treffen müssen, sobald wir das Betriebssystem in Betracht ziehen, ist, wie der Bootloader aussehen wird.

Hier gibt es mehrere Varianten, und wir könnten sogar selbst eine erstellen; In diesem Tutorial werde ich jedoch verwenden GRUB, weil die meisten mehr oder weniger etwas über ihn wissen. Wir erstellen einen Ordner, der das Stammverzeichnis unseres Betriebssystems darstellt, und erstellen dort den Ordner / boot / grub

mkdir nextroot && cd nextroot

mkdir -p boot/grub

Dort erstellen wir die Datei grub.cfg wie folgt:

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


In dieser Datei haben wir gesehen, wie GRUB lädt unseren Kernel in diesem Fall in /next/START.ELF. Jetzt müssen wir unseren Kernel erstellen.

Dafür brauchen wir die GCC y GAS (der Assembler des Projekts GNU, kommt normalerweise mit dem gcc). Also werden wir den Kernel erstellen.

Zuerst erstellen wir eine Datei namens kernel.asm. Diese Datei enthält den Startpunkt unseres Kernels und definiert auch den Multiboot (eine Funktion einiger Bootloader wie z GRUB). Der Inhalt von kernel.asm lautet:

.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, was mit Multiboot zu tun hat, ist einfach, der Spezifikation zu folgen, sonst nichts. Alles wird beim Start beginnen, es wird multiboot_entry aufrufen, wir werden den Multiboot-Header in den ersten 4k definiert haben und wir werden ihn setzen (mit movl).

Später rufen wir NextKernel_Main auf, unsere Kernel-C-Funktion. In der Schleife halten wir an, um den Computer anzuhalten. Dies kompiliert mit:

as -o kernel.o -c kernel.asm

Jetzt werden wir in C in die Programmierung einsteigen. Sie werden denken, dass jetzt alles ein Kinderspiel ist printf en Haupt- und das wars, wir haben es geschafft.

Nun nein, seitdem printf y Haupt- Es sind Funktionen, die vom Betriebssystem definiert werden, aber wir erstellen sie! Wir können nur die Funktionen verwenden, die wir selbst definieren.

In späteren Kapiteln werde ich von Zeit zu Zeit darüber sprechen, wie wir unsere eigene C-Bibliothek (glibc, bionic, newlibc) einrichten können. Wir haben besprochen, dass wir Text auf den Bildschirm bringen wollen. Nun, wir werden sehen, wie wir das machen.

Es gibt zwei Möglichkeiten, eine ist das Aufrufen der BIOS und eine andere besteht darin, den Bildschirmspeicher direkt zu verwalten. Letzteres werden wir tun, weil es aus C klarer ist und es uns auch ermöglicht, dies zu tun, wenn wir in den geschützten Modus wechseln.

Wir erstellen eine Datei namens NextKernel_Main.c mit folgendem Inhalt:

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

Damit manipulieren wir direkt die Erinnerung VGA und Zeichen für Zeichen schreiben wir es. Wir kompilieren durch Deaktivieren der stdlib:
gcc -o NextKernel_Main.o -c NextKernel_Main.c -nostdlib -fPIC -ffreestanding

Wenn Sie es bis hierher geschafft haben, möchten Sie jetzt Ihr brandneues Betriebssystem ausprobieren, aber wir sind noch nicht fertig. Wir benötigen eine kleine Datei, die dem Compiler mitteilt, wo in der Datei jeder Abschnitt verlassen werden soll. Dies erfolgt mit einem Linker-Skript. Wir erstellen 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 = .;
}


Damit definieren wir die Position jedes Abschnitts und den Einstiegspunkt start, den wir in kernel.asm definiert haben. Jetzt können wir all diese Zusammenstellungen vereinen:

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

Jetzt kopieren wir START.ELF nach / next in unseren Ordner, der das Stammverzeichnis unseres Betriebssystems simuliert. Wir gehen mit der Konsole in den Stammordner unseres neuen Betriebssystems und überprüfen, ob zwei Dateien vorhanden sind: eine /boot/grub/grub.cfg und eine andere /next/START.ELF.

Wir gehen in das obere Verzeichnis und rufen ein Dienstprogramm zur ISO-Erstellung mit GRUB auf grub-mkrescue

grub-mkrescue -o nextdivel.iso nextroot

Sobald wir dies getan haben, werden wir eine haben ISO. Diese ISO kann auf Computern geöffnet werden x86 (64 Bit auch) und virtuelle Maschinen. Um es zu testen, werde ich verwenden QEMU. Wir nennen QEMU von der Kommandozeile:

qemu-system-i386 nextdivel.iso

Wird beginnen Meeres-BIOS und später werden wir haben GRUB. Wenn später alles in Ordnung ist, werden wir unseren Satz sehen.
Sie werden denken, dass dies schwierig ist, antworte ich, ja, das ist es.

Es ist schwierig, wirklich ein Betriebssystem zu erstellen, und dieses hier macht nichts Nützliches. In zukünftigen Kapiteln werden wir sehen, wie man mit Farben auf dem Bildschirm umgeht, Speicher reserviert und wenn ich kann, wie man Daten von der Tastatur erhält.

Wenn jemand hier nicht alles kopieren möchte, habe ich ein Repository unter GitHub (ausführlicher) mit dem Betriebssystem NächsterDive. Wenn Sie kompilieren möchten NächsterDive du musst nur git und cmake haben:

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


Ich empfehle Ihnen, bei NextDivel zusammenzuarbeiten, wenn Sie Zeit und Wunsch haben, ein Betriebssystem zu erstellen. Vielleicht sogar besser als Linux ... die Zeit wird es zeigen.