Belajar NetBSD - rump kernels & Kernel-in-Userspace

#Pendahuluan

Di episode 16 sebelumnya kita telah menaklukkan IPv6 dan networking lanjutan. Kini saatnya mengeksplorasi salah satu keunikan paling NetBSD di dunia sistem operasi: pada episode ini kita akan membedah rump kernels dan kernel-in-userspace — menjalankan driver dan subsistem kernel sebagai proses biasa dengan rump_server, mem-boot filesystem di userspace, dan memanfaatkannya untuk testing tanpa harus reboot.

Bayangkan bisa mencoba driver filesystem, mem-boot image disk, atau menguji network stack — semuanya sebagai proses normal yang bisa di-kill kapan saja, tanpa risiko merusak mesin. Inilah kekuatan rump kernels, dan hanya sedikit sistem operasi yang bisa melakukannya dengan sebersih NetBSD. Mari kita mulai dari konsep.

#Apa itu rump kernels?

rump adalah singkatan dari Runnable Userspace Meta Programs. Konsepnya: kernel NetBSD dimodulari sedemikian rupa sehingga driver dan subsistemnya bisa dikompilasi menjadi server yang berjalan di userspace — lengkap dengan filesystem stack, network stack, dan device driver — tanpa memerlukan mesin atau reboot.

Bayangkan sebuah kernel kecil yang "berlari" sebagai proses: ia punya VFS (Virtual File System), bisa memformat dan mem-mount filesystem, dan bisa menangani network — tetapi berjalan sebagai user biasa. Jika proses itu crash, tidak ada yang hancur.

#Manfaat Praktis

#Tool Utama: rump_server

Alat utama rump kernels adalah rump_server — daemon yang menjalankan komponen kernel pilihan di userspace. Tool ini tersedia di base system NetBSD.

#Menjalankan rump_server Pertama

rump_server -lrumpvfs

rump_server: creating server at unix socket /tmp/rump_server

Opsi -l memuat module (di sini rumpvfs — virtual file system), dan -r membuat socket. Sekarang kita punya "kernel mini" yang hidup di /tmp/rump_server — siap menerima perintah mount.

#Mem-boot Filesystem di Userspace

Inilah trik paling menarik: menggunakan rump_server untuk memformat dan mem-mount filesystem — termasuk image disk — tanpa menyentuh filesystem asli sistem.

#Membuat dan Memformat Image

truncate -s 64m /tmp/test.img

Lalu format image tersebut sebagai FFS — memakai rump, sehingga tidak perlu mount global:

rump.disk -t ffs /tmp/test.img

rump.disk: image /tmp/test.img contains 131072 sectors

rump.disk membungkus device disk sehingga bisa dipakai oleh komponen rump — sama seperti device /dev/sd0, tetapi sepenuhnya di userspace.

#Mount Filesystem Rump

Dengan socket rump_server yang berjalan, mount image ke direktori host:

mount_ffs -o rump /tmp/test.img /mnt/rump

mount | grep rump
/tmp/test.img on /mnt/rump type ffs (rump, local)

Perhatikan flag (rump, local) — mount ini dikelola oleh rump_server, bukan oleh kernel utama. Ini artinya filesystem itu "nyata" bagi proses yang memakainya, tetapi tidak mengganggu sistem induk sama sekali.

#Mengisi dan Membaca Data

cp /etc/rc.conf /mnt/rump/
ls -l /mnt/rump

-rw-r--r--  1 root  wheel  512 Aug  3 12:00 rc.conf

#Menguji Kerusakan Tanpa Risiko

Sekarang kekuatan sebenarnya: buat filesystem "rusak" dan lihat apakah fsck memperbaikinya — semuanya di userspace:

rump.disk -t ffs -F /tmp/test.img
fsck -o rump -y /tmp/test.img

** /tmp/test.img
** Phase 1 - Check Blocks and Sizes
...  (diperbaiki otomatis)

Kalau ini dilakukan di filesystem asli, risiko kehilangan data nyata. Dengan rump, semuanya berada di satu file image — hancur berkali-kali pun tidak masalah.

#rumphijack: Memaksakan Proses ke Userspace

rumphijack membungkus sebuah proses sehingga syscall-nya diarahkan ke rump_server alih-alih kernel. Contoh klasik: menjalankan ping dengan network stack rump — seolah-olah proses itu berjalan di mesin yang berbeda.

rump_server -lrumpnet -lrumpnet_net -lrumpnet_netinet unix:///tmp/rumpsock

rump_server: creating server at /tmp/rumpsock

Lalu hijack proses ping:

rumphijack -s /tmp/rumpsock ping -c 3 127.0.0.1

PING 127.0.0.1: 56 data bytes
64 bytes from 127.0.0.1: icmp_seq=0 time=0.041 ms

Perintah itu tampak biasa, tetapi sebenarnya berjalan di atas network stack userspace. Untuk pengujian network, ini memungkinkan mensimulasikan interface dan topologi tanpa memengaruhi stack kernel yang sebenarnya.

#Use Case: Testing Filesystem Tanpa Reboot

Kombinasi rump dan image disk membuka alur kerja yang sangat produktif:

1. Buat image disk uji (truncate).
2. Jalankan rump_server dengan rumpvfs (dan rumpdev jika butuh device).
3. Format dengan newfs -o rump atau rump.disk -t ffs.
4. Mount, isi data, jalankan tool, hancurkan — berulang kali.
5. Buang server (rump_server -u) dan ulangi.

truncate -s 64m /tmp/test.img
rump_server -lrumpvfs
rump.disk -t ffs /tmp/test.img
mount_ffs -o rump /tmp/test.img /mnt/rump
# ... operasi apapun ...
umount /mnt/rump
rump_server -u

#Kapan Menggunakan rump kernels

#Penutup

Pada episode 17 ini, kalian telah mengeksplorasi keunikan paling NetBSD: konsep rump kernels sebagai kernel yang berjalan di userspace, penggunaan rump_server untuk menjalankan komponen kernel, mem-boot dan mengelola filesystem di userspace, serta memanfaatkan rumphijack untuk mengarahkan syscall proses ke network stack rump.

Inti yang harus dibawa pulang:

• rump kernels = kernel/driver berjalan sebagai proses userspace — crash tidak menyeret sistem.
• rump_server -lrumpvfs membangun "kernel mini" dengan socket.
• Format/mount filesystem di userspace dengan -o rump (contoh mount_ffs -o rump).
• rumphijack mengarahkan syscall sebuah proses ke rump_server.
• Ideal untuk testing filesystem/network tanpa reboot dan untuk CI.

Di episode 18 selanjutnya kita akan membawa NetBSD ke dunia virtualisasi: virtualization dan cloud dengan NVMM dan Xen — memahami hypervisor NVMM, integrasi dengan QEMU, peran Xen sebagai dom0/domU, dan image cloud. Sampai jumpa di episode 18!