Emulera Linus Torvalds: Skapa ditt eget operativsystem från grunden (I)

Först och främst, kommentera att det här är min första artikel och att jag hoppas att ni alla gillar det.

I den här serien kommer vi att efterlikna Linus Torvalds, vi kommer att skapa vårt operativsystem från 0. I det här första avsnittet ska vi se boot och lägga en text på skärmen från vår kärna.

I mitt fall kallas operativsystemet NextDivel. Det första beslutet som vi måste fatta så snart vi överväger operativsystemet är vad kommer startladdaren att vara?

Här finns det flera varianter, och vi kan till och med skapa en själva; men i denna handledning ska jag använda GRUB, för de flesta vet mer eller mindre något om honom. Vi skapar en mapp som kommer att vara roten till vårt operativsystem och där skapar vi mappen / boot / grub

mkdir nextroot && cd nextroot

mkdir -p boot/grub

Där skapar vi grub.cfg-filen enligt följande:

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


I den här filen har vi sett hur GRUB kommer att ladda vår kärna, i det här fallet, i /next/START.ELF. Nu måste vi skapa vår kärna.

För detta behöver vi GCC y GAS (projektets samlare GNU, kommer vanligtvis med gcc). Så vi ska skapa kärnan.

Först skapar vi en fil som heter kernel.asm. Den här filen kommer att innehålla startpunkten för vår kärna och kommer också att definiera multiboot (en funktion för vissa bootloaders som GRUB). Innehållet i kernel.asm kommer att vara:

.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

Allt relaterat till multiboot är helt enkelt att följa specifikationen ingenting annat. Allt börjar i början, det kommer att kalla multiboot_entry, vi kommer att ha definierat multiboot-rubriken i de första 4k och vi kommer att lägga det (med movl).

Senare kallar vi NextKernel_Main som är vår kärna C-funktion. I slingan stoppar vi datorn. Detta sammanställs med:

as -o kernel.o -c kernel.asm

Nu ska vi gå in i programmering i C. Du kommer att tro att nu är allt en bit kaka, vi lägger en printf en huvudsakliga och det är det, vi har gjort det.

Jo nej, sedan printf y huvudsakliga de är funktioner som definieras av operativsystemet, men vi skapar dem! Vi kan bara använda de funktioner som vi själva definierar.

I senare kapitel kommer jag att prata om hur man lägger vårt eget C-bibliotek (glibc, bionic, newlibc) men då och då. Vi har pratat om att vi vill lägga text på skärmen, vi får se hur vi gör det.

Det finns två alternativ, ett är att ringa till BIOS och en annan är att hantera skärmminne direkt. Vi kommer att göra det senare eftersom det är tydligare från C och det kommer också att tillåta oss att göra det när vi går in i skyddat läge.

Vi skapar en fil som heter NextKernel_Main.c med följande innehåll:

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

Med detta manipulerar vi minnet direkt VGA och karaktär för karaktär skriver vi den. Vi sammanställer genom att inaktivera stdlib:
gcc -o NextKernel_Main.o -c NextKernel_Main.c -nostdlib -fPIC -ffreestanding

Om du har kommit så här långt vill du prova ditt helt nya operativsystem nu, men vi är inte färdiga än. Vi behöver en liten fil som berättar att kompilatorn var i filen ska lämna varje avsnitt. Detta görs med ett länkskript. Vi skapar 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 = .;
}


Med detta definierar vi positionen för varje sektion och startpunkten, start, som vi har definierat i kernel.asm. Nu kan vi förena all denna sammansättning:

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

Nu kopierar vi START.ELF till / nästa inuti vår mapp som simulerar roten till vårt operativsystem. Vi går till rotmappen i vårt nya operativsystem med konsolen och verifierar att det finns två filer: en /boot/grub/grub.cfg och en annan /next/START.ELF.

Vi går till den övre katalogen och kallar ett ISO-skapande verktyg med GRUB kallat grub-mkrescue

grub-mkrescue -o nextdivel.iso nextroot

När vi väl har gjort detta kommer vi att ha en ISO. Denna ISO kan öppnas på datorer x86 (64 bitar också) och virtuella maskiner. För att testa det ska jag använda QEMU. Vi ringer QEMU från kommandoraden:

qemu-system-i386 nextdivel.iso

Kommer att starta SeaBIOS och senare kommer vi att ha GRUB. Senare om allt är korrekt kommer vi att se vår fras.
Du kommer att tro att det här är svårt, svarar jag, ja det är det.

Att skapa ett operativsystem är svårt och att det här inte gör något användbart. I framtida kapitel kommer vi att se hur man hanterar färger på skärmen, reserverar minne och om jag kan, hur man hämtar data från tangentbordet.

Om någon inte vill kopiera allt här har jag ett arkiv på GitHub (mer detaljerad) med operativsystemet NextDivel. Om du vill kompilera NextDivel du måste bara ha git och 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


Jag uppmuntrar dig att samarbeta på NextDivel om du har tid och önskan att skapa ett operativsystem. Kanske till och med överlägsen Linux ... tiden kommer att visa.