[Kernel sync] The completion of Linux kernel synchronization mechanism

Transferred from: http://blog.csdn.net/bullbat/article/details/7401688

A common pattern in kernel programming is to initialize an activity outside the current thread, and then wait for the activity to end. The activity might be to create a new kernel thread or a new user-space process, a request for an existing process, or some type of hardware action, and so on. In this case, we can use semaphores to synchronize the two tasks. However, another mechanism--completion interface is provided in the kernel. Completion is a lightweight mechanism that allows a thread to tell another thread that a job has been completed.

Structure and initialization

The implementation of completion in the kernel is based on the wait queue (the theory of waiting queue is described in the previous article), and the completion structure is simple:

[CPP]View PlainCopyprint?

1. struct Completion {
2. unsigned int done; /* Atomic weight for synchronization * /
3. wait_queue_head_t wait; / * Wait for event queue * /
4. };

As with semaphores, initialization is divided into static initialization and dynamic initialization in two cases:

Static initialization:

[CPP]View PlainCopyprint?

1. #define Completion_initializer (work) \
2. {0, __wait_queue_head_initializer (work). WAIT)}
4. #define DECLARE_COMPLETION (work) \
5. struct Completion work = Completion_initializer (work)

Dynamic initialization:

[CPP]View PlainCopyprint?

1. static inline void init_completion (struct completion *x)
2. {
3. X->done = 0;
4. Init_waitqueue_head (&x->wait);
5. }

It can be seen that both types of initialization will be used to synchronize the done atomic weight 0, we will see later, the variable in the wait correlation function minus one, add one in the complete series function.

Realize

Synchronous functions are generally paired, and completion is no exception, so let's take a look at the most basic implementations of the two complete and wait_for_completion functions.

The wait_for_completion is eventually implemented by the following function:

[CPP]View PlainCopy print?

2. Static inline long __sched
4. Do_wait_for_common (struct completion *x, long timeout, int state)
6. {
8. if (!x->done) {
10. Declare_waitqueue (wait, current);
14. Wait.flags |= wq_flag_exclusive;
16. __add_wait_queue_tail (&x->wait, &wait);
18. Do {
20. if (signal_pending_state (state, current)) {
22. Timeout =-erestartsys;
24. Break ;
26. }
28. __set_current_state (state);
30. SPIN_UNLOCK_IRQ (&x->wait.lock);
32. Timeout = schedule_timeout (timeout);
34. SPIN_LOCK_IRQ (&x->wait.lock);
36. } while (!x->done && timeout);
38. __remove_wait_queue (&x->wait, &wait);
40. if (!x->done)
42. return timeout;
44. }
46. x->done--;
48. return timeout?: 1;
50. }

and complete is implemented as follows:

[CPP]View PlainCopyprint?

1. void complete (struct completion *x)
2. {
3. unsigned long flags;
5. Spin_lock_irqsave (&x->wait.lock, flags);
6. x->done++;
7. __wake_up_common (&x->wait, Task_normal, 1, 0, NULL);
8. Spin_unlock_irqrestore (&x->wait.lock, flags);
9. }

Do not look at the kernel implementation of the source code we can also think of his implementation, is not only in the wait function loop waiting for done to become available (positive), and the other side of the complete function is the wake function, of course, do add one, wake up the function to be processed. Yes, see from the code above, as we think. The kernel does the same.

Use

Use the examples in LDD3:

[CPP]View PlainCopyprint?

2. #include <linux/module.h>
4. #include <linux/init.h>
8. #include <linux/sched.h>
10. #include <linux/kernel.h>
12. #include <linux/fs.h>
14. #include <linux/types.h>
16. #include <linux/completion.h>
20. Module_license ("GPL");
24. static int complete_major=250;
26. Declare_completion (comp);
30. ssize_t complete_read (struct file *filp,char __user *buf,size_t count,loff_t *pos)
32. {
34. PRINTK (kern_err "process%i (%s) going to sleep\n", Current->pid,current->comm);
36. Wait_for_completion (&comp);
38. PRINTK (Kern_err "Awoken%i (%s) \ n", Current->pid,current->comm);
40. return 0;
42. }
46. ssize_t complete_write (struct file *filp,const char __user *buf,size_t count,loff_t *pos)
48. {
50. PRINTK (kern_err "process%i (%s) awakening the readers...\n", Current->pid,current->comm);
52. Complete (&COMP);
54. return count;
56. }
60. struct File_operations complete_fops={
62. . Owner=this_module,
64. . Read=complete_read,
66. . Write=complete_write,
68. };
72. int complete_init (void)
74. {
76. int result;
78. Result=register_chrdev (Complete_major,"complete", &complete_fops);
80. if (result<0)
82. return result;
84. if (complete_major==0)
86. Complete_major=result;
88. return 0;
90. }
92. void Complete_cleanup (void)
94. {
96. Unregister_chrdev (Complete_major,"complete");
98. }
100. Module_init (Complete_init);
102. Module_exit (Complete_cleanup);

Test steps:

1, Mknod/dev/complete creates a complete node, and on Linux the driver needs to manually create the file node.

2, Insmod Complete.ko Insert the driver module, it is important to note that because our code is manually assigned to the device number, it is likely to be used by the system, so if this happens, view the/proc/devices file. Find a device number that is not being used.

3, Cat/dev/complete is used to read the device, call the device read function

4. Open another terminal input echo "Hello" >/dev/complete this command is used to write to the device.

[Kernel sync] The completion of Linux kernel synchronization mechanism