linux驱动中的阻塞访问方式

最新推荐文章于 2022-12-14 16:27:07 发布
最新推荐文章于 2022-12-14 16:27:07 发布
阅读量834 收藏 1
点赞数

阻塞与非阻塞是设备访问的两种不同的模式。什么是阻塞操作呢？其是指在执行设备操作的时候，如果不能获得资源，则挂起进程直到满足可操作的条件后再进行操作.而非阻塞操作则是在进程不能进行设备操作时，并不挂起到等待队列，而是放弃或者不断的查询，直到能够进行操作。

应用程序以阻塞的方式进行read操作的时候，会调用一个system call，将系统的控制权交给kernel后就进入等待状态，等kernel将这个system执行完成后向应用程序返回响应，应用程序的得到响应后，就推出阻塞状态，并进行后面的工作。

应用程序以非阻塞的方式进行write操作的时候，通过设置文件描述符的属性O_NONBLOCK使其进入非阻塞的访问状态，这时进程也会调用相应的system call，但是system call会立即从kernel中返回。

从表面上看，阻塞状态貌似没有非阻塞的访问方式效率高，事实上却不是这样，非阻塞的访问方式虽然不用等待，会立即返回，可是他不一定就完成了相应的工作，比如上面的例子里面，虽然立即返回，但是数据可能还没有真正的写入文件中，所以说效率的高低并不是表面看上去的那样。

在linux驱动中，可以使用等待队列来实现阻塞进程的唤醒。wait queue以队列为基础数据结构，与进程调度机制紧密结合，能够用于实现内核中的异步事件通知机制等。下面就先看下一些关于等待队列的基本的操作。

定义一个等待队列头并初始化：

[cpp] view plain copy print ?
  1. wait_queue_head_t my_queue;  
  2. init_waitqueue_head(&my_queue);  
wait_queue_head_t my_queue;
init_waitqueue_head(&my_queue);
或者

[cpp] view plain copy print ?
  1. DECLARE_WAIT_QUEUE_HEAD(my_queue);  
DECLARE_WAIT_QUEUE_HEAD(my_queue);
下面来看下wait_queue_head_t这个结构体，其中t的意思就是typedef的意思，是linux中的一种命名规则。

[cpp] view plain copy print ?
  1. struct __wait_queue_head {  
  2.         spinlock_t lock;  
  3.         struct list_head task_list;  
  4. };  
  5. typedef struct __wait_queue_head wait_queue_head_t;  
struct __wait_queue_head {
        spinlock_t lock;
        struct list_head task_list;
};
typedef struct __wait_queue_head wait_queue_head_t;
首先是定义了一个lock的自旋锁，后面定义了一个链表。其中看下init_waitqueue_head函数，通过wait_queue_head_t结构体成员，就不难想象里面大概的函数实现：

[cpp] view plain copy print ?
  1. extern void __init_waitqueue_head(wait_queue_head_t *q, struct lock_class_key *);  
  2.   
  3. #define init_waitqueue_head(q)                          \  
  4.         do {                                            \  
  5.                 static struct lock_class_key __key;     \  
  6.                                                         \  
  7.                 __init_waitqueue_head((q), &__key);     \  
  8.         } while (0)  
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)
而__init_waitqueue_head()函数是：

[cpp] view plain copy print ?
  1. void __init_waitqueue_head(wait_queue_head_t *q, struct lock_class_key *key)  
  2. {  
  3.         spin_lock_init(&q->lock);  
  4.         lockdep_set_class(&q->lock, key);  
  5.         INIT_LIST_HEAD(&q->task_list);  
  6. }  
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);
}
其大概也就是初始化自旋锁以及链表等单元。而DECLARE_WAIT_QUEUE_HEAD的函数原型是：

[cpp] view plain copy print ?
  1. #define DECLARE_WAIT_QUEUE_HEAD(name) \  
  2.         wait_queue_head_t name = __WAIT_QUEUE_HEAD_INITIALIZER(name)  
#define DECLARE_WAIT_QUEUE_HEAD(name) \
        wait_queue_head_t name = __WAIT_QUEUE_HEAD_INITIALIZER(name)
[cpp] view plain copy print ?
  1. #define __WAIT_QUEUE_HEAD_INITIALIZER(name) {                           \  
  2.         .lock           = __SPIN_LOCK_UNLOCKED(name.lock),              \  
  3.         .task_list      = { &(name).task_list, &(name).task_list } }  
#define __WAIT_QUEUE_HEAD_INITIALIZER(name) {                           \
        .lock           = __SPIN_LOCK_UNLOCKED(name.lock),              \
        .task_list      = { &(name).task_list, &(name).task_list } }

定义等待队列用DECLARE_WAITQUEUE函数来实现

[cpp] view plain copy print ?
  1. DECLARE_WAITQUEUE(name,tsk);  
DECLARE_WAITQUEUE(name,tsk);
其定义了一个名为name的等待队列

[cpp] view plain copy print ?
  1. #define DECLARE_WAITQUEUE(name, tsk)                                    \  
  2.         wait_queue_t name = __WAITQUEUE_INITIALIZER(name, tsk)  
#define DECLARE_WAITQUEUE(name, tsk)                                    \
        wait_queue_t name = __WAITQUEUE_INITIALIZER(name, tsk)
其中

[cpp] view plain copy print ?
  1. typedef struct __wait_queue wait_queue_t;  
  2.   
  3. struct __wait_queue {  
  4.         unsigned int flags;  
  5. #define WQ_FLAG_EXCLUSIVE       0x01   
  6.         void *private;  
  7.         wait_queue_func_t func;  
  8.         struct list_head task_list;  
  9. };  
typedef struct __wait_queue wait_queue_t;

struct __wait_queue {
        unsigned int flags;
#define WQ_FLAG_EXCLUSIVE       0x01
        void *private;
        wait_queue_func_t func;
        struct list_head task_list;
};
[cpp] view plain copy print ?
  1. #define __WAITQUEUE_INITIALIZER(name, tsk) {                            \  
  2.         .private        = tsk,                                          \  
  3.         .func           = default_wake_function,                        \  
  4.         .task_list      = { NULL, NULL } }  
