函数 mutex_init() / mutex_lock() / mutex_unlock()

1. 初始化互斥体 -- mutex_init()；

2. 获得互斥体 -- mutex_lock()；

3. 释放互斥体 -- mutex_unlock()；

mutex不能使用在 中断的上下文 中。

1. mutex_init(), 注意mutex使用之前都需要先init

[html]  view plain  copy

1. /**  
2.  * mutex_init - initialize the mutex  
3.  * @mutex: the mutex to be initialized  
4.  *  
5.  * Initialize the mutex to unlocked state.  
6.  *  
7.  * It is not allowed to initialize an already locked mutex.  
8.  */  
9. # define mutex_init(mutex) \  
10. do {                            \  
11.     static struct lock_class_key __key;     \  
12.                             \  
13.     __mutex_init((mutex), #mutex, &__key);      \  
14. } while (0)  

[html]  view plain  copy

1. void  
2. __mutex_init(struct mutex *lock, const char *name, struct lock_class_key *key)  
3. {  
4.     atomic_set(&lock->count, 1);  
5.     spin_lock_init(&lock->wait_lock);  
6.     INIT_LIST_HEAD(&lock->wait_list);  
7.     mutex_clear_owner(lock);  
8. #ifdef CONFIG_MUTEX_SPIN_ON_OWNER  
9.     lock->spin_mlock = NULL;  
10. #endif  
11.   
12.     debug_mutex_init(lock, name, key);  
13. }  

2. mutex_lock(), 注意看注释说明，

a. 如果mutex已经被其他task获取，那么目前的task先sleep直到获取；

b. mutex不能被嵌套获取；上一个task释放mutex之后，才能被其他的task获取；

c. mutex要先被初始化才能使用；mutex正在使用过程中，其内存不能被释放；

[html]  view plain  copy

1. /**  
2.  * mutex_lock - acquire the mutex  
3.  * @lock: the mutex to be acquired  
4.  *  
5.  * Lock the mutex exclusively for this task. If the mutex is not  
6.  * available right now, it will sleep until it can get it.  
7.  *  
8.  * The mutex must later on be released by the same task that  
9.  * acquired it. Recursive locking is not allowed. The task  
10.  * may not exit without first unlocking the mutex. Also, kernel  
11.  * memory where the mutex resides mutex must not be freed with  
12.  * the mutex still locked. The mutex must first be initialized  
13.  * (or statically defined) before it can be locked. memset()-ing  
14.  * the mutex to 0 is not allowed.  
15.  *  
16.  * ( The CONFIG_DEBUG_MUTEXES .config option turns on debugging  
17.  *   checks that will enforce the restrictions and will also do  
18.  *   deadlock debugging. )  
19.  *  
20.  * This function is similar to (but not equivalent to) down().  
21.  */  
22. void __sched mutex_lock(struct mutex *lock)  
23. {  
24.     might_sleep();  
25.     /*  
26.      * The locking fastpath is the 1->0 transition from  
27.      * 'unlocked' into 'locked' state.  
28.      */  
29.     __mutex_fastpath_lock(&lock->count, __mutex_lock_slowpath);  
30.     mutex_set_owner(lock);  
31. }  

3. mutex_unlock(), 释放互斥体

a. 释放之前获得的mutex；

b. mutex只有被获得，才能调用这个函数来释放；换言之，如果没有获得，就没有必要做释放的动作；

[html]  view plain  copy

1. /**  
2.  * mutex_unlock - release the mutex  
3.  * @lock: the mutex to be released  
4.  *  
5.  * Unlock a mutex that has been locked by this task previously.  
6.  *  
7.  * This function must not be used in interrupt context. Unlocking  
8.  * of a not locked mutex is not allowed.  
9.  *  
10.  * This function is similar to (but not equivalent to) up().  
11.  */  
12. void __sched mutex_unlock(struct mutex *lock)  
13. {  
14.     /*  
15.      * The unlocking fastpath is the 0->1 transition from 'locked'  
16.      * into 'unlocked' state:  
17.      */  
18. #ifndef CONFIG_DEBUG_MUTEXES  
19.     /*  
20.      * When debugging is enabled we must not clear the owner before time,  
21.      * the slow path will always be taken, and that clears the owner field  
22.      * after verifying that it was indeed current.  
23.      */  
24.     mutex_clear_owner(lock);  
25. #endif  
26.     __mutex_fastpath_unlock(&lock->count, __mutex_unlock_slowpath);  
27. }