link list and wait queue

-  test2.c (/usr/src/linux-2.6.23/joseph)
|-   struct                  
||     _mydrv_wq             
||     _mydrv_work           
|                            
|-   variable                
||     mydrv_wq              
||     mydrv_work            
||     hello_init            
||     hello_exit            
|                            
|-   function                
||     my_task       // Test task         
||     mydrv_submit_task   //Testing kernel thread used to submmit two task to worker thread and then exit   
||     mydrv_worker        //  The worker thread
||     submit_work         //  Submitting Work to be executed
||     mydrv_init          // init mydrv_wq and mydrv_work
||     hello_init            
||     hello_exit

------------------------------------------------------------------------------------------------------------------------------------------

Introduction:
    In this experiment, I will show you how to use list and wait queue.
we create two kernel thread. One is mydrv_worker which is our worker thread used to handle the submitted tasks
in mydrv_wq.mydrv_worklist. When there is no task to handle, it will add itself to wait queue. It will be wake
up by submit_work when new tasks are added to work list. The other is mydrv_submit_task used to submit two tasks
 and then exit. When we execute ' kill -s 9 thread_id_of_mydrv_worker' mydrv_worker will exit.

source code:

 

#include <linux/init.h> #include <linux/module.h> #include <linux/sched.h> #include <linux/kthread.h> #include <linux/sysctl.h> MODULE_LICENSE("Dual BSD/GPL"); static struct _mydrv_wq { struct list_head mydrv_worklist; // Work List spinlock_t lock; //Protect the list wait_queue_head_t todo; // Synchronize submitter and worker } mydrv_wq; struct _mydrv_work { struct list_head mydrv_workitem; //work chain void (*worker_func)(void *); // Work to perform void *worker_data; // Argument to worker_func } mydrv_work; int submit_work(void (*func)(void *data), void *data); /* Test task */ void my_task(void* data) { printk("%s is called the %d time(s)/n", __func__, (int)data); } /* Testing kernel thread used to submmit two task to worker thread and then exit */ static int mydrv_submit_task(void* unused) { daemonize("submit_task"); submit_work(my_task, (void*)1); submit_work(my_task, (void*)2); printk("%s exit/n", __func__); return 0; } /* The worker thread */ static int mydrv_worker (void* unused) { DECLARE_WAITQUEUE(wait, current); void (*worker_func)(void*); void* worker_data; struct _mydrv_work *mydrv_work; int asked_to_die = 0; // flag used to indicating thread is asked to die daemonize("mydrv_worker"); set_current_state(TASK_INTERRUPTIBLE); // Request delivery of SIGKILL allow_signal(SIGKILL); // Spin until asked to die while (!asked_to_die) { add_wait_queue(&mydrv_wq.todo, &wait); if (list_empty(&mydrv_wq.mydrv_worklist)) { printk("%s go to sleep /n", __func__); schedule(); //woken up by the submitter } else { set_current_state(TASK_RUNNING); } remove_wait_queue(&mydrv_wq.todo, &wait); // Protect concurrent access to the list spin_lock(&mydrv_wq.lock); /* Traverse the list and plough through the work functions present in each node */ while (!list_empty(&mydrv_wq.mydrv_worklist)){ // Get the first entry in the list mydrv_work = list_entry (mydrv_wq.mydrv_worklist.next, struct _mydrv_work, mydrv_workitem); worker_func = mydrv_work->worker_func; worker_data = mydrv_work->worker_data; // Throw the processed node out of the list list_del(mydrv_wq.mydrv_worklist.next); kfree(mydrv_work); // free the node // Execute the work function in this node spin_unlock(&mydrv_wq.lock); // release lock worker_func(worker_data); spin_lock(&mydrv_wq.lock); // re-acquire lock } spin_unlock(&mydrv_wq.lock); set_current_state(TASK_INTERRUPTIBLE); if (signal_pending(current)) asked_to_die = 1; // Die if I receive SIGKILL } printk("%s exit/n", __func__); set_current_state(TASK_RUNNING); return 0; } /*Submitting Work to be executed*/ int submit_work(void (*func)(void *data), void *data) { struct _mydrv_work *mydrv_work; // Allocate the work structure mydrv_work = kmalloc(sizeof(struct _mydrv_work), GFP_ATOMIC); if (!mydrv_work) { printk("memory allocated error in %s", __func__); return -1; } //Populate teh work structure mydrv_work->worker_func = func; // work function mydrv_work->worker_data = data; // Argument to pass printk("submit_work get lock/n");//for test spin_lock(&mydrv_wq.lock);// Protect the list // Add your work to the tail of the list list_add_tail(&mydrv_work->mydrv_workitem, &mydrv_wq.mydrv_worklist); // Wake up the worker thread wake_up(&mydrv_wq.todo); spin_unlock(&mydrv_wq.lock); printk("submit_work release lock/n");//for test return 0; } static int __init mydrv_init(void) { // Initialize the lock to protect against concurrent list access spin_lock_init(&mydrv_wq.lock); // Initialize the wait queue for communication between the submitter and the worker init_waitqueue_head(&mydrv_wq.todo); // Initialize the list head INIT_LIST_HEAD(&mydrv_wq.mydrv_worklist); //start the worker thread kernel_thread(mydrv_worker, NULL, CLONE_FS | CLONE_FILES | CLONE_SIGHAND | SIGCHLD); return 0; } static int hello_init(void) { printk("Hello, I am a test module/n"); mydrv_init(); printk("Create mydrv_submit_task <---------<<<<<<<</n"); kernel_thread(mydrv_submit_task, NULL, CLONE_FS | CLONE_FILES | CLONE_SIGHAND | SIGCHLD); return 0; } static void hello_exit(void) { printk("Bye, my dear!/n Cruel world/n"); } module_init(hello_init); module_exit(hello_exit);

 

steps:
    1. compile
        # make -C /path/to/your/kernel/tree -M `pwd' modules
    2. #echo "" > /var/log/messages
    3. insmod test2.ko
    4. cat /var/log/messages
        May 13 02:27:11 joseph kernel: [160219.386631] Hello, I am a test module
        May 13 02:27:11 joseph kernel: [160219.386843] mydrv_worker go to sleep
        May 13 02:27:11 joseph kernel: [160219.386932] Create mydrv_submit_task <---------<<<<<<<<
        May 13 02:27:11 joseph kernel: [160219.387016] submit_work get lock
        May 13 02:27:11 joseph kernel: [160219.387042] submit_work release lock
        May 13 02:27:11 joseph kernel: [160219.387061] my_task is called the 1 time(s)
        May 13 02:27:11 joseph kernel: [160219.387081] mydrv_worker go to sleep
        May 13 02:27:11 joseph kernel: [160219.387099] submit_work get lock
        May 13 02:27:11 joseph kernel: [160219.387117] submit_work release lock
        May 13 02:27:11 joseph kernel: [160219.387136] my_task is called the 2 time(s)
        May 13 02:27:11 joseph kernel: [160219.387154] mydrv_worker go to sleep
        May 13 02:27:11 joseph kernel: [160219.387171] mydrv_submit_task exit
    5. # ps -ef
        you can find 'mydrv_worker'. assume its thread ID is 21996.
       # kill -s 9 21996  // kill the thread
    6. # cat /var/log/messages
        May 13 19:36:49 joseph kernel: [221908.003286] mydrv_worker exit
        May 13 19:37:04 joseph kernel: [221922.735699] Bye, my dear!
        May 13 19:37:04 joseph kernel: [221922.735701]  Cruel world