How to Implement the Read File Operation Method in a Linux Device Driver

In this article, we show how to implement the read file operation method in a linux device driver.

So the read file operation method originates from the read user system call.

The read file operation method reads data from the kernel space and transfers this data to the user space.

In our example in this code, our character device represents a memory array, which is a contiguous memory location. It can be seen as a device memory buffer.

So when a read user system call is issued to the device file, we transfer data from our device memory buffer to the user buffer (which is the memory of the process address space).

The read method implementation is done by taking our read file operation method and carrying out a few steps.

The general format for the read file operation method is shown below.


ssize_t pcd_read(struct file *filp, char __user *buff, size_t count, loff_t *f_pos) { }

One of the first things that we have to do is check the user request 'count' value against the memory size of the device.

In our example, we are dealing with a memory array that is 512 bytes.

This means that there can only be 512 bytes read. This goes from a starting position of 0 for the first byte and 511 for the last byte.

The file position represents the 'cursor', where the read file operation will start from.

If the file position plus the count is greater than the device memory size, then we have to readjust the count. To set the count to 0, we readjust the count to the memory size of the device - the file position. This ensures that we read the file from the beginning.

Next, we copy the 'count' number of bytes from the device memory to the user buffer. This is done using the copy_to_user() function. We will go over the parameters of this function later.

Next, we update the file position, meaning we set it manually to where it is now that has copied the 'count' number of bytes.

Then, we return the number of bytes successfully read or an error code if there is some type of error in the process.

If the file position is at the end of the file, we simply return 0.

And this would be our read file operation method to read from a device.

The general format for the copy_to_user() function is shown below.


unsigned long copy_to_user(void __user *to, const void *from, unsigned long n) { }

So the copy_to_user() function takes in 3 parameters.

The first parameter is the destination address, which is the address of the user buffer in the user space. After all, the user is reading the data from the device. So the destination must be the user buffer. So the *to is the pointer to the user buffer.

The second parameter is the source address, which is the address of the device memory buffer in the kernel space. The read file operation reads data from the device memory buffer in the kernel space to the user buffer.

The third parameter, n, is the number of bytes that is to be read.

This function returns 0 on success or the number of bytes that could not be copied. Therefore, we must implement an if statement to check what is returned. If there is a return value other than 0, this means that there is an error. We return the error of -EFAULT.

So let's now go through the complete code of this read file operation, which is shown below.


ssize_t pcd_read(struct file *filp, char __user *buff, size_t count, loff_t *f_pos) { pr_info("Read requested for %zu bytes \n", count); pr_info("Current file position = %lld\n", *f_pos); /* Adjust the count */ if((*f_pos + count) > DEV_MEM_SIZE) count= DEV_MEM_SIZE - *f_pos; /*copy to user */ if(copy_to_user(buff,&device_buffer[*f_pos],count)) { return -EFAULT; } /* update the current file position */ *f_pos += count; pr_info("Number of bytes successfully read= %zu\n", count); pr_info("Updated file position= %lld\n", *f_pos); /* Return the number of bytes which have been successfully read */ return count; }

So let's now go through this code.

So we have our read method, which is called pcd_read(). You can call this function anything appropriate for your device.

The input parameters to this function is standard.

*filp is a pointer to the file that we are reading.

*buff is a pointer to the user buffer, which reads in the data from the device memory from the kernel space.

count is the number of bytes that we want to read.

*f_pos is a pointer to the file position of the cursor.

So the pr_info statements are optional. You can put them in your code for debugging purposes.

So the first thing we do in our code is have an if statement that checks the position of the file cursor. If the value is greater than DEV_MEM_SIZE, then we set the value equal to, count= DEV_MEM_SIZE - *f_pos;

We then use the copy_to_user() function to read data from the device.

buff is where the data is read to.

count is how many bytes are to be read.

If the value is greater than 0, we return an error.

We then update the current file position using the statement, *f_pos += count;

We then return count, which will show how many bytes were read.

The full entire code for this project is shown below.


#include<linux/module.h> #include<linux/fs.h> #include<linux/cdev.h> #include<linux/device.h> #include<linux/kdev_t.h> #include<linux/uaccess.h> #undef pr_fmt #define pr_fmt(fmt) "%s :" fmt,__func__ #define DEV_MEM_SIZE 512 char device_buffer[DEV_MEM_SIZE]; //this holds the device number dev_t device_number; //Cdev variable struct cdev pcd_cdev; //File operation methods loff_t pcd_lseek(struct file *filp, loff_t off, int whence) { pr_info("llseek requested \n"); return 0; } ssize_t pcd_read(struct file *filp, char __user *buff, size_t count, loff_t *f_pos) { pr_info("Read requested for %zu bytes \n", count); pr_info("Current file position = %lld\n", *f_pos); /* Adjust the count */ if((*f_pos + count) > DEV_MEM_SIZE) count= DEV_MEM_SIZE - *f_pos; /*copy to user */ if(copy_to_user(buff,&device_buffer[*f_pos],count)) { return -EFAULT; } /* update the current file position */ *f_pos += count; pr_info("Number of bytes successfully read= %zu\n", count); pr_info("Updated file position= %lld\n", *f_pos); /* Return the number of bytes which have been successfully read */ return count; } ssize_t pcd_write(struct file *filp, const char __user *buff, size_t count, loff_t *f_pos) { pr_info("write requested for %zu bytes\n", count); return 0; } int pcd_open(struct inode *inode, struct file *filp) { pr_info("Open was successful\n"); return 0; } int pcd_release(struct inode *inode, struct file *filp) { pr_info("Close was successful\n"); return 0; } //file operations of the driver struct file_operations pcd_fops = { .open= pcd_open, .write= pcd_write, .read= pcd_read, .llseek= pcd_llseek, .release= pcd_release, .owner= THIS_MODULE }; struct class *class_pcd; struct device *device_pcd; static int __init pcd_driver_init(void) { //Dynamically allocate a device number alloc_chrdev_region(&device_number, 0,1,"pcd_devices"); pr_info("Device number <major>:<minor>= %d:%d\n", MAJOR(device_number),MINOR(device_number)); //Initialize the cdev structure with fops cdev_init(&pcd_cdev,&pcd_fops); pcd_cdev.owner= THIS_MODULE; //Register a device (cdev structure) with VFS cdev_add(&pcd_cdev,device_number,1); //Create device class under /sys/class class_pcd= class_create(THIS_MODULE,"pcd_class"); //Populate the sysfs with device information device_pcd= device_create(class_pcd, NULL, device_number, NULL,"pcd"); pr_info("Module init was successful\n"); return 0; } static void __exit pcd_driver_cleanup(void) { device_destroy(class_pcd, device_number); class_destroy(class_pcd); cdev_del(&pcd_cdev); unregister_chrdev_region(device_number,1); pr_info("module unloaded\n"); } module_init(pcd_driver_init); module_exit(pcd_driver_cleanup); MODULE_LICENSE("GPL"); MODULE_AUTHOR("David Hylton"); MODULE_DESCRIPTION("A pseudo character driver");

So when you build this code, you should see that you do not get any errors, such as that shown below.

Once you have this, you can test this read method out.

So this is how to implement the read file operation method in a linux device driver.

Related Resources