Emulimi i Linus Torvalds: Krijoni sistemin tuaj operativ nga e para (I)

Para së gjithash, komentoni se ky është artikulli im i parë dhe që ju uroj të gjithë ju pëlqen.

Në këtë seri ne do të imitojmë Linus Torvalds, ne do të krijojmë sistemin tonë operativ nga 0. Në këtë episod të parë do të shohim boot-in dhe do të vendosim një tekst në ekran nga kerneli ynë.

Në rastin tim thirret sistemi operativ NextDivel. Vendimi i parë që duhet të marrim sa më shpejt që të shqyrtojmë sistemin operativ është cili do të jetë bootloader?

Këtu ka variante të shumta, dhe ne madje mund të krijojmë një vetë; megjithatë në këtë udhëzues do të përdor GRUB, sepse shumica dinë pak a shumë diçka për të. Ne krijojmë një dosje që do të jetë rrënja e sistemit tonë operativ dhe aty krijojmë dosjen / boot / grub

mkdir nextroot && cd nextroot

mkdir -p boot/grub

Aty krijojmë skedarin grub.cfg si më poshtë:

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


Në këtë skedar kemi parë se si GRUB do të ngarkojë bërthamën tonë, në këtë rast, në /next/START.ELF. Tani ne duhet të krijojmë bërthamën tonë.

Për këtë do të na duhet GCC y GAS (montuesi i projektit GNU, zakonisht vjen me gcc). Kështu që ne do të krijojmë bërthamën.

Së pari bëjmë një skedar të quajtur kernel.asm. Kjo skedar do të përmbajë pikën fillestare të kernelit tonë dhe gjithashtu do të përcaktojë multiboot (një tipar i disa bootloaders si p.sh. GRUB) Përmbajtja e kernel.asm do të jetë:

.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

Gjithçka që lidhet me multiboot është thjesht të ndjekësh specifikimet asgjë më shumë. Gjithçka do të fillojë në fillim, do të thërrasë multiboot_entry, ne do të kemi përcaktuar kokën multiboot në 4k-në e parë dhe do ta vendosim atë (me movl).

Më vonë ne e quajmë NextKernel_Main që është funksioni ynë i kernelit C. Në lak, ne ndalet për të ndaluar kompjuterin. Kjo përpilohet me:

as -o kernel.o -c kernel.asm

Tani do të hyjmë në programim në C. Do të mendoni se tani gjithçka është një copë tortë, ne vendosim një printf en kryesor dhe kjo është e gjitha, ne e kemi bërë atë.

Epo jo, pasi printf y kryesor Këto janë funksione që përcaktohen nga sistemi operativ, por ne po i krijojmë ato! Ne mund të përdorim vetëm funksionet që i përcaktojmë vetë.

Në kapitujt e mëvonshëm do të flas se si të vendosim bibliotekën tonë C (glibc, bionic, newlibc) por kohë pas kohe. Ne kemi biseduar që duam të vendosim tekst në ekran, mirë do të shohim se si ta bëjmë atë.

Ka dy mundësi, njëra është të telefononi BIOS dhe një tjetër është menaxhimi i kujtesës në ekran direkt. Ne do të bëjmë këtë të fundit sepse është më i qartë nga C dhe gjithashtu do të na lejojë ta bëjmë kur të hyjmë në modalitetin e mbrojtur.

Ne krijojmë një skedar të quajtur NextKernel_Main.c me përmbajtjen vijuese:

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

Me këtë manipulojmë drejtpërdrejt me kujtesën VGA dhe karakter për karakter po e shkruajmë. Ne përpilojmë duke çaktivizuar stdlib:
gcc -o NextKernel_Main.o -c NextKernel_Main.c -nostdlib -fPIC -ffreestanding

Nëse e keni arritur deri më tani, do të dëshironi të provoni sistemin tuaj të ri operativ tani, por ne nuk kemi mbaruar ende. Ne kemi nevojë për një skedar të vogël që i tregon përpiluesit se ku në skedar të lërë secilin seksion. Kjo është bërë me një skenar lidhës. Ne krijojmë 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 = .;
}


Me këtë ne përcaktojmë pozicionin e secilit seksion dhe pikën e hyrjes, fillimin, që kemi përcaktuar në kernel.asm. Tani mund ta bashkojmë të gjithë këtë shpikje:

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

Tani ne kopjojmë START.ELF tek / tjetri brenda dosjes tonë që simulon rrënjën e sistemit tonë operativ. Ne shkojmë në dosjen rrënjë të sistemit tonë të ri operativ me tastierë dhe verifikojmë që ekzistojnë dy skedarë: një /boot/grub/grub.cfg dhe një tjetër /next/START.ELF.

Ne shkojmë në direktorinë e sipërme dhe thërrasim një vegël të krijimit ISO me GRUB të thirrur grub-mkrescue

grub-mkrescue -o nextdivel.iso nextroot

Pasi ta kemi bërë këtë do të kemi një ISO. Ky ISO mund të hapet në kompjuter x86 (64 bit gjithashtu) dhe makinat virtuale. Për ta provuar, do të përdor QEMU. Ne e quajmë QEMU nga rreshti i komandës:

qemu-system-i386 nextdivel.iso

Do të fillojë DetiBIOS dhe më vonë do të kemi GRUB. Më vonë nëse gjithçka është e saktë do të shohim frazën tonë.
Ju do të mendoni se kjo është e vështirë, unë ju përgjigjem, po është.

Realisht krijimi i një sistemi operativ është i vështirë dhe se ky këtu nuk bën ndonjë gjë të dobishme. Në kapitujt e ardhshëm do të shohim se si të trajtojmë ngjyrat në ekran, të rezervojmë kujtesën dhe nëse mundem, si të marr të dhëna nga tastiera.

Nëse dikush nuk dëshiron të kopjojë gjithçka këtu, unë kam një depo në GitHub (më i përpunuar) me sistemin operativ NextDivel. Nëse dëshironi të përpiloni NextDivel thjesht duhet të keni git dhe 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


Unë ju inkurajoj të bashkëpunoni në NextDivel nëse keni kohë dhe dëshirë për të krijuar një sistem operativ. Ndoshta edhe më superior se Linux ... koha do ta tregojë.