compile kernel
pada bagian ini, kita akan menulis dan load sebuah kernel modul sederhana. Dengan menuliskan sendiri modul kita menjadi belajar bagaimana menulis code kernel yang berdiri sendiri, belajar bagaimana menggunakan modul, dan menemukan beberapa aturan bagaimana kernel terkait menjadi satu kesatuan.
Catatan: instruksi disini ditulis untuk kernel 3.8.x yang mungkin tidak cocok untuk versi kernel yang berbeda.
Contents[hide]
|
[edit]Apakah kernel mendukung modul?
Kernel yang kita gunakan, harus di compile dengan option:
[*] Enable loadable module support ---> [ ] Forced module loading [*] Module unloading [ ] Forced module unloading [*] Module versioning support [*] Source checksum for all modules [*] Module signature verification [ ] Require modules to be validly signed
Pastikan pada saat kita mengcompile kernel opsi di atas di aktifkan. Jika tidak, kita perlu mengcompile ulang kernel.
Sebaiknya, sebelum berexperimen dengan kernel modul, kita mengcompile ulang kernel yang kita gunakan. Tentunya lengkap dengan update-grub dan kemudian boot ke kernel baru tersebut untuk berexperimen dengan kernel modul yang kita buat.
[edit]Rangka Kernel Modul Sederhana
Pertama kali, kita perlu mencari lokasi directory tempat kernel di compile, biasanya di /usr/src/linux. Kemudian ubah directory ke drivers/misc dari directory source code Linux. Lakukan di shell
cd /usr/src/linux/drivers/misc
Edit file, misalnya, mymodule.c
vi mymodule.c
Sekarang, copy paste code berikut ke file mymodule.c
#include <linux/module.h>
#include <linux/configfs.h>
#include <linux/init.h>
static int __init mymodule_init(void)
{
printk ("My module worked!\n");
return 0;
}
static void __exit mymodule_exit(void)
{
printk ("Unloading my module.\n");
return;
}
module_init(mymodule_init);
module_exit(mymodule_exit);
MODULE_LICENSE("GPL");
Simpan file .c tersebut. Edit Makefile di directory tersebut.
cd /usr/src/linux/drivers/misc vi Makefile
Tambahkan kalimat:
obj-m += mymodule.o
Compile module yang kita tulis:
# make -C [top directory dari source kernel] SUBDIRS=$PWD modules
Atau yang lebih jelas
# make -C /usr/src/linux SUBDIRS=$PWD modules
[edit]Jalankan Module
Load module. Tergantung versi kernel yang kita gunakan, ketik:
cd /usr/src/linux/drivers/misc insmod ./mymodule.ko
Atau:
cd /usr/src/linux/drivers/misc insmod ./mymodule.o
Tampaknya untuk kernel versi 3.8 ke atas lebih aman menggunakan .ko.
Cek apakah modul yang kita masukan jalan dengan baik, ketik:
# dmesg | tail
Kita harusnya melihat di akhir printout sebagai berikut:
My module worked!
Cek menggunakan
# lsmod | more
Harusnya keluar kira-kira
Module Size Used by mymodule 12428 0
Selanjutnya, coba kita buang kernel module tersebut menggunakan perintah:
# rmmod mymodule
Cek output di dmesg,
# dmesg | tail
Kita harusnya akan melihat:
Unloading my module.
Selamat! Kita baru saja menulis & menjalankan kernel module yang baru.
[edit]Interface module/kernel
Selanjutnya, mari kita bermain dengan module yang kita buat. Satu hal yang harus kita sadari bahwa module hanya dapat "melihat" function dan variable yang secara sengaja oleh kernel dibuat terlihat ke module.
Pertama-tama, mari kita coba cara yang SALAH! :) ..
Edit file kernel/printk.c
vi /usr/src/linux/kernel/printk.c
Dan tambahkan kalimat berikut sesudah semua include file dan dekat deklarasi variable global (tapi di luar semua function):
int my_variable = 0;
Atau yang lebih lengkap kira-kira sebagai berikut,
#define CREATE_TRACE_POINTS
#include <trace/events/printk.h>
int my_variable = 0;
/*
* Architectures can override it:
*/
void asmlinkage __attribute__((weak)) early_printk(const char *fmt, ...)
{
}
Sekarang compile ulang kernel, update-grub dan reboot ke kernel yang baru.
Selanjutnya, tambahkan kalimat berikut di awal dari module kita dalam function mymodule_init, sebelum code lainnya:
extern int my_variable;
printk ("my_variable is %d\n", my_variable);
my_variable++;
I Lebih jelasnya lakukan modifikasi pada function mymodule_init agar menjadi,
static int __init mymodule_init(void)
{
extern int my_variable;
printk ("my_variable is %d\n", my_variable);
my_variable++;
printk ("My module worked!\n");
return 0;
}
Simpan file yang kita ubah, dan di recompile module menggunakan perintah:
cd /usr/src/linux/drivers/misc make -C /usr/src/linux SUBDIRS=$PWD modules
Dan load module (ini harusnya akan gagal):
cd /usr/src/linux/drivers/misc insmod ./mymodule.ko
Saat loading module yang kita buat harusnya fail dengan message berikut:
insmod: error inserting './mymodule.ko': -1 Unknown symbol in module
ini artinya kernel tidak mengijinkan module untuk "melihat" variable tersebut. Saat module di load, kernel akan me-resolve semua referensi external, seperti nama function atau nama variable. Jika dia tidak berhasil me-resolve semua nama yang ada dalam daftar simbol yang di export kernel, maka module tidak bisa menulis / menggunakan variable atau call ke function tersebut. Kernel mengalokasi tempat bagi variable my_variable entah mana, sayangnya module tidak bisa menemukannya.
Untuk memperbaiki ini, kita akan memasukan my_varible ke daftar symbol yang di export oleh kernel. Banyak directory di kernel mempunyai file yang di khususkan untuk meng-export symbol yang di definisikan dalam directory tersebut. Buka lagi file kernel/printk.c
vi /usr/src/linux/kernel/printk.c
dan tambahkan kalimat berikut sesudah deklarasi varible my_variable:
EXPORT_SYMBOL(my_variable);
Atau yang lebih lengkap kira-kira sebagai berikut,
#define CREATE_TRACE_POINTS #include <trace/events/printk.h>
int my_variable = 0;
EXPORT_SYMBOL(my_variable);
/*
* Architectures can override it:
*/
void asmlinkage __attribute__((weak)) early_printk(const char *fmt, ...)
{
}
Recompile kernel, update-grub dan reboot ke kernel yang baru.
Sekarang coba untuk load module lagi:
# insmod ./mymodule.ko
Sekarang, saat kita cek dmesg, kita harusnya melihat:
my_variable is 0 My module worked!
Reload module:
# rmmod mymodule && insmod ./mymodule.ko
Sekarang kita akan melihat:
Unloading my module. my_variable is 1 My module worked!
Setiap kali kita me-reload module, my_variable harus bertambah satu. Module yang kita buat dapat mengakses variable atau function yang ada di main kernel, selama secara explisit di export melalui deklarasi EXPORT_SYMBOL(). Contoh, function printk() di definisikan di kernel dan di export di file kernel/printk.c.
Membuat loadable kernel module sederhana adalah cara menyenangkan untuk mengeksplorasi kernel. Contoh, kita dapat menggunakan sebuah module untuk menyalakan dan mematikan printk, dengan mendefinisikan variable do_print di kernel yang awalnya di set 0. Maka semua printk menjadi tergantung pada "do_print":
if (do_print)
printk ("Big long obnoxious message\n");
dan menyalakan do_print jika kernel module yang kita buat di load. Kita dapat mendefinisikan di modul yang kita buat ke daftar function yang di panggil ketika kernel menerima interupsi tertentu (gunakan cat /proc/interrupts untuk mencari tahu interupsi yang digunakan).
function request_irq() menambahkan function yang kita buat ke daftar handler untuk line IRQ (Interrupt ReQuest) tertentu, yang mana kita dapat gunakan untuk mem-print out sebuah message setiap kita menerima interupsi di line tersebut. Kita dapat melakukan investigasi nilai dari variable yang di export dengan cara me-load module yang dapat membaca nilai tersebut dan langsung keluar (return nilai non-zero dari function module_init()). Variabel jiffies, yang naik setiap 1/100 detik (di kebanyakan platform), adalah kandidat yang baik untuk module seperti ini.
Semoga anda cukup bersemangat untuk bermain dengan kernel module!
[edit]Referensi
- http://www.linuxchix.org/content/courses/kernel_hacking/lesson8
- http://www.tldp.org/LDP/lkmpg/2.6/html/lkmpg.html
- http://www.tldp.org/LDP/lkmpg/2.6/html/x181.html
