Belajar Assembly - Kernel, Bootloader & Embedded

#Pendahuluan

Inilah alasan paling murni mengapa assembly masih ada: kernel, bootloader, dan firmware tidak bisa ditulis tanpa assembly. Saat komputer menyala, tidak ada OS, tidak ada libc, bahkan tidak ada fungsi — hanya CPU, memori, dan instruksi mesin. Episode 21 membawa kalian ke medan itu, dan menutupnya dengan embedded bare-metal di ARM Cortex-M dan RISC-V.

Mengapa penting? Karena memahami boot flow dan interrupt adalah inti dari sistem operasi — dan bagian-bagian krusialnya (setup page tables, switch mode, interrupt stub) selalu assembly. Kalau kalian bercita-cita ke sistem programming, kernel, atau security research (bootkits, firmware), ini medan perang kalian.

#Alur Boot: Dari Power-On ke Long Mode

Perjalanan sebuah sistem x86-64 dimulai dengan mode yang sangat sederhana:

1. Real mode (16-bit) — CPU memakai register segmentasi; hanya 1 MiB yang bisa diakses. Inilah kondisi saat BIOS memuat bootloader.
2. Protected mode (32-bit) — mode flat 32-bit modern.
3. Long mode (64-bit) — mode yang kita pakai sepanjang series ini; butuh setup page tables dan GDT.

Setiap transisi dilakukan lewat assembly: mengubah kontrol register (CR0/CR4/EFER) dan memuat GDT/IDT. Contoh transisi real → protected (ringkas):

; matikan interrupt dulu
cli
; muat GDT
lgdt [gdt_desc]
; set PE (Protection Enable) bit di CR0
mov eax, cr0
or eax, 1
mov cr0, eax
; far jump untuk flush pipeline
jmp 0x08:protected_start

#Bootloader: Multiboot dan GRUB

Bootloader bertugas memuat kernel ke memori dan menyerahkan kontrol. Spesifikasi Multiboot menstandarkan antarmuka antara bootloader dan OS. Sebuah kernel yang ingin boot via GRUB cukup menandai dirinya dengan header Multiboot:

section .multiboot
align 4
    dd 0x1BADB002          ; magic Multiboot
    dd 0                   ; flags
    dd -(0x1BADB002 + 0)   ; checksum
 
section .text
global _start
_start:
    ; GRUB memanggil kita di protected mode 32-bit
    mov esp, stack_top
    ; ... inisialisasi minimal ...
    hlt
 
section .bss
align 16
stack_bottom:
    resb 16384
stack_top:

Bootloader juga bertanggung jawab pada interrupt handlers selama boot. Di x86-64, handler didaftarkan lewat IDT (Interrupt Descriptor Table): lidt memuat tabel, dan setiap entry menunjuk ke stub assembly yang menyimpan register (pusha-setara) lalu menyerahkan ke kode C. Stub interrupt selalu assembly karena harus mengelola hardware secara presisi.

#Assembly di Kernel Linux

Linux sendiri menyimpan ratusan baris assembly di arch/x86/. Area yang paling terkenal:

• arch/x86/entry/entry_64.S — jalur syscall dan interrupt (materi episode 10 dipakai di sini!).
• arch/x86/boot/ — bootstrap real-mode.
• arch/x86/kernel/head_64.S — transisi ke long mode dan setup page tables.
• arch/x86/lib/ — rutin memori yang di-tuning (memset, memcpy versi SIMD).

grep -n "syscall" arch/x86/entry/entry_64.S | head

Fakta yang melegakan: kalian sudah mengenal 90% instruksi di file-file tersebut. syscall (episode 10), register save/restore (episode 8), swapgs, dan page-table setup — semuanya adalah kombinasi teknik yang sudah kalian kuasai.

#Embedded: Bare-Metal ARM Cortex-M dan RISC-V

Di dunia microcontroller, kalian menulis bare-metal: tidak ada OS, program langsung berjalan di reset vector. Dua target paling umum:

#ARM Cortex-M (misal STM32)

CPU menjalankan kode langsung dari flash; vector table (termasuk reset handler) diisi alamat-alamat fungsi:

.section .isr_vector
    .word _estack              ; SP awal
    .word Reset_Handler        ; PC saat reset
    .word NMI_Handler
 
.section .text
Reset_Handler:
    ldr r0, =_sbss
    ldr r1, =_ebss
    movs r2, #0
bss_clear:
    cmp r0, r1
    bcs main
    str r2, [r0], #4
    b bss_clear
main:
    bl main_loop               ; fungsi C
    b .

#RISC-V MCU

Sama polanya, dialek RISC-V:

.section .text.init
.global _start
_start:
    la sp, _estack
    call _bss_init
    call main
    j _start

Kedua versi memakai prinsip yang sama: atur stack pointer, nol-kan .bss, lalu panggil main di C — inisialisasi bare-metal yang kita pelajari dari episode 8 dan 11, hanya di arsitektur berbeda.

#Praktik Mini: Kernel Hello di QEMU

Untuk merasakan "menjadi kernel", uji kernel kecil 32-bit dengan QEMU:

nasm -f elf32 mini_kernel.asm -o mini.o
ld -m elf_i386 -Ttext 0x100000 mini.o -o mini_kernel
qemu-system-i386 -kernel mini_kernel

Gantilah mini_kernel.asm dengan kode yang menulis ke VGA text buffer (alamat 0xB8000) — di situlah kalian melihat tulisan "kernel" kalian di layar virtual QEMU. Detail lengkapnya bisa mengisi satu series sendiri; untuk sekarang, cukup pahami posisi assembly dalam alur boot.

#Common Pitfalls

• Melupakan cli saat transisi mode — interrupt bisa terjadi di tengah perubahan state yang tidak konsisten.
• Stack tidak disetup — interrupt pertama crash; atur SP paling awal.
• GDT/IDT base yang salah — lgdt/lidt menerima alamat linear; salah alamat = triple fault.
• Mencampur lebar mode — instruksi 64-bit di protected mode (dan sebaliknya) tidak valid.
• .bss tidak di-nol-kan di bare-metal — variabel global dianggap nol padahal berisi sampah; inilah kenapa kita zeroing di startup.
• Melewatkan segmentasi — real mode butuh segment:offset; jangan pakai asumsi flat.

#Penutup

Pada episode 21 ini, kalian telah melihat assembly di titik paling murni.

Inti yang harus dibawa pulang:

• Alur boot: real mode → protected mode → long mode; tiap transisi butuh assembly.
• Multiboot header adalah antarmuka GRUB ↔ kernel; interrupt handler lewat IDT + stub assembly.
• Kernel Linux menyimpan bootstrap dan entry syscall di arch/x86/ — 90% instruksinya sudah kalian kenal.
• Bare-metal (ARM Cortex-M, RISC-V MCU): setup SP, nol-kan .bss, panggil main.
• QEMU memungkinkan uji boot dan embedded tanpa hardware.

Di episode 22 — episode pamungkas — kita mundur selangkah melihat peta besar: ekosistem, alternatif & refleksi akhir — perbandingan Assembly vs C vs Rust vs WebAssembly, kapan memilih yang mana, rekap lengkap episode 0–21, checklist production toolchain, dan daftar sumber belajar resmi untuk melanjutkan perjalanan kalian. Ini bukan akhir — ini penutup satu fase.