Linux內核同步機制之completion【轉】

Linux內核同步機制之completion
內核編程中常見的一種模式是，在當前線程之外初始化某個活動，然後等待該活動的結束。這個活動可能是，創建一個新的內核線程或者新的用戶空間進程、對一個已有進程的某個請求，或者某種類型的硬體動作，等等。在這種情況下，我們可以使用信號量來同步這兩個任務。然而，內核中提供了另外一種機制——completion介面。Completion是一種輕量級的機制，他允許一個線程告訴另一個線程某個工作已經完成。

結構與初始化

Completion在內核中的實現基於等待隊列（關於等待隊列理論知識在前面的文章中有介紹），completion結構很簡單：

struct completion {
    unsigned int done;/*用於同步的原子量*/
    wait_queue_head_t wait;/*等待事件隊列*/
};

和信號量一樣，初始化分為靜態初始化和動態初始化兩種情況：
靜態初始化：

#define COMPLETION_INITIALIZER(work) \
    { 0, __WAIT_QUEUE_HEAD_INITIALIZER((work).wait) }

#define DECLARE_COMPLETION(work) \
    struct completion work = COMPLETION_INITIALIZER(work)

動態初始化：

static inline void init_completion(struct completion *x)
{
    x->done = 0;
    init_waitqueue_head(&x->wait);
}

可見，兩種初始化都將用於同步的done原子量置位了0，後面我們會看到，該變數在wait相關函數中減一，在complete系列函數中加一。

實現

同步函數一般都成對出現，completion也不例外，我們看看最基本的兩個complete和wait_for_completion函數的實現。
wait_for_completion最終由下麵函數實現：

static inline long __sched
do_wait_for_common(struct completion *x, long timeout, int state)
{
    if (!x->done) {
        DECLARE_WAITQUEUE(wait, current);

        wait.flags |= WQ_FLAG_EXCLUSIVE;
        __add_wait_queue_tail(&x->wait, &wait);
        do {
            if (signal_pending_state(state, current)) {
                timeout = -ERESTARTSYS;
                break;
            }
            __set_current_state(state);
            spin_unlock_irq(&x->wait.lock);
            timeout = schedule_timeout(timeout);
            spin_lock_irq(&x->wait.lock);
        } while (!x->done && timeout);
        __remove_wait_queue(&x->wait, &wait);
        if (!x->done)
            return timeout;
    }
    x->done--;
    return timeout ?: 1;
}

wait_for_completion最終由下麵函數實現：

static inline long __sched
do_wait_for_common(struct completion *x, long timeout, int state)
{
    if (!x->done) {
        DECLARE_WAITQUEUE(wait, current);

        wait.flags |= WQ_FLAG_EXCLUSIVE;
        __add_wait_queue_tail(&x->wait, &wait);
        do {
            if (signal_pending_state(state, current)) {
                timeout = -ERESTARTSYS;
                break;
            }
            __set_current_state(state);
            spin_unlock_irq(&x->wait.lock);
            timeout = schedule_timeout(timeout);
            spin_lock_irq(&x->wait.lock);
        } while (!x->done && timeout);
        __remove_wait_queue(&x->wait, &wait);
        if (!x->done)
            return timeout;
    }
    x->done--;
    return timeout ?: 1;
}

而complete實現如下：

void complete(struct completion *x)  
{  
    unsigned long flags;  
  
    spin_lock_irqsave(&x->wait.lock, flags);  
    x->done++;  
    __wake_up_common(&x->wait, TASK_NORMAL, 1, 0, NULL);  
    spin_unlock_irqrestore(&x->wait.lock, flags);  
}  

不看內核實現的源代碼我們也能想到他的實現，不外乎在wait函數中迴圈等待done變為可用（正），而另一邊的complete函數為喚醒函數，當然是將done加一，喚醒待處理的函數。是的，從上面的代碼看到，和我們想的一樣。內核也是這樣做的。

運用

運用LDD3中的例子：

#include <linux/module.h>
#include <linux/init.h>

#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/types.h>
#include <linux/completion.h>

MODULE_LICENSE("GPL");

static int complete_major=250;
DECLARE_COMPLETION(comp);

ssize_t complete_read(struct file *filp,char __user *buf,size_t count,loff_t *pos)
{
    printk(KERN_ERR "process %i (%s) going to sleep\n",current->pid,current->comm);
    wait_for_completion(&comp);
    printk(KERN_ERR "awoken %i (%s)\n",current->pid,current->comm);
    return 0;
}

ssize_t complete_write(struct file *filp,const char __user *buf,size_t count,loff_t *pos)
{
    printk(KERN_ERR "process %i (%s) awakening the readers...\n",current->pid,current->comm);
    complete(&comp);
    return count;
}

struct file_operations complete_fops={
    .owner=THIS_MODULE,
    .read=complete_read,
    .write=complete_write,
};

int complete_init(void)
{
    int result;
    result=register_chrdev(complete_major,"complete",&complete_fops);
    if(result<0)
        return result;
    if(complete_major==0)
        complete_major=result;
    return 0;
}
void complete_cleanup(void)
{
    unregister_chrdev(complete_major,"complete");
}
module_init(complete_init);
module_exit(complete_cleanup);

測試步驟：

1. mknod /dev/complete創建complete節點，在linux上驅動程式需要手動創建文件節點。
2. insmod complete.ko 插入驅動模塊，這裡要註意的是，因為我們的代碼中是手動分配的設備號，很可能被系統已經使用了，所以如果出現這種情況，查看/proc/devices文件。找一個沒有被使用的設備號。
3. cat /dev/complete 用於讀該設備，調用設備的讀函數
4. 打開另一個終端輸入 echo “hello” > /dev/complete 該命令用於寫入該設備。