【驱动】TP电容屏驱动—2.互斥锁lock的学习笔记

函数 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
/**  
 * mutex_init - initialize the mutex  
 * @mutex: the mutex to be initialized  
 *  
 * Initialize the mutex to unlocked state.  初始化互斥锁到解锁状态。
 *  
 * It is not allowed to initialize an already locked mutex.  不允许初始化已锁定的互斥锁。
 */  
# define mutex_init(mutex) \  
do {                            \  
    static struct lock_class_key __key;     \  
                            \  
    __mutex_init((mutex), #mutex, &__key);      \  
} while (0)  


void  
__mutex_init(struct mutex *lock, const char *name, struct lock_class_key *key)  
{  
    atomic_set(&lock->count, 1);  
    spin_lock_init(&lock->wait_lock);  
    INIT_LIST_HEAD(&lock->wait_list);  
    mutex_clear_owner(lock);  
#ifdef CONFIG_MUTEX_SPIN_ON_OWNER  
    lock->spin_mlock = NULL;  
#endif  
  
    debug_mutex_init(lock, name, key);  
}  

　　

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

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

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

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

[html] view plain copy
/**  
 * mutex_lock - acquire the mutex  获得互斥锁
 * @lock: the mutex to be acquired  
 *  
 * Lock the mutex exclusively for this task. If the mutex is not  
 * available right now, it will sleep until it can get it.  锁定这个任务专用的互斥锁。如果互斥对象不是可用的，它会一直睡到它可以得到它。  

 * The mutex must later on be released by the same task that  
 * acquired it. Recursive locking is not allowed. The task  
 * may not exit without first unlocking the mutex. Also, kernel  
 * memory where the mutex resides mutex must not be freed with  
 * the mutex still locked. The mutex must first be initialized  
 * (or statically defined) before it can be locked. memset()-ing  
 * the mutex to 0 is not allowed.  
 *  
 * ( The CONFIG_DEBUG_MUTEXES .config option turns on debugging  
 *   checks that will enforce the restrictions and will also do  
 *   deadlock debugging. )  
 *  
 * This function is similar to (but not equivalent to) down().  
 */  
void __sched mutex_lock(struct mutex *lock)  
{  
    might_sleep();  
    /*  
     * The locking fastpath is the 1->0 transition from  
     * 'unlocked' into 'locked' state.  
     */  
    __mutex_fastpath_lock(&lock->count, __mutex_lock_slowpath);  
    mutex_set_owner(lock);  
}  

　　

3. mutex_unlock(), 释放互斥体
a. 释放之前获得的mutex；

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

[html] view plain copy
/**  
 * mutex_unlock - release the mutex  
 * @lock: the mutex to be released  
 *  
 * Unlock a mutex that has been locked by this task previously.  
 *  
 * This function must not be used in interrupt context. Unlocking  
 * of a not locked mutex is not allowed.  
 *  
 * This function is similar to (but not equivalent to) up().  
 */  
void __sched mutex_unlock(struct mutex *lock)  
{  
    /*  
     * The unlocking fastpath is the 0->1 transition from 'locked'  
     * into 'unlocked' state:  
     */  
#ifndef CONFIG_DEBUG_MUTEXES  
    /*  
     * When debugging is enabled we must not clear the owner before time,  
     * the slow path will always be taken, and that clears the owner field  
     * after verifying that it was indeed current.  
     */  
    mutex_clear_owner(lock);  
#endif  
    __mutex_fastpath_unlock(&lock->count, __mutex_unlock_slowpath);  
}  

 

————————————————
版权声明：本文为CSDN博主「Jarry_le」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/u011677209/article/details/77600575