#define __WAITQUEUE_INITIALIZER(name, tsk) {                            \
        .private        = tsk,                                          \
        .func           = default_wake_function,                        \
        .task_list      = { NULL, NULL } }

flag：它的值有WQ_FLAG_EXCLUSIVE或者0，他说明等待的进程是否是互斥的。当为WQ_FLAG_EXCLUSIVE表示互斥；

private：一般用来指向等待进程的task_struct实例；

func：其唤醒等待进程；

task_list：用于链接等待队列中的进程

下面看下添加和移除等待队列的API函数：

[cpp] view plain copy print ?
  1. void add_wait_queue(wait_queue_head_t *q, wait_queue_t *wait)  
  2. {  
  3.         unsigned long flags;  
  4.   
  5.         wait->flags &= ~WQ_FLAG_EXCLUSIVE;  
  6.         spin_lock_irqsave(&q->lock, flags);  
  7.         __add_wait_queue(q, wait);  
  8.         spin_unlock_irqrestore(&q->lock, flags);  
  9. }  
  10. EXPORT_SYMBOL(add_wait_queue);  
void add_wait_queue(wait_queue_head_t *q, wait_queue_t *wait)
{
        unsigned long flags;

        wait->flags &= ~WQ_FLAG_EXCLUSIVE;
        spin_lock_irqsave(&q->lock, flags);
        __add_wait_queue(q, wait);
        spin_unlock_irqrestore(&q->lock, flags);
}
EXPORT_SYMBOL(add_wait_queue);
其意思就是将wait等待队列加入到q的等待队列头中。再看其中的__add_wait_queue函数：

[cpp] view plain copy print ?
  1. static inline void __add_wait_queue(wait_queue_head_t *head, wait_queue_t *new)  
  2. {  
  3.         list_add(&new->task_list, &head->task_list);  
  4. }  
static inline void __add_wait_queue(wait_queue_head_t *head, wait_queue_t *new)
{
        list_add(&new->task_list, &head->task_list);
}
这样很容易看出，wait是如何挂到q上面去的。同样的：

[cpp] view plain copy print ?
  1. void remove_wait_queue(wait_queue_head_t *q, wait_queue_t *wait)  
  2. {  
  3.         unsigned long flags;  
  4.   
  5.         spin_lock_irqsave(&q->lock, flags);  
  6.         __remove_wait_queue(q, wait);  
  7.         spin_unlock_irqrestore(&q->lock, flags);  
  8. }  
  9. EXPORT_SYMBOL(remove_wait_queue);  
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);
        spin_unlock_irqrestore(&q->lock, flags);
}
EXPORT_SYMBOL(remove_wait_queue);
而__remove_wait_queue函数

[cpp] view plain copy print ?
  1. static inline void __remove_wait_queue(wait_queue_head_t *head,  
  2.                                                         wait_queue_t *old)  
  3. {         
  4.         list_del(&old->task_list);  
  5. }         
static inline void __remove_wait_queue(wait_queue_head_t *head,
                                                        wait_queue_t *old)
{       
        list_del(&old->task_list);
}
这样看就很简单了。

下面介绍的是等待事件函数，其就是依据condition条件是否满足来选择是否返回或者阻塞等待。

[cpp] view plain copy print ?
  1. wait_event(wq, condition)  
  2. wait_event_timeout(wq, condition, timeout)   
  3. wait_event_interruptible(wq, condition)   
  4. wait_event_interruptible_timeout(wq, condition, timeout)  
wait_event(wq, condition)
wait_event_timeout(wq, condition, timeout) 
wait_event_interruptible(wq, condition) 
wait_event_interruptible_timeout(wq, condition, timeout)
下面以此来看上面函数的实现过程：

[cpp] view plain copy print ?
  1. /** 
  2.  * wait_event - sleep until a condition gets true 
  3.  * @wq: the waitqueue to wait on 
  4.  * @condition: a C expression for the event to wait for 
  5.  * 
  6.  * The process is put to sleep (TASK_UNINTERRUPTIBLE) until the 
  7.  * @condition evaluates to true. The @condition is checked each time 
  8.  * the waitqueue @wq is woken up. 
  9.  * 
  10.  * wake_up() has to be called after changing any variable that could 
  11.  * change the result of the wait condition. 
  12.  */  
  13. #define wait_event(wq, condition)                                       \  
  14. do {                                                                    \  
  15.         if (condition)                                                  \  
  16.                 break;                                                  \  
  17.         __wait_event(wq, condition);                                    \  
  18. } while (0)  
/**
 * wait_event - sleep until a condition gets true
 * @wq: the waitqueue to wait on
 * @condition: a C expression for the event to wait for
 *
 * The process is put to sleep (TASK_UNINTERRUPTIBLE) until the
 * @condition evaluates to true. The @condition is checked each time
 * the waitqueue @wq is woken up.
 *
 * wake_up() has to be called after changing any variable that could
 * change the result of the wait condition.
 */
#define wait_event(wq, condition)                                       \
do {                                                                    \
        if (condition)                                                  \
                break;                                                  \
        __wait_event(wq, condition);                                    \
} while (0)
其不难看出，当condition为真时，函数立即返回，否则等待条件为真。

[cpp] view plain copy print ?
  1. #define __wait_event(wq, condition)                                     \  
  2. do {                                                                    \  
  3.         DEFINE_WAIT(__wait);                                            \  
  4.                                                                         \  
  5.         for (;;) {                                                      \  
  6.                 prepare_to_wait(&wq, &__wait, TASK_UNINTERRUPTIBLE);    \  
  7.                 if (condition)                                          \  
  8.                         break;                                          \  
  9.                 schedule();                                             \  
  10.         }                                                               \  
  11.         finish_wait(&wq, &__wait);                                      \  
  12. } while (0)  
#define __wait_event(wq, condition)                                     \
do {                                                                    \
        DEFINE_WAIT(__wait);                                            \
                                                                        \
        for (;;) {                                                      \
                prepare_to_wait(&wq, &__wait, TASK_UNINTERRUPTIBLE);    \
                if (condition)                                          \
                        break;                                          \
                schedule();                                             \
        }                                                               \
        finish_wait(&wq, &__wait);                                      \
} while (0)

