Writing an example driver from scratch : Chapter -6

In the previous five chapters we walked through the steps of writing an simple charcater driver and for a virtual device and accessing it from the user space.

The limitation of driver written was it could not read using cat command . This was because the return value of the read function was not appropriate for the cat function.

The cat command continues to read from a file unless it is not informed that there is no further data to be read from the file, which is done by returning 0 when the end of file is reached.

To do this in our read function we have to keep count of the number of bytes that are written into the device. Hence we add a variable "written" into the write function which gets updated when data is written in to the device as follows

written = written + count ;

This value of written is assigned to another variable "read" every time device is opened. When the read function is called the variable "read" is compared with the variable "count", which indicates the number of bytes that the userspace wants to read. In case the count value is more than read, then we have to decrease the value of count to the amount of data present in the device i.e

if ( count > read)
count = read

And on every pass through the read function we keep decreasing the value of read by the count number of bytes that are read, and return the value of read.

Thus when end of file is reached the value of read becomes zero which when returned to cat, it would stop reading from the file.

Here is the drive code with the modified read and write functions. The steps to compile and insert the device are the same as in chapter-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; static int written,read; 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; } read = written; 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_char(struct file *filp, char *buff, size_t count, loff_t *offp) { unsigned long ret; printk("Inside read \n"); if(count > read) count = read; read = read -count; ret = copy_to_user(buff, char_arr.array, count); return count; } ssize_t write_char(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); written += count; return count; } struct file_operations fops = { owner: THIS_MODULE, read: read_char, write: write_char, open: open, release: release }; struct cdev *kernel_cdev; int char_arr_init (void) { int ret; dev_t dev_no,dev; 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,"char_arr_dev"); if (ret < 0) { printk("Major number allocation is failed\n"); return ret; } Major = MAJOR(dev_no); printk (KERN_INFO" The major number for your device is %d\n", Major); init_MUTEX(&char_arr.sem); ret = cdev_add( kernel_cdev,dev_no,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);

Assuming we have created a device by the name /dev/temp, we can communicate with the device as follows

$ echo "hi" > /dev/temp
$ cat /dev/temp
hi

Or we can use the user application code as show in chapter-5