Linux World: June 2014

Creating checkerboard image using gimp

Here is how we can create a checker board background or an image of checker board using gimp. Launch gimp and create a new image by selecting file->new.

Select the size of the image that is reqiured. In this post we will use the sizw 640X480.

Once the new blank image is created, select the menu Tools->GEGL operation

In the pull down menu for operations select the option checkerborard.

The follwing menu should appear.

Width: Width of the boxes

Height: Height of the boxes

X offset:Defines from where does the boxes start from at the left margin

Y offset: Defines from whese does the boxes start from at the bottom.

Color,Other color: These can be used to set the colors for the boxes

Click on OK to create a checkerboard image, which we can export as an image or use it as a background for other layers.

Final image:

Using list_del to remove a node from a linked list

In the post " " we saw how to create as linked list using the built in functions of linux. Now let us see how we can delte the nodes of the linked list.

The deltetion of nodes in a linked list has to be done carefully to make sure that even after the deletion of a node the list retains its structure. That is no matter from which position the node is deleted, the head, the tail or in between, the link between the remaining nodes should be retained.

If we delete the node at the head, then the node to which it was pointing to becomes the new head. If we delete the node from the tail, then the node to before it becomes the tail and if we delete the node from in between, the node previous to the delted node should be made to point to the node to which the deleted node was pointing to, making sure that the link between the nodes are maintained.

The kernel developers have made the above process very easy for us by providing the function

void list_del(struct list_head *entry);

entry is the pointer to the node which we want to delete.

We need not be bothered whether it is the head,tail or in between the kernel takes function takes care of it.

Let us take the code that we used to create the list in the post "Creating a linked list"

In the init part of the module we have create three nodes in the linked list. Now let us add the deletion of nodes to the same init function, and print the linked list after every deletion.

For example to delete the "one" we need to call the function

list_del(&one->test_list);

and after every deletion we will iterate over the list using list_for_each

delete_list.c

#include<linux/kernel.h>
#include<linux/module.h>
#include<linux/list.h>
#include<linux/slab.h>

struct k_list {
struct list_head test_list;
int temp;
};


int create_list_init(void) {

struct k_list *one,*two,*three,*entry;
struct list_head test_head;
struct list_head *ptr;

one=kmalloc(sizeof(struct k_list *),GFP_KERNEL);
two=kmalloc(sizeof(struct k_list *),GFP_KERNEL);
three=kmalloc(sizeof(struct k_list *),GFP_KERNEL);

one->temp=10;
two->temp=20;
three->temp=30;

INIT_LIST_HEAD(&test_head);

//Creation of linked list 

list_add(&one->test_list,&test_head);
list_add(&two->test_list,&test_head);
list_add(&three->test_list,&test_head);
list_for_each(ptr,&test_head){
entry=list_entry(ptr,struct k_list,test_list);


printk(KERN_INFO "\n Hello %d  \n \n", entry->temp);

}
//Deletion of  nodes 
printk(KERN_INFO "\n Deleting first entry \n");

list_del(&one->test_list);

list_for_each(ptr,&test_head){
entry=list_entry(ptr,struct k_list,test_list);


printk(KERN_INFO "\n Hello %d  \n \n", entry->temp);

}


printk(KERN_INFO "\n Deleting second entry \n");
list_del(&two->test_list);

list_for_each(ptr,&test_head){
entry=list_entry(ptr,struct k_list,test_list);


printk(KERN_INFO "\n Hello %d  \n \n", entry->temp);

}


printk(KERN_INFO "\n Deleting third entry \n");
list_del(&three->test_list);

list_for_each(ptr,&test_head){
entry=list_entry(ptr,struct k_list,test_list);


printk(KERN_INFO "\n Hello %d  \n \n", entry->temp);

}

return 0;

}

int create_list_exit(void) {
return 0 ;
}

module_init(create_list_init);
module_exit(create_list_exit);

To compile the module use the make file.

ifneq ($(KERNELRELEASE),) 
   obj-m := delete_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 delete_list.ko

To see the output use the command demsg

