Nabootsing van Linus Torvalds: Skep u eie bedryfstelsel van nuuts af (I)

Eerstens moet u opmerk dat dit my eerste artikel is en dat ek hoop dat u almal daarvan hou.

In hierdie reeks gaan ons navolg Linus Torvalds, gaan ons ons bedryfstelsel skep vanaf 0. In hierdie eerste episode gaan ons die boot sien en ons sal 'n teks uit ons kern op die skerm plaas.

In my geval word die bedryfstelsel genoem Volgende Divel. Die eerste besluit wat ons moet neem sodra ons die bedryfstelsel oorweeg, is wat die selflaaiprogram sal wees?

Hier is daar verskeie variante, en ons kan selfs self een skep; in hierdie handleiding gaan ek egter gebruik GRUB, want die meeste weet min of meer iets van hom. Ons skep 'n vouer wat die wortel van ons bedryfstelsel is en daar maak ons ​​die / boot / grub-vouer

mkdir nextroot && cd nextroot

mkdir -p boot/grub

Daar skep ons die grub.cfg-lêer soos volg:

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


In hierdie lêer het ons gesien hoe GRUB sal ons kern in hierdie geval in /next/START.ELF laai. Nou moet ons ons kern skep.

Hiervoor het ons die GCC y GAS (die samesteller van die projek GNU, kom gewoonlik saam met die gcc). Ons gaan dus die kern skep.

Ons maak eers 'n lêer met die naam kernel.asm. Hierdie lêer bevat die beginpunt van ons kern en sal ook die multiboot definieer ('n kenmerk van sommige selflaaiprogramme soos GRUB). Die inhoud van kernel.asm sal wees:

.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 wat met multiboot verband hou, is bloot om die spesifikasie niks anders te volg nie. Alles sal begin, dit sal multiboot_entry noem, ons sal die multibootkopkop in die eerste 4k gedefinieer het en ons sal dit (met movl) sit.

Later noem ons NextKernel_Main wat ons kern C-funksie is. In die lus stop ons om die rekenaar te stop. Dit kom saam met:

as -o kernel.o -c kernel.asm

Nou gaan ons programmering in C betree. U sal dink dat alles nou 'n stuk koek is, ons sit 'n printf en hoof en dit is dit, ons het dit gedoen.

Wel nee, sedertdien printf y hoof dit is funksies wat deur die bedryfstelsel gedefinieer word, maar ons skep dit! Ons kan slegs die funksies gebruik wat ons self definieer.

In latere hoofstukke sal ek praat oor hoe om ons eie C-biblioteek (glibc, bionic, newlibc) maar van tyd tot tyd te plaas. Ons het bespreek dat ons teks op die skerm wil plaas, en ons sal sien hoe ons dit doen.

Daar is twee opsies, een is om die BIOS en 'n ander is om skermgeheue direk te bestuur. Ons gaan laasgenoemde doen, want dit is duideliker uit C en dit sal ons ook toelaat om dit te doen wanneer ons die beskermde modus betree.

Ons skep 'n lêer genaamd NextKernel_Main.c met die 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 manipuleer ons die geheue direk VGA en karakter vir karakter skryf ons dit. Ons stel saam deur die stdlib uit te skakel:
gcc -o NextKernel_Main.o -c NextKernel_Main.c -nostdlib -fPIC -ffreestanding

As u tot hiertoe gekom het, wil u nou u splinternuwe bedryfstelsel probeer, maar ons is nog nie klaar nie. Ons het 'n klein lêer nodig wat die samesteller vertel waar in die lêer elke afdeling moet verlaat. Dit word gedoen met 'n skakelskrip. Ons skep 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 definieer ons die posisie van elke afdeling en die ingangspunt, begin, wat ons in kernel.asm omskryf het. Nou kan ons al hierdie konkoksie verenig:

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

Nou kopieer ons START.ELF na / volgende in ons gids wat die wortel van ons bedryfstelsel simuleer. Ons gaan met die konsole na die hoofmap van ons nuwe bedryfstelsel en verifieer dat daar twee lêers is: een /boot/grub/grub.cfg en 'n ander /next/START.ELF.

Ons gaan na die boonste gids en noem 'n ISO-skeppingsprogram met GRUB genaamd grub-mkrescue

grub-mkrescue -o nextdivel.iso nextroot

Sodra ons dit gedoen het, sal ons 'n ISO. Hierdie ISO kan op rekenaars oopgemaak word x86 (64 bisse ook) en virtuele masjiene. Om dit te toets, gaan ek dit gebruik QEMU. Ons roep QEMU vanaf die opdraglyn:

qemu-system-i386 nextdivel.iso

Sal begin SeaBIOS en later sal ons hê GRUB. As alles later korrek is, sal ons ons frase sien.
U sal dink dat dit moeilik is, antwoord ek, ja, dit is.

Dit is moeilik om regtig 'n bedryfstelsel te skep en dat dit hier niks nuttig is nie. In toekomstige hoofstukke sal ons sien hoe om kleure op die skerm te hanteer, geheue te reserveer en indien moontlik, hoe om data vanaf die sleutelbord te kry.

As iemand nie alles hier wil kopieer nie, het ek 'n bewaarplek by GitHub (uitgebrei) met die bedryfstelsel Volgende Divel. As u wil saamstel Volgende Divel jy moet net git en cmake hê:

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


Ek moedig u aan om saam te werk aan NextDivel as u die tyd en begeerte het om 'n bedryfstelsel te skep. Miskien selfs beter as Linux ... die tyd sal leer.