Creating proc read and write entry (linux kernel 4.6)

In the post "Creating a read write proc entry in kernel versions above 3.10" we saw how to create a read and write proc entry in the kernel version 3.10 and above. There is a slight modification to creation of proc entries, and here is a code that has been tested in 4.6.

We can create a proc entry using the function

static inline struct proc_dir_entry *proc_create(const char *name, umode_t mode,struct proc_dir_entry *parent, const struct file_operations *proc_fops)

Where:

name: The name of the proc entry
mode: The access mode for proc entry
parent: The name of the parent directory under /proc
proc_fops: The structure in which the file operations for the proc entry will be created.

For example to create a proc entry by the name "hello" under /proc the above function will be defined are

For example to create a proc entry by the name "hello_write" under /proc the above function will be defined are

proc_create("hello_write",0,NULL,&proc_fops);

Now we need to create file_operations structure proc_fops in which we can map the read and write functions for the proc entry.

struct file_operations proc_fops = { read: read_proc write: write_proc };

Next we need to add the functions read_proc and write_proc which will give write data to the proc entry and then read data from the proc entry.

The write function will recieve data from the user space using the function copy_from_user into a char pointer "msg".

copy_from_user(msg,buf,count);

Thus the write function will look as below.

int write_proc(struct file *filp,const char *buf,size_t count,loff_t *offp) { copy_from_user(msg,buf,count); printk(KERN_INFO "In write"); len=count; temp=len; return count; }

Once data is written to the proc entry we can read from the proc entry using a read function, i.e tranfer data to the user space using the function copy_to_user function.

The read function can be as below.

int read_proc(struct file *filp,char *buf,size_t count,loff_t *offp ) { if(count>temp) { count=temp; } temp=temp-count; copy_to_user(buf,msg, count); if(count==0) temp=len; return count; }

The creation of proc entry and the intialization of the msg pointer can be done in a function create_new_proc_entry.

void create_new_proc_entry(void) { proc_create("temp1",0,NULL,&proc_fops); msg=kmalloc(10*sizeof(char),GFP_KERNEL); //Use of GFP_KERNEL flag after size is the biggest // change as compared to older verstions }

The create_new_proc_entry will be called in the init function.

int proc_init (void) { create_new_proc_entry(); return 0; }

The proc entry that was created will be removed in the exit function using remove_proc_entry.

void proc_cleanup(void) { remove_proc_entry("temp1",NULL); }

Thus the full code for creating a write proc entry looks as below.

proc_rw.c

#include <linux/module.h> #include <linux/kernel.h> #include <linux/proc_fs.h> #include<linux/sched.h> #include <asm/uaccess.h> #include <linux/slab.h> int len,temp; char *msg; int read_proc(struct file *filp,char *buf,size_t count,loff_t *offp ) { if(count>temp) { count=temp; } temp=temp-count; copy_to_user(buf,msg, count); if(count==0) temp=len; return count; } int write_proc(struct file *filp,const char *buf,size_t count,loff_t *offp) { copy_from_user(msg,buf,count); len=count; temp=len; return count; } struct file_operations proc_fops = { read: read_proc, write: write_proc }; void create_new_proc_entry(void) //use of void for no arguments is compulsory now { proc_create("hello",0,NULL,&proc_fops); msg=kmalloc(10*sizeof(char).GFP_KERNEL); } int proc_init (void) { create_new_proc_entry(); return 0; } void proc_cleanup(void) { remove_proc_entry("hello",NULL); kfree(msg); } MODULE_LICENSE("GPL"); module_init(proc_init); module_exit(proc_cleanup);

The makefile for the compilation of the modules are

ifneq ($(KERNELRELEASE),) obj-m := proc_rw.o else #KERNELDIR ?= /lib/modules/$(shell uname -r)/build KERNELDIR ?= /home/nitin/Desktop/src/linux-3.11.1/ PWD := $(shell pwd) default: $(MAKE) -C $(KERNELDIR) M=$(PWD) modules endif clean: $(MAKE) -C $(KERNELDIR) M=$(PWD) clean

Compile and load the module using

$ make $ sudo insmod proc_rw.ko

To test the proc entry let us first write data into the entry $ echo "hello" > /proc/hello

Now we can read the data back

$ cat /proc/hello hello

We can see that the message that we wrote into the proc entry, the same data is being displayed when it is read. The data will remain as long as it is not overwritten by new data.