等待队列源码分析

1. struct list_head {
struct list_head *next, *prev;  //定义了一个指向下一个的指针和一个指向上一个的指针
};
／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／


2.每一个等待队列有两部分组成：一个是等待队列头和一个等待队列成员
struct __wait_queue_head {
spinlock_t lock;         ／＊定义一个自旋锁，保证等待队列的安全性
struct list_head task_list;  ／／定义一个链表
};
typedef struct __wait_queue_head wait_queue_head_t;


struct __wait_queue {
unsigned int flags;   ／／指明等待的进程是互斥还是非互斥进程
#define WQ_FLAG_EXCLUSIVE 0x01
void *private;        ／／指向任务的task_struct
wait_queue_func_t func;  //默认唤醒函数
struct list_head task_list;
};
／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／
3.队列初始化函数分析
extern void __init_waitqueue_head(wait_queue_head_t *q, struct lock_class_key *); 
／／初始化队列函数
#define init_waitqueue_head(q) \
do { \
static struct lock_class_key __key; \
\
__init_waitqueue_head((q), &__key); \
} while (0)


void __init_waitqueue_head(wait_queue_head_t *q, struct lock_class_key *key)
{
spin_lock_init(&q->lock);   ／／初始化自旋锁
lockdep_set_class(&q->lock, key);
INIT_LIST_HEAD(&q->task_list); ／／初始化队列
}




static inline void INIT_LIST_HEAD(struct list_head *list)
{
list->next = list;        ／／链表操作
list->prev = list;
}
／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／
4.添加和移除等待队列函数分析
void add_wait_queue(wait_queue_head_t *q, wait_queue_t *wait)
{
unsigned long flags;


wait->flags &= ~WQ_FLAG_EXCLUSIVE（＝0x01）;／／相与必等于0，将进程调为非互斥  
spin_lock_irqsave(&q->lock, flags);         ／／关中断，保护临界区
__add_wait_queue(q, wait); ／／将wait进程添加队列中的头部位（分析下面的函数）
spin_unlock_irqrestore(&q->lock, flags); ／／中断恢复
}
＝＝＝＝＝＝＝＝
static inline void __add_wait_queue(wait_queue_head_t *head, wait_queue_t *new)
{
list_add(&new->task_list, &head->task_list);
}


static inline void list_add(struct list_head *new, struct list_head *head)
{
__list_add(new, head, head->next);
}


static inline void __list_add(struct list_head *new,
     struct list_head *prev,
     struct list_head *next)
{
next->prev = new;
new->next = next;
new->prev = prev;
prev->next = new;     
}
＝＝＝＝＝＝＝
void remove_wait_queue(wait_queue_head_t *q, wait_queue_t *wait)
{
unsigned long flags;


spin_lock_irqsave(&q->lock, flags);  ／／关中断
__remove_wait_queue(q, wait);         ／／移除wait进程
spin_unlock_irqrestore(&q->lock, flags);  ／／中断恢复
}
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
static inline void __remove_wait_queue(wait_queue_head_t *head,
wait_queue_t *old)
{
list_del(&old->task_list);  ／／删除等待进程old的结点
}


static inline void list_del(struct list_head *entry)
{
__list_del(entry->prev, entry->next);
entry->next = LIST_POISON1;  ／／指向其他地方，防止出错
entry->prev = LIST_POISON2;
}


static inline void __list_del(struct list_head * prev, struct list_head * next)
{
next->prev = prev;
prev->next = next;
}
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝


void
prepare_to_wait_exclusive(wait_queue_head_t *q, wait_queue_t *wait, int state)
{
unsigned long flags;


wait->flags |= WQ_FLAG_EXCLUSIVE;  ／／结果为1，进程为互斥进程
spin_lock_irqsave(&q->lock, flags); ／／关中断
if (list_empty(&wait->task_list))    ／／判断wait队列是否为空，即些进程是否存在
__add_wait_queue_tail(q, wait); ／／添加到队列尾部
set_current_state(state);               ／／设置进程状态
spin_unlock_irqrestore(&q->lock, flags);
}


＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
#define set_current_state(state_value) \
set_mb(current->state, (state_value))
#define set_mb(var, value)  do { var = value;  mb(); } while (0)


#define mb() asm volatile ("": : :"memory") 听网上说是设置了一个内存屏障，这里不懂，如果好的理解，望解释解释


＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝


5.／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／


void
prepare_to_wait(wait_queue_head_t *q, wait_queue_t *wait, int state)
{
unsigned long flags;


wait->flags &= ~WQ_FLAG_EXCLUSIVE;   ／／非互斥进程
spin_lock_irqsave(&q->lock, flags);
if (list_empty(&wait->task_list))     ／／判断进程是否在队列中
__add_wait_queue(q, wait);     ／／如果没有，加入队列
set_current_state(state);
spin_unlock_irqrestore(&q->lock, flags);
}


6／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／
void finish_wait(wait_queue_head_t *q, wait_queue_t *wait)
{
unsigned long flags;


__set_current_state(TASK_RUNNING);    ／／设置当前进程为RUNING
/*
* We can check for list emptiness outside the lock
* IFF:
*  - we use the "careful" check that verifies both
*    the next and prev pointers, so that there cannot
*    be any half-pending updates in progress on other
*    CPU's that we haven't seen yet (and that might
*    still change the stack area.
* and
*  - all other users take the lock (ie we can only
*    have _one_ other CPU that looks at or modifies
*    the list).
*/
if (!list_empty_careful(&wait->task_list)) {    ／／判断是否在队列中
spin_lock_irqsave(&q->lock, flags);
list_del_init(&wait->task_list);        ／／如果在删除
spin_unlock_irqrestore(&q->lock, flags);
}
}
EXPORT_SYMBOL(finish_wait);


＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
static inline int list_empty_careful(const struct list_head *head)
{
struct list_head *next = head->next;
return (next == head) && (next == head->prev);
}


static inline void list_del_init(struct list_head *entry)
{
__list_del(entry->prev, entry->next);    ／／删除entry进程
INIT_LIST_HEAD(entry); ／／初始化指针
}


static inline void INIT_LIST_HEAD(struct list_head *list)
{
list->next = list;
list->prev = list;
}
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝


void abort_exclusive_wait(wait_queue_head_t *q, wait_queue_t *wait,
unsigned int mode, void *key)
{
unsigned long flags;


__set_current_state(TASK_RUNNING);
spin_lock_irqsave(&q->lock, flags);
if (!list_empty(&wait->task_list))
list_del_init(&wait->task_list);  ／／唤醒进程
else if (waitqueue_active(q))             ／／判断队列是否为空，如是不是空执行下一句
__wake_up_locked_key(q, mode, key); ／／唤醒你想唤醒的进程
spin_unlock_irqrestore(&q->lock, flags);
}
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝


＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
7、／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／
int autoremove_wake_function(wait_queue_t *wait, unsigned mode, int sync, void *key)
{
int ret = default_wake_function(wait, mode, sync, key);


if (ret)
list_del_init(&wait->task_list);     ／／默认唤醒函数
return ret;
}


主要函数就分析这些，如果上面有什么错误的，望大家指出来