这里首先是定义了一个等待队列项__wait：

[cpp] view plain copy print ?
  1. #define DEFINE_WAIT(name) DEFINE_WAIT_FUNC(name, autoremove_wake_function)  
#define DEFINE_WAIT(name) DEFINE_WAIT_FUNC(name, autoremove_wake_function)
[cpp] view plain copy print ?
  1. #define DEFINE_WAIT_FUNC(name, function)                                \  
  2.         wait_queue_t name = {                                           \  
  3.                 .private        = current,                              \  
  4.                 .func           = function,                             \  
  5.                 .task_list      = LIST_HEAD_INIT((name).task_list),     \  
  6.         }  
#define DEFINE_WAIT_FUNC(name, function)                                \
        wait_queue_t name = {                                           \
                .private        = current,                              \
                .func           = function,                             \
                .task_list      = LIST_HEAD_INIT((name).task_list),     \
        }
其中，.private  = current表示等待队列项指向当前的进程；.func  = function 其就是的唤醒函数。

下面就进入循环，开始是prepare_to_wait函数，这个函数的作用是将等待队列项__wait插入到等待队列透wq中，然后设置为TASK_UNINTERRUPTIBLE，即改阻塞状态不能被信号打断，而TASK_INTERRUPTIBLE状态可以被信号打断唤醒。然后再检查一次condition，当condition刚好为真时函数立即返回，否则调用schedule()函数使得进程睡眠，执行schedule()进行了进程的切换以后，直到进程被唤醒才会调度该进程。for循环是等进程被唤醒后再一次检查condition条件是否满足，防止同时唤醒的进程已经抢先占据了资源。最后finish_wait将进程状态属性改为TASK_RUNNING，并且将进程从等待队列中删除。下面看下实现过程：

[cpp] view plain copy print ?
  1. prepare_to_wait(wait_queue_head_t *q, wait_queue_t *wait, int state)  
  2. {  
  3.         unsigned long flags;  
  4.   
  5.         wait->flags &= ~WQ_FLAG_EXCLUSIVE;  
  6.         spin_lock_irqsave(&q->lock, flags);  
  7.         if (list_empty(&wait->task_list))  
  8.                 __add_wait_queue(q, wait);  
  9.         set_current_state(state);  
  10.         spin_unlock_irqrestore(&q->lock, flags);  
  11. }  
  12. EXPORT_SYMBOL(prepare_to_wait);  
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);
}
EXPORT_SYMBOL(prepare_to_wait);
[cpp] view plain copy print ?
  1. void finish_wait(wait_queue_head_t *q, wait_queue_t *wait)  
  2. {  
  3.         unsigned long flags;  
  4.   
  5.         __set_current_state(TASK_RUNNING);  
  6.         /* 
  7.          * We can check for list emptiness outside the lock 
  8.          * IFF: 
  9.          *  - we use the "careful" check that verifies both 
  10.          *    the next and prev pointers, so that there cannot 
  11.          *    be any half-pending updates in progress on other 
  12.          *    CPU's that we haven't seen yet (and that might 
  13.          *    still change the stack area. 
  14.          * and 
  15.          *  - all other users take the lock (ie we can only 
  16.          *    have _one_ other CPU that looks at or modifies 
  17.          *    the list). 
  18.          */  
  19.         if (!list_empty_careful(&wait->task_list)) {  
  20.                 spin_lock_irqsave(&q->lock, flags);  
  21.                 list_del_init(&wait->task_list);  
  22.                 spin_unlock_irqrestore(&q->lock, flags);  
  23.         }  
  24. }  
  25. EXPORT_SYMBOL(finish_wait);  
