wordpress 分类下文章列表/网站seo诊断分析报告

目录

1. 等待队列

2. 完成量completion

1. 等待队列
等待队列（wait queue）用于使进程等待某一特定事件发生，而无须频繁轮询。进程在等待期间睡眠，在事件发生时内核自动唤醒。

1、数据结构：

每个等待队列都有一个队列头

//wait.h (include\linux)

struct __wait_queue_head {
    spinlock_t        lock;
    struct list_head    task_list;
};
typedef struct __wait_queue_head wait_queue_head_t;

队列中的成员使用

初始化方法：

静态初始化

DECLARE_WAIT_QUEUE_HEAD(name)

动态初始化

wait_queue_head_t my_queue;

init_waitqueue_head(&my_queue);

#define wait_event_timeout(wq_head, condition, timeout)                \
({                                        \
    long __ret = timeout;                            \
    might_sleep();                                \
    if (!___wait_cond_timeout(condition))                    \
        __ret = __wait_event_timeout(wq_head, condition, timeout);    \
    __ret;                                    \
})
 
#define __wait_event_interruptible(wq_head, condition)                \
    ___wait_event(wq_head, condition, TASK_INTERRUPTIBLE, 0, 0,        \
              schedule())
 
#define wake_up_interruptible(x)    __wake_up(x, TASK_INTERRUPTIBLE, 1, NULL)
 

wait_event_timeout(wq, condition, timeout)的返回值：

函数返回0：表示timeout超时

返回一个正数：表示还没有超时，但condition变为真，返回剩余的时间

2. 完成量completion
完成量(completion)机制基于等待队列，内核利用该机制等待某一操作完成。

#include <linux/completion.h>

struct completion {
    unsigned int done;
    wait_queue_head_t wait;
};
主要API：

DECLARE_COMPLETION(work)

静态初始化一个完成量

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

举例：

static DECLARE_COMPLETION(release_done);

void init_completion(struct completion *x)

动态初始化一个完成量

举例：

struct completion emsgs_comp;

init_completion(&emsgs_comp);

void reinit_completion(struct completion *x)

void wait_for_completion(struct completion *)

void complete(struct completion *)

void complete_all(struct completion *)

extern void wait_for_completion_io(struct completion *);

extern int wait_for_completion_interruptible(struct completion *x);

extern int wait_for_completion_killable(struct completion *x);

extern unsigned long wait_for_completion_timeout(struct completion *x, unsigned long timeout);

extern unsigned long wait_for_completion_io_timeout(struct completion *x, unsigned long timeout);

extern long wait_for_completion_interruptible_timeout(struct completion *x, unsigned long timeout);

extern long wait_for_completion_killable_timeout(struct completion *x, unsigned long timeout);

extern bool try_wait_for_completion(struct completion *x);

extern bool completion_done(struct completion *x);
————————————————
版权声明：本文为CSDN博主「liuzl_2010」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/zsyf33078/article/details/88528390

在linux内核中，引入锁机制主要是解决资源并发与竞争问题；
主要常用锁机制：信号量，自旋锁，互斥锁；
线程间的 同步大多使用completion信号量，而互斥资源的保护大多使用自旋锁和互斥锁。.

该篇文章主要讲解的是completion完成量。也算是信号量中的一种。
completion信号量是一个轻量级的机制，它允许一个线程告诉另一个线程某个工作已经做完了。

一般信号量的的处理会限制在一个函数内，但是有时候函数A的处理的前提条件是函数B，
A必须等待B处理后才能继续，可以用信号量来进行处理，但linux kernel提供complete的方式。使用方式如下文所示：
(1) init
(2) wait_for_completion A在这个位置上等待B的执行
(3) complete_all B执行完,A就可以执行,无论多少次

以下代码分析是在kernel4.14下

1 completion结构体
struct completion {
    unsigned int done;
    wait_queue_head_t wait;
};
1
2
3
4
字段解释：
(1) unsigned int done;
等待的事件是否完成。初始化时为0，表示等待的事件未完成；大于0，表示等待的事件已经完成。
(2) wait_queue_head_t wait;
存放等待该事件完成的进程队列

2 定义和初始化
struct completion my_completion;
init_completion(&my_completion);

define init_completion(x) __init_completion(x)
static inline void __init_completion(struct completion *x)
{
    x->done = 0;
    init_waitqueue_head(&x->wait);
}
1
2
3
4
5
6
直接定义并调用init_completion()初始化。init_completion()会将done字段初始化为0，wait字段的自旋锁为未锁，等待队列为空。这说明调用该完成量的进程必须等待某事件完成(即另外一进程必须先调用completiom()唤醒该完成量)。

3 等待完成量的释放
wait_for_completion_timeout(&my_completion, 10);
这个函数的返回值如果>0，<10，说明等到了一个反馈，即是my_completion通过complete_all这个函数释放掉了

unsigned long __sched
wait_for_completion_timeout(struct completion *x, unsigned long timeout)
{
    return wait_for_common(x, timeout, TASK_UNINTERRUPTIBLE);
}
1
2
3
4
5
static long __sched
wait_for_common(struct completion *x, long timeout, int state)
{
    return __wait_for_common(x, schedule_timeout, timeout, state);
}
1
2
3
4
5
static inline long __sched
__wait_for_common(struct completion *x,
          long (*action)(long), long timeout, int state)
{
    might_sleep();

    complete_acquire(x);

    spin_lock_irq(&x->wait.lock);
    timeout = do_wait_for_common(x, action, timeout, state);
    spin_unlock_irq(&x->wait.lock);

    complete_release(x);

    return timeout;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
static inline long __sched
do_wait_for_common(struct completion *x,
           long (*action)(long), long timeout, int state)
{
    if (!x->done) {
        DECLARE_WAITQUEUE(wait, current);

        __add_wait_queue_entry_tail_exclusive(&x->wait, &wait);
        do {
            if (signal_pending_state(state, current)) {
                timeout = -ERESTARTSYS;
                break;
            }
            __set_current_state(state);
            spin_unlock_irq(&x->wait.lock);
            timeout = action(timeout);
            spin_lock_irq(&x->wait.lock);
        } while (!x->done && timeout);
        __remove_wait_queue(&x->wait, &wait);
        if (!x->done)
            return timeout;
    }
    if (x->done != UINT_MAX)
        x->done--;
    return timeout ?: 1;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
当 x->done =1时，就说明等到了。

4 释放完成量
complete_all(&my_completion);

/*This will wake up all threads waiting on this particular completion event.*/
void complete_all(struct completion *x)
{
    unsigned long flags;

    spin_lock_irqsave(&x->wait.lock, flags);
    x->done = UINT_MAX;
    __wake_up_locked(&x->wait, TASK_NORMAL, 0);
    spin_unlock_irqrestore(&x->wait.lock, flags);
}
#define UINT_MAX (~0U)
1
2
3
4
5
6
7
8
9
10
11
把 completion的done 赋值为1，唤醒所有等待 struct completion *x 的 task。

5 参考：
(1) https://www.cnblogs.com/metootxy/archive/2013/04/01/2994178.html
(2) https://blog.csdn.net/dreamxu/article/details/5866593
(3) https://www.cnblogs.com/aaronLinux/p/5904493.html
————————————————
版权声明：本文为CSDN博主「「已注销」」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/cherylchenyajun/article/details/107784434