Writing an Example Driver From Scratch: Chapter -4 Inserting into the kernel

Here is the full code of the driver that we have pieced together in the previous three chapters

Note: The code has been tested and found working on version 3.5.4

#include <linux/module.h> #include <linux/kernel.h> #include <linux/fs.h> // required for various structures related to files liked fops. #include <asm/uaccess.h> // required for copy_from and copy_to user functions #include <linux/semaphore.h> #include <linux/cdev.h> static int Major; dev_t dev_no,dev; struct device { char array[100]; struct semaphore sem; }char_arr; int open(struct inode *inode, struct file *filp) { printk(KERN_INFO "Inside open \n"); if(down_interruptible(&char_arr.sem)) { printk(KERN_INFO " could not hold semaphore"); return -1; } return 0; } int release(struct inode *inode, struct file *filp) { printk (KERN_INFO "Inside close \n"); printk(KERN_INFO "Releasing semaphore"); up(&char_arr.sem); return 0; } ssize_t read(struct file *filp, char *buff, size_t count, loff_t *offp) { unsigned long ret; printk("Inside read \n"); ret = copy_to_user(buff, char_arr.array, count); return ret; } ssize_t write(struct file *filp, const char *buff, size_t count, loff_t *offp) { unsigned long ret; printk(KERN_INFO "Inside write \n"); ret = copy_from_user(char_arr.array, buff, count); return count; } struct file_operations fops = { read: read, write: write, open: open, release: release }; struct cdev *kernel_cdev; int char_arr_init (void) { int ret; kernel_cdev = cdev_alloc(); kernel_cdev->ops = &fops; kernel_cdev->owner = THIS_MODULE; printk (" Inside init module\n"); ret = alloc_chrdev_region( &dev_no , 0, 1,"chr_arr_dev"); if (ret < 0) { printk("Major number allocation is failed\n"); return ret; } Major = MAJOR(dev_no); dev = MKDEV(Major,0); sema_init(&char_arr.sem,1); printk (" The major number for your device is %d\n", Major); ret = cdev_add( kernel_cdev,dev,1); if(ret < 0 ) { printk(KERN_INFO "Unable to allocate cdev"); return ret; } return 0; } void char_arr_cleanup(void) { printk(KERN_INFO " Inside cleanup_module\n"); cdev_del(kernel_cdev); unregister_chrdev_region(Major, 1); } MODULE_LICENSE("GPL"); module_init(char_arr_init); module_exit(char_arr_cleanup);

The above code being a kernel module, it needs a Makefile for compilation.

Makefile:

ifneq ($(KERNELRELEASE),) obj-m := char_arr_dev.o else KERNELDIR ?= /lib/modules/$(shell uname -r)/build PWD := $(shell pwd) default: $(MAKE) -C $(KERNELDIR) M=$(PWD) modules endif

Note: The above makefile is taken from the Device Drivers book from Alessandro Rubini .

The make file checks if the KERNELRELEASE is set, because we need to know the location where the kernel Makefile is located, as it is that Makefile which we will use to compile our code.

If the KERNELRELEASE is not set then we set the KERNELDIR to the default location of the kernel tree, where we will find the Makefile.

After setting this we call make in the script, but this time we pass the "-c" option to indicate where the kernel makefile is located. The "M" option tells the make file where is the source code of the module that we want to compile into a kernel module. In our case the source code is present in the same folder so we pass value of present working directory.

Note that the name of the object code against "obj-m" in the makefile should be the name of your "c" file for the module, just replace the ".c" with ".o" .

Once you have created the file save it as Makefile (Note the capital "M"), in the same folder where your module is stored.

Open a terminal, and go to the file where you have the module and the Makefile, run the command

make

If the command does not throw any errors, then your code has been compiled successfully. Run "ls" and see that you should have a file by same name as your "c" code only with the ".ko" as the extension.

To insert the module into the kernel we will use the command "insmod", you will need superuser privileges to run the command.

sudo insmod char_arr_dev.ko

If there are no errors your module is a part of the kernel now, as we have added a "printk" to print the major number in our init function, run the command "dmesg" and you will find the line printed, with the major number, for eg :

The major number for your device is 251

Make a note of the number, we will need it again.

Once we have inserted the module, we need to have a device which will use the driver or the module. So we can create an entry like a device in /dev using the command "mknod"

Run the command

mknod /dev/"your device name" c "major number" "minor number"

eg:

mknod /dev/char_arr c 251 0

If there are no errors we have a device ready that we can talk to using our driver.

NOTE: This code will not work with command "cat" , please use the application code in the next chapter. The updated code which will work with "cat" will be the chapter-6.

Next Chapter

User Access