Senghoo's Blog

#include <asm/semaphore.h>  /*信号量相关头文件*/
struct semaphore		/*信号量相关结构体*/
/*初始化相关函数*/
void  sema_init(struct semaphore *sem,int val); 
/*初始化信号量函数*/
DECLARE_MUTEX(name);	/*创建互斥体并初始化为1*/
DECLARE_MUTEX_LOCKED(name);	/*创建互斥体并初始化为0*/
void init_MUTEX(struct semaphore *sem); /*初始化互斥体为1*/
void init_MUTEX_LOCKED(struct semaphore *sem); /*初始化互斥体为0*/
/*down&up 相关函数*/
void down(struct semaphore *sem); /*不可中断*/
int down_interruptible(struct semaphore *sem); /*可中断*/
int down_trylock(struct semaphore *sem); /*立即退出*/
void up(struct semaphore *sem); /*释放信号量*/

#include <linux/rwsem.h> 	/*相关头文件*/
struct rw_semaphore		/*相关结构体*/
void init_rwsem(struct rw_semaphore *sem);	/*初始化信号量*/
void down_read(struct rw_semaphore *sem);	/*获取读取者信号量*/
int down_read_trylock(struct rw_semaphore *sem);	/*获取读取者信号量失败立即退出*/
void up_read(struct rw_semaphore *sem);	/*释放读取者信号量*/
void down_write(struct rw_semaphore *sem);	/*获取写入者信号量*/
int down_write_trylock(struct rw_semaphore *sem);	/*获取写入者信号量失败立即退出*/
void up_write(struct rw_semaphore *sem);	/*释放写入者信号量*/
void downgrade_write(struct rw_semaphore *sem);/*释放写入者权限*/

#include <linux/completion.h>
DECLARE_COMPLETION(my_completion);	 /*创建completion*/
struct completion my_completion;	/*结构体*/
void wait_for_completion(struct completion *c); /*等待完成*/
void complete(struct completion *c);	/*触发一个等待*/
void complete_all(struct completion *c);	/*出发所有等待*/

....
DECLARE_COMPLETION(my_completion);
start_external_task(&my_completion);
void wait_for_completion(&my_completion);
....

/*需要的头文件和两种初始化自旋锁的方法。
使用宏在编译时直接初始化。
而使用函数是在运行时初始化*/
#include <linux/spinlock.h>
spinlock_t lock = SPIN_LOCK_UNLOCKED;
void spin_lock_init(spinlock_t *lock);
/*分别为：
获得锁。
获得锁并禁用中断，中断状态保存你在flags中。
获得锁并禁用中断，不保存状态，必须保证没有其他代码禁用中断
获得锁并禁用软中断，硬中断工作正常。
*/
void spin_lock(spinlock_t *lock);
void spin_lock_irqsave(spinlock_t *lock, unsigned long flags);
void spin_lock_irq(spinlock_t *lock);
void spin_lock_bh(spinlock_t *lock);
/*下面四个函数和上面的函数一一对应用于释放锁。*/
void spin_unlock(spinlock_t *lock);
void spin_unlock_irqrestore(spinlock_t *lock, unsigned long flags);
void spin_unlock_irq(spinlock_t *lock);
void spin_unlock_bh(spinlock_t *lock);
/*
*/
int spin_trylock(spinlock_t *lock);
int spin_trylock_bh(spinlock_t *lock);

rwlock_t lock = RW_LOCK_UNLOCKED
rwlock_init(rwlock_t *lock);
void read_lock(rwlock_t *lock);
void read_lock_irqsave(rwlock_t *lock, unsigned long flags);
void read_lock_irq(rwlock_t *lock);
void read_lock_bh(rwlock_t *lock);
void read_unlock(rwlock_t *lock);
void read_unlock_irqrestore(rwlock_t *lock, unsigned long flags);
void read_unlock_irq(rwlock_t *lock);
void read_unlock_bh(rwlock_t *lock);
void write_lock(rwlock_t *lock);
void write_lock_irqsave(rwlock_t *lock, unsigned long flags);
void write_lock_irq(rwlock_t *lock);
void write_lock_bh(rwlock_t *lock);
void write_unlock(rwlock_t *lock);
void write_unlock_irqrestore(rwlock_t *lock, unsigned long flags);
void write_unlock_irq(rwlock_t *lock);
void write_unlock_bh(rwlock_t *lock);