linux驱动中的阻塞访问方式

最新推荐文章于 2022-10-25 15:40:24 发布
最新推荐文章于 2022-10-25 15:40:24 发布
阅读量844 收藏 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
    评论
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模型，当进程发起...
linux设备驱动--阻塞IO
BaikalHU
03-12 2099
阻塞与非阻塞IO与进程的调度密切相关，但是深入的进程调度的算法还不到时间去研究，因为个人的方针是先以设备模型和文件系统为突破口，循序渐进。        这个并不妨碍目前对设备驱动中的阻塞与非阻塞IO的理解。        阻塞操作是指在执行设备操作时，若不能获得资源，则挂起进程直到满足可操作的条件后再进行操作。被挂起的进程进入休眠状态，被从调度器的运行队列移走，直到等待的条件被满足。
Linux GPIO 注册和应用
weixin_34279579的博客
09-09 125
Linux GPIO 注册和应用 Linux Kernel, GPIO, ARM 于Linux kernel代码。经常使用 GPIO 作为一个特殊的信号，如芯片片选信号。 GPIO 功能应用，我们经常使用的。例如 gpio_request ，那么 GPIO 是何时，以及怎样注冊的。本文就来探索一下。 基于的平台上 freesccale 的 i.MX6 先从函数 gpio_requ...
linux内核中断实践3：工作队列
10-25 579
linux内核中断实践3：工作队列
深入linux设备驱动程序内核机制(第四章) 读书笔记
随风
06-09 2820
第四章 互斥与同步     本文欢迎大家转载     原文出自: http://blog.csdn.net/dyron 4.1 并发的来源     并发, 是指可能导致对共享资源的访问出现竞争状态的若干执行路径, 不一定是指严格的时间意义上的并发执行     linux系统下并发的来源主要有:     . 中断处理路径     当系统正在执行当前进程时, 发生中断,
Linux设备驱动——阻塞型I/O
雪狼的博客
12-03 389
Linux设备驱动——阻塞型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驱动开发之旅（四）－－设备的阻塞操作
01-03
Linux驱动开发之旅（四）－－设备的阻塞操作,包括可用代码文档及相应的参考资料
linux设备驱动开发-设备阻塞访问的简单实现
mj5742356的专栏
06-23 494
当我们读取一个空的命名管道文件是，会阻塞等待，知道有新数据写入管道中。
Linux 设备驱动中的阻塞与非阻塞 I/O
Leon的博客
12-02 1113
阻塞操作是指在执行设备操作时若不能获得资源则挂起进程，直到满足可操作的条件后再进行操作。被挂起的进程进入休眠状态，被从调度器的运行队列移走，直到等待的条件被满足。而非阻塞操作的进程在不能进行设备操作时并不挂起，它或者放弃，或者不停地查询，直至可以进行操作为止。 阻塞从字面上听起来似乎意味着低效率，实则不然，如果设备驱动不阻塞，则用户想获取设备资源只能不停地查询，这反而会无谓地耗费 CPU 资源。而阻塞访问时，不能获取资源的进程将进入休眠，它将 CPU 资源让给其他进程。因为阻塞的进程会进入休眠状态，因此，必
嵌入式Linux 阻塞和非阻塞 IO 驱动设备访问模式
yangxueyangxue的博客
01-25 431
阻塞和非阻塞 IO 是 Linux 驱动开发里面很常见的两种设备访问模式， 在编写驱动的时候一定要考虑到阻塞和非阻塞。
【Linux驱动开发】阻塞和非阻塞IO
ty的博客
04-25 577
阻塞和非阻塞IO；等待队列，等待队列项，等待队列头，等待事件，等待唤醒；轮询，select，poll，epoll
linux设备驱动程序中的阻塞机制
xiaohaozi7107的专栏
06-14 469
阻塞与非阻塞是设备访问的两种方式。在写阻塞与非阻塞的驱动程序时，经常用到等待队列。 一、阻塞与非阻塞 　　阻塞调用是指调用结果返回之前，当前线程会被挂起，函数只有在得到结果之后才会返回。 　　非阻塞指不能立刻得到结果之前，该函数不会阻塞当前进程，而会立刻返回。 　　对象是否处于阻塞模式和函数是不是阻塞调用有很强的相关性，但并不是一一对应的。阻塞对象上可以有非阻塞的调用方式，我们可以通过
驱动：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驱动开发（5、使用leds驱动框架点亮led灯）
漫长当下
08-27 3163
文章目录使用驱动框架的优势leds驱动框架相关 在前面已经用创建通用字符设备的方式完成了led的操作，本次总结记录的是使用linux内核提供的leds驱动框架来点亮led灯。 使用驱动框架的优势 linux内核为各种硬件进行分类，然后针对各类硬件实现一套比较标准的驱动框架，其中每类硬件共有属性那一部分由内核开发者负责实现和维护，然后给驱动开发者留出接口用来完成具体硬件的特定操作部分。更加简化了驱动开发者的编码工作。 leds驱动框架相关 相关的源代码位于drivers/leds/目录内，头文件位于inclu
linux中的阻塞IO驱动和非阻塞NIO驱动
wangjie36的博客
05-15 1139
IO操作的两个阶段先查询再读写，而非阻塞IO在查询阶段的处理和阻塞 IO不同。应用程序需要迕行 IO 操 作前，先发起查询，驱劢程序根据数据情况返回查询结果，如果返回查询结果NG，应用程序就不执行读写操作了。如果应用程序非要读写的话，就继续去查询，直到驱动程序返回数据准备完成，才会做下一步的读写操作。非阻塞IO的处理方式是轮询。linux 中提供了应用程序的轮询机制和相应的驱动程序系统调用。驱动程序中的poll函数。等待待队列也就是进程组成的队列，linux 在系统执行会根据不同的状态把进程分成不同的队列。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值