$ dmesg
[45120.660527]  Hello 30  
[45120.660527]  
[45120.660535] 
[45120.660535]  Hello 20  
[45120.660535]  
[45120.660539] 
[45120.660539]  Hello 10  
[45120.660539]  
[45120.660543] 
[45120.660543]  Deleting first entry 
[45120.660545] 
[45120.660545]  Hello 30  
[45120.660545]  
[45120.660549] 
[45120.660549]  Hello 20  
[45120.660549]  
[45120.660552] 
[45120.660552]  Deleting second entry 
[45120.660555] 
[45120.660555]  Hello 30  
[45120.660555]  
[45120.660558] 
[45120.660558]  Deleting third entry

In the above output the first three lines are creation of the linked list. Then after deleting each node we iterated through the list and see the that each call to list_de deletes one node from the linked list.

Teminating a kernel thread using kthread_stop

In the post "Kernel thread creation 1 " we saw how to create a kthread in linux using kthread_create. The function we used to stop the thread was kthread_stop.

But kthread_stop does not terminate the thread by itself, it waits for the thread to call do_exit or terminate itself. kthread_stop only makes sure that if the thread calls the function kthread_should_stop, then kthread_should_stop returns true.

So just by calling kthread_stop in the cleanup function we can not trerminte a thread in between unless the thread does not exit by itself. To be able to terminate a thread in between, i.e. as soon as kthread_stop is called, we need to make sure that thread keeps checking for the function kthread_should_stop.

If kthread_should_stop returns true, which happens when kthread_stop is called on the thread, then the thread should exit by calling the do_exit.

Taking the same example as in the post "Kernel thread creation 1" , we need to add the following lines of code to the thread function

if(kthread_should_stop()) {
do_exit(0);
}

Thus the thread function would look like

int thread_fn(void) {

unsigned long j0,j1;
int delay = 60*HZ;
j0 = jiffies;
j1 = j0 + delay;

while (time_before(jiffies, j1)){ 
if(kthread_should_stop()) {
do_exit(0);
}
  schedule();
}
printk(KERN_INFO "In thread1");
return 0;
}

Thus the full code for a creating a kernel thread which will terminate on call to kthread_stop would be

kthread_terminate.c

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/kthread.h>  // for threads
#include <linux/time.h>
#include <linux/timer.h>


static struct task_struct *thread1;


int thread_fn(void) {

unsigned long j0,j1;
int delay = 60*HZ;
j0 = jiffies;
j1 = j0 + delay;

while (time_before(jiffies, j1)){ 
if(kthread_should_stop()) {
do_exit(0);
}
  schedule();
}
printk(KERN_INFO "In thread1");
return 0;
}

int thread_init (void) {
 
 char name[8]="thread1";
 printk(KERN_INFO "in init");
 thread1 = kthread_create(thread_fn,NULL,name);
 if((thread1))
  {
  printk(KERN_INFO "in if");
  wake_up_process(thread1);
  }

 return 0;
}



void thread_cleanup(void) {
 int ret;
 ret = kthread_stop(thread1);
 if(!ret)
  printk(KERN_INFO "Thread stopped");

}
MODULE_LICENSE("GPL"); 
module_init(thread_init);
module_exit(thread_cleanup);

The makefile for the module would be

ifneq ($(KERNELRELEASE),) 
 obj-m := kthread_terminate.o
else 

KERNELDIR ?= /lib/modules/$(shell uname -r)/build 


PWD := $(shell pwd)

default: 
 $(MAKE) -C $(KERNELDIR) M=$(PWD) modules
endif 
clean:
 $(MAKE) -C $(KERNELDIR) M=$(PWD) clean

compile the module and insert it

$ make 
$ sudo insmod kthread_terminate.ko

To see if the therad has been created we can use the command ps

$ ps -ef | grep thread 
root         2     0  0 16:44 ?        00:00:00 [kthreadd]
root     14728     2 99 21:23 ?        00:00:13 [thread1]
root     14733  8932  0 21:23 pts/2    00:00:00 grep thread

Now if we remove the module, the thread should get terminated immediately and module removal should not wait for the thread to complete as was the case in the module where kthread_should_stop was not used in the thread function.

$ rmmmod kthread_terminate

Pages

Creating checkerboard image using gimp

Using list_del to remove a node from a linked list

Teminating a kernel thread using kthread_stop