Emulant Linus Torvalds: Crea el teu propi sistema operatiu des de 0 (I)

Abans de res comentar que aquest és el meu primer article i que desitjo que us agradi a tots.

En aquesta sèrie anem a emular Linus Torvalds, Crearem el nostre sistema operatiu des de 0. En aquest primer episodi veurem l'arrencada i posarem un text en pantalla des del nostre nucli.

En el meu cas el sistema operatiu es diu NextDivel. La primera decisió que hem de fer res més plantejar-nos el sistema operatiu és quin serà el bootloader?

Aquí hi ha múltiples variants, i fins i tot podríem crear-ne un nosaltres; però, en aquest tutorial vaig a utilitzar GRUB, Perquè la majoria coneix més o menys alguna cosa d'ell. Creem una carpeta que serà el root del nostre sistema operatiu i allà vam crear la carpeta / boot / grub

mkdir nextroot && cd nextroot

mkdir -p boot/grub

Allà vam crear el fitxer grub.cfg de la següent manera:

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


En aquest fitxer hem vist com GRUB carregarà el nostre nucli, en aquest cas, en /next/START.ELF. Ara hem de crear el nostre nucli.

Per a això necessitarem el GCC y GAS (L'assemblador de el projecte GNU, Sol venir amb el gcc). Així doncs anem a crear el nucli.

Primer fem un arxiu anomenat kernel.asm. Aquest fitxer contindrà el punt d'inici del nostre nucli ia més definirà el multiboot (una característica d'alguns bootloaders com GRUB). El contingut d'kernel.asm serà:

.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

Tot el relacionant amb multiboot és simplement seguir l'especificació res més. Tot començarà a start, cridarà a multiboot_entry, haurem definit el multiboot header en els primers 4k i el posarem (amb movl).

Més tard fem una crida a NextKernel_Main que és la nostra funció en C de l'nucli. En el loop fem una halt per aturar l'ordinador. Això es compila amb:

as -o kernel.o -c kernel.asm

Ara entrarem a programar en C. Pensaràs que ara tot és bufar i fer ampolles, posem una imprimirf en principal i ja està, ho hem fet.

Doncs no, ja que imprimirf y principal són funcions que defineix el sistema operatiu, però nosaltres ho estem creant! Només podrem fer servir les funcions que nosaltres mateixos definim.

En capítols posteriors parlaré de com posar la nostra pròpia lliuraria de l'C (glibc, bionic, newlibc) però temps a el temps. Hem parlat que volem posar text en pantalla, bé veurem com ho fem.

Hi ha dues opcions, una és trucar a la BIOS i una altra és gestionar la memòria de la pantalla directament. Anem a fer això últim ja que és més clar des de C ia més ens permetrà fer-ho quan entrem en mode protegit.

Creem un fitxer anomenat NextKernel_Main.c amb el següent contingut:

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

Amb això manipulem directament la memòria VGA i caràcter a caràcter ho anem escrivint. Compilem desactivant la stdlib:
gcc -o NextKernel_Main.o -c NextKernel_Main.c -nostdlib -fPIC -ffreestanding

Si has arribat fins aquí voldràs provar ja el teu nou i flamant sistema operatiu, però encara no hem acabat. Necessitem un petit fitxer que digui a l'compilador en quina posició de l'arxiu deixar cada secció. Això es fa amb un linker script. Creem 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 = .;
}


Amb això definim la posició de cada secció i el punt d'entrada, start, que hem definit en kernel.asm. Ara ja podem unir tot aquest potinga:

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

Ara copiem START.ELF al / next dins la nostra carpeta que simula el root del nostre sistema operatiu. Ens dirigim a la carpeta root del nostre sistema operatiu nou amb la consola i verifiquem que hi ha dos arxius: un grub.cfg i un altre /next/START.ELF.

Anem a directori superior i cridem a una utilitat de creació ISOs amb GRUB anomenada grub-mkrescue

grub-mkrescue -o nextdivel.iso nextroot

Un cop haguem fet això tindrem una ISO. Aquesta ISO pot obrir-se en ordinadors x86 (64 bits també) i màquines virtuals. Per provar-ho, vaig a utilitzar QEMU. Fem una crida a QEMU des de la línia de comandes:

qemu-system-i386 nextdivel.iso

arrencarà SeaBIOS i més tard tindrem GRUB. Després si tot va correcte veurem la nostra frase.
Pensaràs que això és difícil, et responc, sí que ho és.

Realment crear un sistema operatiu és difícil i això que aquest d'aquí no fa res útil. En propers capítols veurem com gestionar colors a la pantalla, reservar memòria i si puc, com obtenir dades de el teclat.

Si algú no vol copiar tot el que hi ha aquí, tinc un repositori en GitHub (Més elaborat) amb el sistema operatiu NextDivel. Si vols compilar NextDivel només has de tenir git i 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


Us animo a col·laborar en NextDivel si tens temps i ganes de crear un sistema operatiu. Potser fins i tot superior a Linux ... el temps ho dirà.