1. Kernel Modules

2. Kernel Module Pieces of code that can be loaded and unloaded into the kernel upon demand. Compiled as an independent program With appropriate flags to indicate that it is kernel code. Can be linked into the kernel by installation. –Static/Dynamic loading –“/proc/modules” or “lsmod” Enhance the functionality of the kernel. Example: –Device Drivers

3. Functions in Kernel Module int init_module(void) –Invoked when the module is inserted to kernel –Return 0 if success. void cleanup_module(void) –Invoked when the module is removed from kernel printk() –/usr/src/linux-2.6.5-1.358/include/linux/kernel.h

4. #include int init_module(void) { printk(KERN_ALERT "Hello world.\n“); return 0; } void cleanup_module(void) { printk(KERN_ALERT "Goodbye world.\n"); } MODULE_LICENSE("GPL"); // GNU Public License v2 or later

5. Makefile ifneq ($(KERNELRELEASE),) obj-m += hello.o else KDIR:= /lib/modules/$(shell uname -r)/build PWD:= $(shell pwd) default: $(MAKE) -C $(KDIR) SUBDIRS=$(PWD) modules endif

6. insmod hello.ko lsmod or “/proc/modules” tail -f /var/log/messages rmmod hello

7. Modules vs. Programs Programs –main() –performs a single task from beginning to end –Run in user mode –Can call the libc functions Modules –init_module & cleanup_module –registers itself in order to serve future requests –Run in kernel mode Part of kernel program –Only can call the ones exported by the kernel. include/linux include/asm Export all non-static symbols

8. Device Drivers Character devices –one that can be accessed as a stream of bytes –Keyboard driver Block devices –One that can be accessed as multiples of a block, usually 1KB per block –Disk driver

9. Device Drivers To communicate with hardware –Each piece of hardware is represented by a file located in /dev –An application do some operations on that file –The kernel finds corresponding device driver for that file. –Each operation on that file will trigger a function in the device driver for that hardware –The file in /dev is not regular file To find the device driver for that file –ls -l /dev/b* –Major number Match with driver –Minor number used by the driver to distinguish between the various hardware it controls ls -l /dev/fd0u*

10. Device Drivers Defines functions on the file operation –Read, write, open, close, etc Register the device to kernel creates a file in “/dev” using “mknod”

11. Device Drivers Function mapping struct file_operations fops = {.read = device_read,.write = device_write,.open = device_open,.release = device_release }; vi /usr/src/linux-2.6.5-1.358/include/linux/fs.h int register_chrdev(unsigned int major, const char *name, struct file_operations *fops); int unregister_chrdev(unsigned int major, const char *name);

12. #include #define DEVICE_NAME "chardev" #define BUF_LEN 80 static int Major; static char msg[BUF_LEN]; static char *msg_Ptr;

13. static int device_open(struct inode *inode, struct file *file) { static int counter = 0; sprintf(msg, "This device is opened %d times!\n", counter++); msg_Ptr = msg; try_module_get(THIS_MODULE); return 0; } static int device_release(struct inode *inode, struct file *file) { module_put(THIS_MODULE); return 0; }

14. We cannot remove the device driver while device file is opened by a process. There's a counter which keeps track of how many processes are using your module –the 3 rd column in lsmod try_module_get(THIS_MODULE); –Increment the use count module_put(THIS_MODULE); –Decrement the use count

15. static ssize_t device_read(struct file *filp, char *buffer, size_t length, loff_t * offset) { int bytes_read = 0; if (*msg_Ptr == 0) return 0; while (length && *msg_Ptr) { put_user(*(msg_Ptr++), buffer++); length--; bytes_read++; } return bytes_read; }

16. put_user(char src, char* dst); –src is in kernel code segment –dst is in user code segment get_user(char dst, char* src); –src is in user code segment –dst is in kernel code segment A pointer into userspace should never be simply dereferenced #include buffer is in user data segment length: length of the buffer

17. static ssize_t device_write(struct file *filp, const char *buff, size_t len, loff_t * off) { printk(" This operation isn't supported.\n"); return -EINVAL; }

18. static struct file_operations fops = {.read = device_read,.write = device_write,.open = device_open,.release = device_release };

19. int init_module(void) { Major = register_chrdev(0, DEVICE_NAME, &fops); if (Major < 0) { printk("Failed to register char device.\n"); return Major; } printk(KERN_ALERT "chardev is assigned to major number %d.\n", Major); return 0; } void cleanup_module(void) { int ret = unregister_chrdev(Major, DEVICE_NAME); if (ret < 0) printk("Error in unregister_chrdev: %d\n", ret); }

20. mknod Create a file in /dev And match the file with a device driver mknod /dev/hello c Major 0 –This Major number is from the output of /var/log/messages

21. References Linux Device Drivers, 2nd Edition –http://www.xml.com/ldd/chapter/book/index.htmlhttp://www.xml.com/ldd/chapter/book/index.html The Linux Kernel Module Programming Guide –http://tldp.org/LDP/lkmpg/2.6/html/http://tldp.org/LDP/lkmpg/2.6/html/