Implementing stack using the list functions in kernel -2

In the post "Implementing stack using the list fuctions in kernel" we saw how to create a stack entry using the in built list functions of the kernel. Some of the operations that we did while creating the stack can further be automated using some more list functions of the kernel.

We had used a variable "tail" to keep track of the last element of the stack, which was being updated in the push_stack function after every write to the stack. This is not really needed is we use the function list_last_entry.

list_last_entry(ptr, type, member)

ptr: Pointer to the head node of the list. type: type of structure of which the head is member of member: The name of the head node in the structure.

For our example, we can use list_last_entry as below.

list_last_entry(head,struct k_list,test_list); list_last_entry automatically returns the last node of the list and there is no need to keep track of the tail node.

Thus the push function can be modified as below.

int push_stack(struct file *filp,const char *buf,size_t count,loff_t *offp) { msg=kmalloc(10*sizeof(char),GFP_KERNEL); temp=copy_from_user(msg,buf,count); node=kmalloc(sizeof(struct k_list *),GFP_KERNEL); node->data=msg; if(list_empty(head)) { list_add(&node->test_list,head); } else{ tail=list_last_entry(head,struct k_list,test_list); list_add(&node->test_list,tail); } return count; }

In the pop_stack function, the check for stack being empty was being performed by comparing the tail with the head pointer. This can be easily by using the function list_empty, which returns true is the list is empty

int list_empty(const struct list_head *head)

head: Pointer to the head node of the list which is being tested.

list_last_entry can also be used in the pop_stack function to read out the last element of the stack.

Thus the modified pop_stack will look as below.

int pop_stack(struct file *filp,char *buf,size_t count,loff_t *offp ) { if(list_empty(head) ){ msg=empty; if(flag==1) { ret=emp_len; flag=0; } else if(flag==0){ ret=0; flag=1; } temp=copy_to_user(buf,msg, count); printk(KERN_INFO "\nStack empty\n"); return ret; } if(new_node == 1) { node=list_last_entry(head,struct k_list ,test_list); msg=node->data; ret=strlen(msg); new_node=0; } if(count>ret) { count=ret; } ret=ret-count; temp=copy_to_user(buf,msg, count); printk(KERN_INFO "\n data = %s \n" ,msg); if(count==0) { list_del(&node->test_list); new_node=1; } return count; }

The complete modified code for stack being

stack_list.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>#include <uapi/linux/string.h> int len,temp,cnt,i=0,ret; char *empty="Stack Empty \n"; int emp_len,flag=1; struct k_list { struct list_head test_list; char *data; }; static struct k_list *node; struct list_head *tail,*head; struct list_head test_head; int new_node=1; char *msg; int pop_stack(struct file *filp,char *buf,size_t count,loff_t *offp ) { if(list_empty(head) ){ msg=empty; if(flag==1) { ret=emp_len; flag=0; } else if(flag==0){ ret=0; flag=1; } temp=copy_to_user(buf,msg, count); printk(KERN_INFO "\nStack empty\n"); return ret; } if(new_node == 1) { node=list_last_entry(head,struct k_list ,test_list); msg=node->data; ret=strlen(msg); new_node=0; } if(count>ret) { count=ret; } ret=ret-count; temp=copy_to_user(buf,msg, count); printk(KERN_INFO "\n data = %s \n" ,msg); if(count==0) { list_del(&node->test_list); new_node=1; } return count; } int push_stack(struct file *filp,const char *buf,size_t count,loff_t *offp) { msg=kmalloc(10*sizeof(char),GFP_KERNEL); temp=copy_from_user(msg,buf,count); node=kmalloc(sizeof(struct k_list *),GFP_KERNEL); node->data=msg; if(list_empty(head)) { list_add(&node->test_list,head); } else{ tail=list_last_entry(head,struct k_list,test_list); list_add(&node->test_list,tail); } return count; } struct file_operations proc_fops = { read: pop_stack, write: push_stack }; void create_new_proc_entry(void) { proc_create("stack",0,NULL,&proc_fops); } int stack_init (void) { create_new_proc_entry(); head=kmalloc(sizeof(struct list_head *),GFP_KERNEL); INIT_LIST_HEAD(head); tail=head; emp_len=strlen(empty); return 0; } void stack_cleanup(void) { remove_proc_entry("stack",NULL); } MODULE_LICENSE("GPL"); module_init(stack_init); module_exit(stack_cleanup);

To compile the module use the make file.

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

Compile and insert the module into the kernel

$ make $ insmod stack_list.ko

To see the output

$ echo "1" > /proc/stack $ echo "2" > /proc/stack $ echo "3" > /proc/stack $ echo "4" > /proc/stack

Thus we have written the 1,2,3,4 as data into 4 nodes with 4 being inserted last. Now to pop data out of the stack

$ cat /proc/stack 4 $ cat /proc/stack 3 $ cat /proc/stack 2 $ cat /proc/stack 1 $ cat /proc/stack Stack Empty

Thus we can see that the proc entry is operating as a stack.
Related posts

Implementing stack using the list functions in kernel
Creating a read write proc entry in kernel versions above 3.10
Pointer to structure from its member pointer: container_of