Meniru Linus Torvalds: Buat sistem operasi Anda sendiri dari awal (I)

Pertama-tama, beri komentar bahwa ini adalah artikel pertama saya dan saya harap Anda semua menyukainya.

Dalam seri ini kita akan meniru Linus Torvalds, kita akan membuat sistem operasi kita dari 0. Di episode pertama ini kita akan melihat boot dan kita akan meletakkan teks di layar dari kernel kita.

Dalam kasus saya, sistem operasi disebut BerikutnyaMenyelam. Keputusan pertama yang harus kita buat segera setelah kita mempertimbangkan sistem operasi adalah apa yang akan menjadi bootloader?

Di sini ada beberapa varian, dan kami bahkan dapat membuatnya sendiri; Namun dalam tutorial ini saya akan menggunakan GRUB, karena kebanyakan tahu sedikit banyak tentang dia. Kami membuat folder yang akan menjadi root sistem operasi kami dan di sana kami membuat folder / boot / grub

mkdir nextroot && cd nextroot

mkdir -p boot/grub

Di sana kami membuat file grub.cfg sebagai berikut:

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


Dalam file ini kita telah melihat caranya GRUB akan memuat kernel kami, dalam hal ini, di /next/START.ELF. Sekarang kita harus membuat kernel kita.

Untuk ini kita membutuhkan GCC y GAS (perakit proyek GNU, biasanya dilengkapi dengan gcc). Jadi kami akan membuat kernel.

Kami pertama kali membuat file bernama kernel.asm. File ini akan berisi titik awal kernel kami dan juga akan menentukan multiboot (fitur dari beberapa bootloader seperti GRUB). Isi dari kernel.asm adalah:

.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

Segala sesuatu yang berhubungan dengan multiboot hanya mengikuti spesifikasinya, tidak lebih. Semuanya akan dimulai di awal, ini akan memanggil multiboot_entry, kita akan mendefinisikan header multiboot di 4k pertama dan kita akan menaruhnya (dengan movl).

Kemudian kami memanggil NextKernel_Main yang merupakan fungsi kernel C kami. Dalam loop kami melakukan penghentian untuk menghentikan komputer. Ini dikompilasi dengan:

as -o kernel.o -c kernel.asm

Sekarang kita akan memasuki pemrograman dalam C. Anda akan berpikir bahwa sekarang semuanya sudah mudah, kami meletakkan file Printf en utama dan hanya itu, kami telah melakukannya.

Tidak, sejak itu Printf y utama Ini adalah fungsi yang ditentukan oleh sistem operasi, tetapi kami sedang membuatnya! Kami hanya dapat menggunakan fungsi yang kami tentukan sendiri.

Dalam bab-bab selanjutnya saya akan berbicara tentang bagaimana meletakkan perpustakaan C kita sendiri (glibc, bionic, newlibc) tetapi dari waktu ke waktu. Kami telah mengatakan bahwa kami ingin meletakkan teks di layar, kami akan melihat bagaimana kami melakukannya.

Ada dua pilihan, satu adalah memanggil file BIOS dan lainnya adalah mengelola memori layar secara langsung. Kami akan melakukan yang terakhir karena lebih jelas dari C dan itu juga akan memungkinkan kami untuk melakukannya ketika kami memasuki mode terlindungi.

Kami membuat file bernama NextKernel_Main.c dengan konten berikut:

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

Dengan ini kami langsung memanipulasi memori VGA dan karakter demi karakter kami menulisnya. Kami mengkompilasi dengan menonaktifkan stdlib:
gcc -o NextKernel_Main.o -c NextKernel_Main.c -nostdlib -fPIC -ffreestanding

Jika Anda sudah berhasil sejauh ini, Anda pasti ingin mencoba sistem operasi baru Anda sekarang, tetapi kami belum selesai. Kami membutuhkan file kecil yang memberi tahu kompiler di mana file akan meninggalkan setiap bagian. Ini dilakukan dengan skrip linker. Kami membuat 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 = .;
}


Dengan ini kami menentukan posisi setiap bagian dan titik masuk, mulai, yang telah kami definisikan di kernel.asm. Sekarang kita bisa menyatukan semua ramuan ini:

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

Sekarang kita salin START.ELF ke / next di dalam folder kita yang mensimulasikan root sistem operasi kita. Kami pergi ke folder root sistem operasi baru kami dengan konsol dan memverifikasi bahwa ada dua file: satu /boot/grub/grub.cfg dan /next/START.ELF lainnya.

Kami pergi ke direktori atas dan memanggil utilitas pembuatan ISO dengan GRUB disebut grub-mkrescue

grub-mkrescue -o nextdivel.iso nextroot

Setelah kami melakukan ini, kami akan memiliki file ISO. ISO ini dapat dibuka di komputer x86 (64 bit juga) dan mesin virtual. Untuk mengujinya, saya akan menggunakan QEMU. Kami memanggil QEMU dari baris perintah:

qemu-system-i386 nextdivel.iso

Akan dimulai BIOS Laut dan nanti kita akan punya GRUB. Nanti jika semuanya benar kita akan melihat frase kita.
Anda akan berpikir bahwa ini sulit, saya menjawab Anda, ya.

Sungguh sulit untuk membuat sistem operasi dan yang satu ini di sini tidak berguna. Dalam bab-bab selanjutnya kita akan melihat bagaimana menangani warna pada layar, memesan memori dan jika saya bisa, bagaimana mendapatkan data dari keyboard.

Jika seseorang tidak ingin menyalin semuanya di sini, saya memiliki repositori di GitHub (lebih rumit) dengan sistem operasi BerikutnyaMenyelam. Jika Anda ingin mengkompilasi BerikutnyaMenyelam Anda hanya perlu memiliki git dan 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


Saya mendorong Anda untuk berkolaborasi di NextDivel jika Anda punya waktu dan keinginan untuk membuat sistem operasi. Mungkin lebih unggul dari Linux ... waktu akan menjawabnya.