void finish_wait(wait_queue_head_t *q, wait_queue_t *wait)
{
        unsigned long flags;

        __set_current_state(TASK_RUNNING);
        /*
         * 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);
下面看一下wait_event_timeout()函数的实现，timeout就是阻塞等待的超时时间，单位是jiffy，当timeout达到以后，不论condition是否满足函数都会返回。

[cpp] view plain copy print ?
  1. #define wait_event_timeout(wq, condition, timeout)                      \  
  2. ({                                                                      \  
  3.         long __ret = timeout;                                           \  
  4.         if (!(condition))                                               \  
  5.                 __wait_event_timeout(wq, condition, __ret);             \  
  6.         __ret;                                                          \  
  7. })  
#define wait_event_timeout(wq, condition, timeout)                      \
({                                                                      \
        long __ret = timeout;                                           \
        if (!(condition))                                               \
                __wait_event_timeout(wq, condition, __ret);             \
        __ret;                                                          \
})
[cpp] view plain copy print ?
  1. #define __wait_event_timeout(wq, condition, ret)                        \  
  2. do {                                                                    \  
  3.         DEFINE_WAIT(__wait);                                            \  
  4.                                                                         \  
  5.         for (;;) {                                                      \  
  6.                 prepare_to_wait(&wq, &__wait, TASK_UNINTERRUPTIBLE);    \  
  7.                 if (condition)                                          \  
  8.                         break;                                          \  
  9.                 ret = schedule_timeout(ret);                            \  
  10.                 if (!ret)                                               \  
  11.                         break;                                          \  
  12.         }                                                               \  
  13.         finish_wait(&wq, &__wait);                                      \  
  14. } while (0)  
#define __wait_event_timeout(wq, condition, ret)                        \
do {                                                                    \
        DEFINE_WAIT(__wait);                                            \
                                                                        \
        for (;;) {                                                      \
                prepare_to_wait(&wq, &__wait, TASK_UNINTERRUPTIBLE);    \
                if (condition)                                          \
                        break;                                          \
                ret = schedule_timeout(ret);                            \
                if (!ret)                                               \
                        break;                                          \
        }                                                               \
        finish_wait(&wq, &__wait);                                      \
} while (0)
其和前面的区别就在于多了一个timeout条件，schedule_timeout()函数设置了一个ret的时钟值，他首先调用schedule()函数，进程睡眠，但是每次时钟中断的时候它都会检测时钟值是否到期，当时钟到期后则返回，正常的返回值是0。

剩余的两个wait()函数过程都一样，这里列出实现过程：

[cpp] view plain copy print ?
  1. #define wait_event_interruptible(wq, condition)                         \  
  2. ({                                                                      \  
  3.         int __ret = 0;                                                  \  
  4.         if (!(condition))                                               \  
  5.                 __wait_event_interruptible(wq, condition, __ret);       \  
  6.         __ret;                                                          \  
  7. })  
#define wait_event_interruptible(wq, condition)                         \
({                                                                      \
        int __ret = 0;                                                  \
        if (!(condition))                                               \
                __wait_event_interruptible(wq, condition, __ret);       \
        __ret;                                                          \
})
[cpp] view plain copy print ?
  1. #define __wait_event_interruptible(wq, condition, ret)                  \  
  2. do {                                                                    \  
  3.         DEFINE_WAIT(__wait);                                            \  
  4.                                                                         \  
  5.         for (;;) {                                                      \  
  6.                 prepare_to_wait(&wq, &__wait, TASK_INTERRUPTIBLE);      \  
  7.                 if (condition)                                          \  
  8.                         break;                                          \  
  9.                 if (!signal_pending(current)) {                         \  
  10.                         schedule();                                     \  
  11.                         continue;                                       \  
  12.                 }                                                       \  
  13.                 ret = -ERESTARTSYS;                                     \  
  14.                 break;                                                  \  
  15.         }                                                               \  
  16.         finish_wait(&wq, &__wait);                                      \  
  17. } while (0)  
#define __wait_event_interruptible(wq, condition, ret)                  \
do {                                                                    \
        DEFINE_WAIT(__wait);                                            \
                                                                        \
        for (;;) {                                                      \
                prepare_to_wait(&wq, &__wait, TASK_INTERRUPTIBLE);      \
                if (condition)                                          \
                        break;                                          \
                if (!signal_pending(current)) {                         \
                        schedule();                                     \
                        continue;                                       \
                }                                                       \
                ret = -ERESTARTSYS;                                     \
                break;                                                  \
        }                                                               \
        finish_wait(&wq, &__wait);                                      \
} while (0)
其中wait_event_interruptible()函数是将进程属性设置为TASK_INTERRUPTIBLE，可以被信号唤醒，signal_pending(current)函数是判断是否是信号唤醒的。是的话直接返回-ERESTARTSYS。

[cpp] view plain copy print ?
  1. #define wait_event_interruptible_timeout(wq, condition, timeout) \  
  2. ({ \  
  3.         long __ret = timeout; \  
  4.         if (!(condition)) \  
  5.                 __wait_event_interruptible_timeout(wq, condition, __ret); \  
  6.         __ret; \  
  7. })  
#define wait_event_interruptible_timeout(wq, condition, timeout) \
({ \
        long __ret = timeout; \
        if (!(condition)) \
                __wait_event_interruptible_timeout(wq, condition, __ret); \
        __ret; \
})
[cpp] view plain copy print ?
  1. #define __wait_event_interruptible_timeout(wq, condition, ret) \  
  2. do { \  
  3.         wait_queue_t __wait; \  
  4.         init_waitqueue_entry(&__wait, current); \  
  5.         add_wait_queue(&wq, &__wait); \  
  6.         for (;;) { \  
  7.                 set_current_state(TASK_INTERRUPTIBLE); \  
  8.                 if (condition) \  
  9.                         break; \  
  10.                 if (!signal_pending(current)) { \  
  11.                         ret = schedule_timeout(ret); \  
  12.                         if (!ret) \  
  13.                                 break; \  
  14.                         continue; \  
  15.                 } \  
  16.                 ret = -ERESTARTSYS; \  
  17.                 break; \  
  18.         } \  
  19.         current->state = TASK_RUNNING; \  
  20.         remove_wait_queue(&wq, &__wait); \  
  21. } while (0)  
#define __wait_event_interruptible_timeout(wq, condition, ret) \
do { \
        wait_queue_t __wait; \
        init_waitqueue_entry(&__wait, current); \
        add_wait_queue(&wq, &__wait); \
        for (;;) { \
                set_current_state(TASK_INTERRUPTIBLE); \
                if (condition) \
                        break; \
                if (!signal_pending(current)) { \
                        ret = schedule_timeout(ret); \
                        if (!ret) \
                                break; \
                        continue; \
                } \
                ret = -ERESTARTSYS; \
                break; \
        } \
        current->state = TASK_RUNNING; \
        remove_wait_queue(&wq, &__wait); \
} while (0)
[cpp] view plain copy print ?
  1. static inline void init_waitqueue_entry(wait_queue_t *q, struct task_struct *p)  
  2. {  
  3.         q->flags = 0;  
  4.         q->private = p;  
  5.         q->func = default_wake_function;  
  6. }  
static inline void init_waitqueue_entry(wait_queue_t *q, struct task_struct *p)
{
        q->flags = 0;
        q->private = p;
        q->func = default_wake_function;
}
default_wake_function是内核中的一个默认的唤醒函数。

下面来看一下唤醒函数，常用的有：

[cpp] view plain copy print ?
  1. #define wake_up(x)                      __wake_up(x, TASK_NORMAL, 1, NULL)  
  2. #define wake_up_interruptible(x)        __wake_up(x, TASK_INTERRUPTIBLE, 1, NULL)  
#define wake_up(x)                      __wake_up(x, TASK_NORMAL, 1, NULL)
#define wake_up_interruptible(x)        __wake_up(x, TASK_INTERRUPTIBLE, 1, NULL)
唤醒函数主要是唤醒属于指定等待队列头的所有等待队列中等待进程。可以看出，其实质都是调用__wake_up()函数，只是传递的参数不同而已。

[cpp] view plain copy print ?
  1. void __wake_up(wait_queue_head_t *q, unsigned int mode,  
  2.                         int nr_exclusive, void *key)  
  3. {  
  4.         unsigned long flags;  
  5.   
  6.         spin_lock_irqsave(&q->lock, flags);  
  7.         __wake_up_common(q, mode, nr_exclusive, 0, key);  
  8.         spin_unlock_irqrestore(&q->lock, flags);  
  9. }  
  10. EXPORT_SYMBOL(__wake_up);  
void __wake_up(wait_queue_head_t *q, unsigned int mode,
                        int nr_exclusive, void *key)
{
        unsigned long flags;

        spin_lock_irqsave(&q->lock, flags);
        __wake_up_common(q, mode, nr_exclusive, 0, key);
        spin_unlock_irqrestore(&q->lock, flags);
}
EXPORT_SYMBOL(__wake_up);
其中

[cpp] view plain copy print ?
  1. static void __wake_up_common(wait_queue_head_t *q, unsigned int mode,  
  2.                         int nr_exclusive, int wake_flags, void *key)  
  3. {  
  4.         wait_queue_t *curr, *next;  
  5.   
  6.         list_for_each_entry_safe(curr, next, &q->task_list, task_list) {  
  7.                 unsigned flags = curr->flags;  
  8.   
  9.                 if (curr->func(curr, mode, wake_flags, key) &&  
  10.                                 (flags & WQ_FLAG_EXCLUSIVE) && !--nr_exclusive)  
  11.                         break;  
  12.         }  
  13. }  
static void __wake_up_common(wait_queue_head_t *q, unsigned int mode,
                        int nr_exclusive, int wake_flags, void *key)
{
        wait_queue_t *curr, *next;

        list_for_each_entry_safe(curr, next, &q->task_list, task_list) {
                unsigned flags = curr->flags;

                if (curr->func(curr, mode, wake_flags, key) &&
                                (flags & WQ_FLAG_EXCLUSIVE) && !--nr_exclusive)
                        break;
        }
}
list_for_each_entry_safe将遍历整个等待队列链表，在if语句中，func是默认的唤醒函数，是将curr进程通过mode方式唤醒，然后再比较是否是互斥形式，如果是的话在判断需要唤醒的互斥进程的数量(nr_exclusive是需唤醒的互斥进程的数量)，通过if语句可以看出，在遍历的过程中首先先会唤醒非互斥的，然后才会唤醒互斥进程（可以通过if语句中&&的顺序判断）。

通过上面的分析，对于等待队列的阻塞以及唤醒已经很清楚了，下面还有一套sleep()函数，其目的是使进程在等待队列上睡眠，如：

[cpp] view plain copy print ?
  1. sleep_on(wait_queue_head_t *q)  
  2. interruptible_sleep_on(wait_queue_head_t *q)  
sleep_on(wait_queue_head_t *q)
interruptible_sleep_on(wait_queue_head_t *q)
sleep_on函数是将进程的状态设置为TASK_UMINTERRUPTIBLE，并且将它附属到等待队列头q上，知道获得资源，q引导的等待队列被唤醒。

而interruptible_sleep_on函数是将进程设置为TASK_INTERRUPTIBLE。

sleep_on与wake_up、interruptible_sleep_on与wake_up_interruptible都是成对出现使用的。

[cpp] view plain copy print ?
  1. void __sched sleep_on(wait_queue_head_t *q)  
  2. {  
  3.         sleep_on_common(q, TASK_UNINTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);  
  4. }  
  5. EXPORT_SYMBOL(sleep_on);  
void __sched sleep_on(wait_queue_head_t *q)
{
        sleep_on_common(q, TASK_UNINTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
}
EXPORT_SYMBOL(sleep_on);
[cpp] view plain copy print ?
  1. void __sched interruptible_sleep_on(wait_queue_head_t *q)  
  2. {  
  3.         sleep_on_common(q, TASK_INTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);  
  4. }  
  5. EXPORT_SYMBOL(interruptible_sleep_on);  
void __sched interruptible_sleep_on(wait_queue_head_t *q)
{
        sleep_on_common(q, TASK_INTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
}
EXPORT_SYMBOL(interruptible_sleep_on);
其核心都是sleep_on_common()函数，只是传递的参数不同。

[cpp] view plain copy print ?
  1. static long __sched  
  2. sleep_on_common(wait_queue_head_t *q, int state, long timeout)  
  3. {  
  4.         unsigned long flags;  
  5.         wait_queue_t wait;  
  6.   
  7.         init_waitqueue_entry(&wait, current);  
  8.   
  9.         __set_current_state(state);  
  10.   
  11.         spin_lock_irqsave(&q->lock, flags);  
  12.         __add_wait_queue(q, &wait);  
  13.         spin_unlock(&q->lock);  
  14.         timeout = schedule_timeout(timeout);  
  15.         spin_lock_irq(&q->lock);  
  16.         __remove_wait_queue(q, &wait);  
  17.         spin_unlock_irqrestore(&q->lock, flags);  
  18.   
  19.         return timeout;  
  20. }  
static long __sched
sleep_on_common(wait_queue_head_t *q, int state, long timeout)
{
        unsigned long flags;
        wait_queue_t wait;

        init_waitqueue_entry(&wait, current);

        __set_current_state(state);

        spin_lock_irqsave(&q->lock, flags);
        __add_wait_queue(q, &wait);
        spin_unlock(&q->lock);
        timeout = schedule_timeout(timeout);
        spin_lock_irq(&q->lock);
        __remove_wait_queue(q, &wait);
        spin_unlock_irqrestore(&q->lock, flags);

        return timeout;
}
实现思想与前面所说的都差不多，代码也比较简单，这里就不详细分析了。

在许多的设备驱动中，并不调用sleep_on()或interruptible_sleep_on()，而是亲自进行进程的状态改变和切换，这样代码的效率比较高，下面我们根据前面的globlemem虚拟字符设备驱动的例子来进行改进，增加队列等待机制，可以对照之前的代码来看加入阻塞访问前后的区别。

首先定义设备结构体，添加了r_wait和w_wait两个读写的等待队列头：

[cpp] view plain copy print ?
  1. struct globalmem_dev{  
  2.         struct cdev cdev;  
  3.     unsigned int current_len;  
  4.         unsigned char mem[GLOBALMEM_SIZE];  
  5.     struct semaphore sem;  
  6.     wait_queue_head_t r_wait;  
  7.     wait_queue_head_t w_wait;  
  8. };  
struct globalmem_dev{
        struct cdev cdev;
	unsigned int current_len;
        unsigned char mem[GLOBALMEM_SIZE];
	struct semaphore sem;
	wait_queue_head_t r_wait;
	wait_queue_head_t w_wait;
};
自然还需要在初始化模块里面进行初始化：

[cpp] view plain copy print ?
  1. int globalmem_init(void)  
  2. {  
  3.         int result;  
  4.         dev_t devno=MKDEV(globalmem_major,0);  
  5.   
  6.         if(globalmem_major)  
  7.                 result=register_chrdev_region(devno,1,"globalmem");  
  8.         else{  
  9.                 result=alloc_chrdev_region(&devno,0,1,"globalmem");  
  10.                 globalmem_major=MAJOR(devno);  
  11.         }  
  12.         if(result<0)  
  13.                 return result;  
  14.   
  15.         globalmem_devp = kmalloc(sizeof(struct globalmem_dev),GFP_KERNEL);  
  16.     if(!globalmem_devp){  
  17.         result = -ENOMEM;  
  18.         goto fail_malloc;  
  19.     }  
  20.   
  21.     memset(&globalmem_devp,0,sizeof(struct globalmem_dev));  
  22.   
  23.         globalmem_setup_cdev(&globalmem_devp,0);  
  24.     init_MUTEX(&globalmem_devp->sem);  
  25.     init_waitqueue_head(&globalfifo_devp->r_wait);     //初始化读等待队列  
  26.     init_waitqueue_head(&globalfifo_devp->w_wait);    //初始化写等待队列  
  27.   
  28.         return 0;  
  29.   
  30. fail_malloc:  
  31.     unregister_chrdev_region(devno,1);  
  32.     return result;  
  33. }  
int globalmem_init(void)
{
        int result;
        dev_t devno=MKDEV(globalmem_major,0);

        if(globalmem_major)
                result=register_chrdev_region(devno,1,"globalmem");
        else{
                result=alloc_chrdev_region(&devno,0,1,"globalmem");
                globalmem_major=MAJOR(devno);
        }
        if(result<0)
                return result;

       	globalmem_devp = kmalloc(sizeof(struct globalmem_dev),GFP_KERNEL);
	if(!globalmem_devp){
		result = -ENOMEM;
		goto fail_malloc;
	}

	memset(&globalmem_devp,0,sizeof(struct globalmem_dev));

        globalmem_setup_cdev(&globalmem_devp,0);
	init_MUTEX(&globalmem_devp->sem);
	init_waitqueue_head(&globalfifo_devp->r_wait);     //初始化读等待队列
	init_waitqueue_head(&globalfifo_devp->w_wait);    //初始化写等待队列

        return 0;

fail_malloc:
	unregister_chrdev_region(devno,1);
	return result;
}
下面在继续修改读写模块：

[cpp] view plain copy print ?
  1. static ssize_t globalmem_read(struct file *filp,char __user *buf,size_t count,loff_t *ppos)  
  2. {  
  3.     unsigned long p = *ppos;  
  4.     int ret = 0;  
  5.     struct globalmem_dev *dev = filp->private_data;  
  6.     DECLARE_WAITQUEUE(wait,cuerrent);      
  7.       
  8.     down(&dev->sem);  
  9.     add_wait_queue(&dev->r_wait,&wait);  
  10.   
  11.     while(dev->current_len==0){  
  12.         if(filp->f_flags & O_NONBLOCK){  
  13.             ret = -EAGAIN;  
  14.             goto out;         
  15.         }  
  16.         __set_current_state(TASK_INTERRUPTIBLE);  
  17.         up(&dev->sem);  
  18.   
  19.         schedule();  
  20.         if(signal_pending(current)){  
  21.             ret = -ERESTARTSYS;  
  22.             goto out2;    
  23.         }     
  24.           
  25.         down(&dev->sem);  
  26.     }  
  27.       
  28.     if(count > dev->current_len)  
  29.         count = dev->current_len;  
  30.     if(copy_to_user(buf,dev->mem,count)){  
  31.         ret = -EFAULT;  
  32.         goto out;     
  33.     }else{  
  34.         memcpy(dev->mem,dev->mem+count,dev->current_len-count);  
  35.         dev->current_len -= count;  
  36.         printk(KERN_INFO "read %d bytes(s),current_len:%d\n",count,dev->current_len);  
  37.   
  38.         wake_up_interruptible(&dev->w_wait);  
  39.           
  40.         ret = count;              
  41.     }  
  42.     out:up(&dev->sem);  
  43.     out2:remove_wait_queue(&dev->r_wait,&wait);  
  44.     set_current_state(TASK_RUNNING);  
  45.     return ret;  
  46. }  
static ssize_t globalmem_read(struct file *filp,char __user *buf,size_t count,loff_t *ppos)
{
	unsigned long p = *ppos;
	int ret = 0;
	struct globalmem_dev *dev = filp->private_data;
	DECLARE_WAITQUEUE(wait,cuerrent);    
	
	down(&dev->sem);
	add_wait_queue(&dev->r_wait,&wait);

	while(dev->current_len==0){
		if(filp->f_flags & O_NONBLOCK){
			ret = -EAGAIN;
			goto out;		
		}
		__set_current_state(TASK_INTERRUPTIBLE);
		up(&dev->sem);

		schedule();
		if(signal_pending(current)){
			ret = -ERESTARTSYS;
			goto out2;	
		}	
		
		down(&dev->sem);
	}
	
	if(count > dev->current_len)
		count = dev->current_len;
	if(copy_to_user(buf,dev->mem,count)){
		ret = -EFAULT;
		goto out;	
	}else{
		memcpy(dev->mem,dev->mem+count,dev->current_len-count);
		dev->current_len -= count;
		printk(KERN_INFO "read %d bytes(s),current_len:%d\n",count,dev->current_len);

		wake_up_interruptible(&dev->w_wait);
		
		ret = count;			
	}
	out:up(&dev->sem);
	out2:remove_wait_queue(&dev->r_wait,&wait);
	set_current_state(TASK_RUNNING);
	return ret;
}
[cpp] view plain copy print ?
  1. static ssize_t globalmem_write(struct file *filp,const char __user *buf,size_t count,loff_t *ppos)  
  2. {  
  3.     unsigned long p = *ppos;  
  4.     int ret = 0;  
  5.     struct globalmem_dev *dev = filp->private_data;  
  6.     DECLARE_WAITQUEUE(wait,cuerrent);      
  7.       
  8.     down(&dev->sem);  
  9.     add_wait_queue(&dev->w_wait,&wait);  
  10.   
  11.     while(dev->current_len==GLOBALFIFO_SIZE){  
  12.         if(filp->f_flags & O_NONBLOCK){  
  13.             ret = -EAGAIN;  
  14.             goto out;         
  15.         }  
  16.         __set_current_state(TASK_INTERRUPTIBLE);  
  17.         up(&dev->sem);  
  18.   
  19.         schedule();  
  20.         if(signal_pending(current)){  
  21.             ret = -ERESTARTSYS;  
  22.             goto out2;    
  23.         }     
  24.           
  25.         down(&dev->sem);  
  26.     }  
  27.       
  28.     if(count > GLOBALFIFO_SIZE-dev->current_len)  
  29.         count = GLOBALFIFO-dev->current_len;  
  30.     if(copy_from_user(dev->mem+dev->current_len,buf,count)){  
  31.         ret = -EFAULT;  
  32.         goto out;     
  33.     }else{  
  34.         dev->current_len += count;  
  35.         printk(KERN_INFO "written %d bytes(s),current_len:%d\n",count,dev->current_len);  
  36.   
  37.         wake_up_interruptible(&dev->r_wait);  
  38.           
  39.         ret = count;              
  40.     }  
  41.     out:up(&dev->sem);  
  42.     out2:remove_wait_queue(&dev->w_wait,&wait);  
  43.     set_current_state(TASK_RUNNING);  
  44.     return ret;  
  45. }  
static ssize_t globalmem_write(struct file *filp,const char __user *buf,size_t count,loff_t *ppos)
{
	unsigned long p = *ppos;
	int ret = 0;
	struct globalmem_dev *dev = filp->private_data;
	DECLARE_WAITQUEUE(wait,cuerrent);    
	
	down(&dev->sem);
	add_wait_queue(&dev->w_wait,&wait);

	while(dev->current_len==GLOBALFIFO_SIZE){
		if(filp->f_flags & O_NONBLOCK){
			ret = -EAGAIN;
			goto out;		
		}
		__set_current_state(TASK_INTERRUPTIBLE);
		up(&dev->sem);

		schedule();
		if(signal_pending(current)){
			ret = -ERESTARTSYS;
			goto out2;	
		}	
		
		down(&dev->sem);
	}
	
	if(count > GLOBALFIFO_SIZE-dev->current_len)
		count = GLOBALFIFO-dev->current_len;
	if(copy_from_user(dev->mem+dev->current_len,buf,count)){
		ret = -EFAULT;
		goto out;	
	}else{
		dev->current_len += count;
		printk(KERN_INFO "written %d bytes(s),current_len:%d\n",count,dev->current_len);

		wake_up_interruptible(&dev->r_wait);
		
		ret = count;			
	}
	out:up(&dev->sem);
	out2:remove_wait_queue(&dev->w_wait,&wait);
	set_current_state(TASK_RUNNING);
	return ret;
}
其并没有调用seelp_on()等函数，选择自己设置状态以及进程的切换等动作。将上述的过程用wait_event_interruptible()函数替换的话，可能会出现死锁的状态，可以自己思考一下这个过程。上面读缓冲区的数据需要在写函数中唤醒r_wait，才可以进行读的操作，而进行写的过程需要在读函数中唤醒w_wait才可以写入。

转自：http://blog.csdn.net/wanchres/article/details/7109198
gongmin856
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Linux驱动开发之旅（四）－－设备的阻塞操作
01-03
Linux驱动开发之旅（四）－－设备的阻塞操作,包括可用代码文档及相应的参考资料
linux设备驱动开发-设备阻塞访问的简单实现
mj5742356的专栏
06-23 492
当我们读取一个空的命名管道文件是，会阻塞等待，知道有新数据写入管道中。
驱动：8.1设备的阻塞方式访问
奇怪的博客
06-17 187
用户空间：recv/accept fd = open("/dev/mybuttons",…); read(fd,buf,len);//有数据读，无数据等待 驱动程序： 要是实现设备的阻塞方式操作，要使用内核中的等待队列机制 等待队列的核心数据结构： struct __wait_queue_head { spinlock_t lock; struct list_head task_list; }; typedef struct __wait_queue_head wait_queue_head_t;
linux 设备驱动阻塞,Linux设备驱动中的阻塞与非阻塞I/O
weixin_30415591的博客
05-07 169
阻塞与非阻塞I/O阻塞操作是指在执行设备操作时若不能获得资源则挂起进程，直到满足可操作的条件后再进行操作。因为阻塞的进程会进入休眠状态，因此，必须确保有一个地方能够唤醒休眠的进程。唤醒进程的地方最大可能发生在中断里面，因为硬件资源获得的同时往往伴随着一个中断。注意：驱动程序需要提供阻塞(等待队列，中断)和非阻塞方式(轮询，异步通知)访问设备。休眠(被阻塞)的进程处于一个特殊的不可执行状态。这点非常...
深入linux设备驱动程序内核机制(第四章) 读书笔记
随风
06-09 2816
第四章 互斥与同步     本文欢迎大家转载     原文出自: http://blog.csdn.net/dyron 4.1 并发的来源     并发, 是指可能导致对共享资源的访问出现竞争状态的若干执行路径, 不一定是指严格的时间意义上的并发执行     linux系统下并发的来源主要有:     . 中断处理路径     当系统正在执行当前进程时, 发生中断,
ZYNQ 7010-7020实现阻塞IO访问（Linux驱动）.zip
03-21
这个名为"ZYNQ 7010-7020实现阻塞IO访问（Linux驱动）.zip"的压缩包文件显然包含了与Zynq 7010和7020设备相关的Linux驱动程序源代码，旨在实现阻塞I/O（Input/Output）访问。阻塞I/O是一种常见的I/O模型，当进程发起...
i.MX6ULL实现阻塞IO访问【Linux驱动】.zip
02-21
i.MX6ULL是一款基于ARM Cortex-A7架构的低功耗微处理器，常用于...通过分析和理解项目代码，可以学习到如何为特定硬件编写Linux驱动程序，掌握阻塞I/O模型的运用，这对于理解和定制嵌入式系统的底层功能非常有帮助。
ZYNQ 7010-7020实现非阻塞IO访问（Linux驱动）.zip
03-21
本项目提供的ZynQ 7010-7020 Linux驱动库应该包含了上述所有组件的实现，通过编译运行项目代码，开发者可以学习如何在Zynq平台上有效地实现非阻塞I/O访问，从而优化系统的效率和响应性。对于那些需要高效处理来自...
i.MX6ULL实现非阻塞IO访问【Linux驱动】.zip
02-21
通过理解和掌握上述知识点，开发者可以编写出高效、可靠的i.MX6ULL Linux驱动程序，实现对硬件的非阻塞I/O访问，充分利用硬件资源，提高系统的并发性和响应速度。项目的代码可以直接编译运行，为学习和实践提供了...
Linux设备驱动中的阻塞和非阻塞I/O
01-20
写的是Linux设备驱动中的阻塞和非阻塞I/0，何谓阻塞与非阻塞I/O？简单来说是对I/O操作的两种不同的方式，驱动程序可以灵活的支持用户空间对设备的这两种访问方式。 　一、基本概念： 　阻塞操作：是指在执行设备...
Linux GPIO 注册和应用
weixin_34279579的博客
09-09 120
Linux GPIO 注册和应用 Linux Kernel, GPIO, ARM 于Linux kernel代码。经常使用 GPIO 作为一个特殊的信号，如芯片片选信号。 GPIO 功能应用，我们经常使用的。例如 gpio_request ，那么 GPIO 是何时，以及怎样注冊的。本文就来探索一下。 基于的平台上 freesccale 的 i.MX6 先从函数 gpio_requ...
Linux设备驱动——阻塞型I/O
雪狼的博客
12-03 386
Linux设备驱动——阻塞型I/O
linux驱动之阻塞与休眠
qq_40684669的博客
11-09 506
在休眠与唤醒的基础上, 获取应用程序意图(阻塞读取/非阻塞读取), 来决定是否休眠
Linux设备驱动中的阻塞与非阻塞I/O
ljl113的博客
12-14 550
;//定义等待队列头部};//定义并初始化一个名为name的等待队列元素/* 参数name：等待队列项的名字* 参数tsk：表示等待队列项属于哪个任务，一般设置为current（表示当前进程）*/
linux设备驱动中的阻塞与非阻塞（一）
u011756766的博客
11-23 3110
这两天在搞linux驱动的阻塞和非阻塞，困扰了两天，看了不少博客，有了点自己的想法，也不知是否对错，但还是写写吧，让各位大神给我指点指点。         首先说说什么是阻塞和非阻塞的概念：阻塞操作就是指进程在操作设备时，由于不能获取资源或者暂时不能操作设备时，系统就会把进程挂起，被挂起的进程会进入休眠状态并且会从调度器的运行队列移走，放到等待队列中，然后一直休眠，直到该进程满足可操作的条件，再
从零开始之驱动发开、linux驱动（十九、阻塞和非阻塞IO）
To_run_away的博客
09-21 1557
阻塞和非阻塞I/O是设备访问的两种不同模式， 驱动程序可以灵活地支持这两种用户空间对设备的访问方式。   阻塞操作是指在执行设备操作时， 若不能获得资源， 则挂起进程直到满足可操作的条件后再进行操作。 被挂起的进程进入睡眠状态， 被从调度器的运行队列移走， 直到等待的条件被满足。 而非阻塞操作的进程在不能进行设备操作时， 并不挂起， 它要么放弃， 要么不停地查询， 直至可以进行操作为止。   ...
Linux内核的驱动阻塞机制
qq_44194231的博客
07-01 727
什么叫阻塞，阻塞就是执行操作的时候，如果条件不满足则进程挂起，进入睡眠状态，知道等待的条件满足。 阻塞的实现机制，应用程序是无法实现阻塞的，进程阻塞是通过Linux内核的等待队列来实现的。如果像将一个进程阻塞，就将它放入等待队列中，运行条件不满足的时候就将等待队列上的进程睡眠，实现阻塞的目的。 实现函数： 1.DECLARE_WAIT_QUEUE_HEAD(myQueue); 功能描述：定义一个等待队列头结点并初始化（相当于链式队列的头结点） 2.DECLARE_WAITQUEUE(name,curr.
Linux设备驱动中的阻塞和非阻塞IO
shenyeaxu的博客
07-09 759
这篇文章我们来了解下Linux设备驱动中阻塞和非阻塞。 阻塞：阻塞是指执行设备操作时，如果不能获得设备资源，则挂起进程，是进程进入休眠模式，直到设备资源可以获取。 非阻塞：非阻塞是在不能获取设备资源时，要么放弃获取，要么一直不停的查询，直到可以获取资源。 这两种操作能够为为应用程序提供这样的能力： （1）当应用程序对设备资源进行read(), write()操作时，如果设备资源不能获取，用...
Linux字符设备驱动机制探索论文.doc
最新发布
07-07
这篇论文深入探讨了Linux操作系统中的字符设备驱动机制，适合学习Linux内核设计与实现的学生参考。作者王华山在计算机科学与技术专业背景下，详细阐述了字符设备的基本概念、相关数据结构、驱动实例、并发控制以及...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值