Émulation de Linus Torvalds: créez votre propre système d'exploitation à partir de zéro (I)

Tout d'abord, dites que c'est mon premier article et que j'espère que vous l'aimerez tous.

Dans cette série, nous allons émuler Linus Torvalds, nous allons créer notre système d'exploitation à partir de 0. Dans ce premier épisode nous allons voir le boot et nous mettrons un texte à l'écran depuis notre noyau.

Dans mon cas, le système d'exploitation s'appelle SuivantDivel. La première décision que nous devons prendre dès que nous considérons le système d'exploitation est de savoir quel sera le chargeur de démarrage?

Ici, il existe plusieurs variantes, et nous pourrions même en créer une nous-mêmes; cependant dans ce tutoriel je vais utiliser GRUB, parce que la plupart savent plus ou moins quelque chose sur lui. Nous créons un dossier qui sera la racine de notre système d'exploitation et là nous créons le dossier / boot / grub

mkdir nextroot && cd nextroot

mkdir -p boot/grub

Là, nous créons le fichier grub.cfg comme suit:

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


Dans ce fichier, nous avons vu comment GRUB chargera notre noyau, dans ce cas, dans /next/START.ELF. Maintenant, nous devons créer notre noyau.

Pour cela, nous aurons besoin du GCC y GAS (l'assembleur du projet GNU, est généralement fourni avec le gcc). Nous allons donc créer le noyau.

Nous créons d'abord un fichier appelé kernel.asm. Ce fichier contiendra le point de départ de notre noyau et définira également le multiboot (une fonctionnalité de certains bootloaders comme GRUB). Le contenu de kernel.asm sera:

.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

Tout ce qui concerne le multiboot est simplement de suivre la spécification rien d'autre. Tout commencera au début, il appellera multiboot_entry, nous aurons défini l'en-tête multiboot dans les 4 premiers kilomètres et nous le mettrons (avec movl).

Plus tard, nous appelons NextKernel_Main qui est notre fonction C du noyau. Dans la boucle, nous nous arrêtons pour arrêter l'ordinateur. Cela compile avec:

as -o kernel.o -c kernel.asm

Maintenant, nous allons entrer dans la programmation en C. Vous allez penser que maintenant tout est un morceau de gâteau, nous mettons un printf en principal et c'est tout, nous l'avons fait.

Eh bien non, depuis printf y principal ce sont des fonctions qui sont définies par le système d'exploitation, mais nous les créons! Nous ne pouvons utiliser que les fonctions que nous définissons nous-mêmes.

Dans les chapitres suivants, je parlerai de la façon de mettre notre propre bibliothèque C (glibc, bionic, newlibc) mais de temps en temps. Nous avons dit que nous voulons mettre du texte à l'écran, eh bien nous verrons comment nous le faisons.

Il existe deux options, l'une consiste à appeler le BIOS et une autre consiste à gérer directement la mémoire d'écran. Nous allons faire ce dernier car il est plus clair à partir de C et cela nous permettra également de le faire lorsque nous entrerons en mode protégé.

Nous créons un fichier appelé NextKernel_Main.c avec le contenu suivant:

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

Avec cela, nous manipulons directement la mémoire VGA et caractère par caractère, nous l'écrivons. Nous compilons en désactivant le stdlib:
gcc -o NextKernel_Main.o -c NextKernel_Main.c -nostdlib -fPIC -ffreestanding

Si vous êtes arrivé jusqu'ici, vous voudrez essayer votre tout nouveau système d'exploitation maintenant, mais nous n'avons pas encore terminé. Nous avons besoin d'un petit fichier qui indique au compilateur où dans le fichier quitter chaque section. Cela se fait avec un script de l'éditeur de liens. Nous créons 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 = .;
}


Avec cela, nous définissons la position de chaque section et le point d'entrée, start, que nous avons défini dans kernel.asm. Maintenant, nous pouvons unir toute cette concoction:

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

Maintenant, nous copions START.ELF dans / next dans notre dossier qui simule la racine de notre système d'exploitation. Nous allons dans le dossier racine de notre nouveau système d'exploitation avec la console et vérifions qu'il y a deux fichiers: un /boot/grub/grub.cfg et un autre /next/START.ELF.

Nous allons dans le répertoire supérieur et appelons un utilitaire de création ISO avec GRUB appelé grub-mkrescue

grub-mkrescue -o nextdivel.iso nextroot

Une fois que nous aurons fait cela, nous aurons un ISO. Cet ISO peut être ouvert sur des ordinateurs x86 (64 bits aussi) et des machines virtuelles. Pour le tester, je vais utiliser QEMU. Nous appelons QEMU depuis la ligne de commande:

qemu-system-i386 nextdivel.iso

Va commencer BIOS de la mer et plus tard nous aurons GRUB. Plus tard, si tout est correct, nous verrons notre phrase.
Vous penserez que c'est difficile, je réponds que oui.

Créer vraiment un système d'exploitation est difficile et que celui-ci ici ne fait rien d'utile. Dans les prochains chapitres, nous verrons comment gérer les couleurs à l'écran, réserver de la mémoire et si je peux, comment obtenir des données à partir du clavier.

Si quelqu'un ne veut pas tout copier ici, j'ai un référentiel à GitHub (plus élaboré) avec le système d'exploitation SuivantDivel. Si vous souhaitez compiler SuivantDivel il vous suffit d'avoir git et 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


Je vous encourage à collaborer sur NextDivel si vous avez le temps et le désir de créer un système d'exploitation. Peut-être même supérieur à Linux ... le temps le dira.