Chinaunix首页 | 论坛 | 博客
  • 博客访问: 103819
  • 博文数量: 76
  • 博客积分: 0
  • 博客等级: 民兵
  • 技术积分: 440
  • 用 户 组: 普通用户
  • 注册时间: 2014-05-20 14:21
文章分类

全部博文(76)

文章存档

2015年(76)

我的朋友

分类: 其他平台

2015-03-23 08:45:57

继续敲《LINUX设备驱动开发详解》中的信号量机制的中心内容,版权所有,我是抄他的~~~


信号量是用于保护临界区的一种常用方法,他的使用方法和自旋锁类似,只要获得了信号量的进程才能执行临界区代码,不同的是,当无法获得信号量时,进程不会原地打转,而是进入休眠等待状态。

1定义信号量

struct semaphore sem;

2初始化信号量
void sema_init(struct semaphore *sem,int val);
该函数初始化信号量,并设置信号量sem的值为val。尽管信号量可以被初始化为大于1的值从而成为一个计数信号量,但是它通常不被这样使用。

void init_MUTEX(struct semaphore *sem);
该函数用于初始化一个用于互斥的信号量,他把信号量sem的值设置为1,等于sema_init(struct semaphore *sem,1)

void init_MUTEX_LOCKED(struct semphore *sem);
该函数也用于初始化一个信号量,但它把信号量sem的值设置为0,等同于sema_init(struct semaphore *sem,0)

此外,还定义了两个宏,定义并初始化信号量的快捷方式:
DECLARE_MUTEX(name);
DECLARE_MUTEX_LOCKED(name);
前者定义一个名为name的信号量,并初始化为1,后者定义一个name的信号量,并初始化为0.

3获得信号量
void down(struct semaphore *sem)
该函数用于获得信号量sem,它会导致睡眠,因此不能在中断上下文使用。

int down_interruptible(struct semaphore *sem)
该函数功能与down类似,不同之处是,因为down()而进入睡眠状态的进程不能被信号打断,而因为down_interruptible()而进入睡眠状态的进程能被信号所打断,信号也会导致该函数返回,这时返回值为非0.   
在使用down_interruptible()获得信号量时,对返回值一般会进行检查,如果,非0,通常立刻返回-ERESTARTSYS;
if(down_interruptible(&sem))
{
return -ERESTARTSYS;
}

int down_trylock(struct semaphore *sem)
该函数尝试获得信号量sem,如果能立刻获得,他就获得改信号量,并返回0,否则,返回非0值,它不会导致调用者睡眠,可以在中断上下文使用。
信号量的使用方法如下:
//定义信号量
DECLARE_MUTEX(sem);
down(&sem);  //获得信号量,保护临界区
...
...//临界区
...
up(&sem);    //释放信号量

使用信号量实现设备只能被一个进程打开
static DECLARE_MUTEX(xxx_lock);   //定义互斥锁
static int xxx_open(struct *inode,struct file *filp)
{
  ...   //试图给进程获得信号量,如果进程获得了信号量,则继续进行别的操作,
if(down_trylock(&xxx_lock))  //获得打开锁
return -EBUSY;  //但如果该共享资源已经被另外互斥锁锁定,则直接返回设备繁忙
  ...
  return 0;
}

static int xxx_release(struct *inode,struct file *filp)
{                   //打开锁
  up(&xxx_lock)  //释放打开锁  
  return 0;
}

信号量的同步
如果信号量被初始化为0,则它可以用于同步,同步意味着一个执行单元的继续执行等待另一个执行单元完成某事,保证执行的先后顺序,
执行单元A                         执行单元B
DECLARE_MUTEX(sem);                                            //该例子中,执行单元A执行代码区域b之前,必须等待执行单元B执行完代码单元c,
代码区域a 
down(&sem);                     代码区域c                       //即执行完 代码区域a时,要先判断 代码区域c是否执行完,完了才能执行区域b
代码区域b                 up(&sem);


完成量用于同步
linux系统中提供了一种比信号量更好的同步机制,即完成量(completion),它用于一个执行单元等待另一个执行单元完成某事。

1定义完成量
struct completion my_completion;

2初始化completion
init_completion(&my_completion);

定义并初始化的快捷方式
DECLARE_COMPLETION(my_completion);

3等待完成量
下面函数用于等待一个completion被唤醒
void wait_for_completion(struct completion *c);  

4唤醒完成量
void complete(struct completion *c);
void complete_all(struct completion *c);



完成量的功能实例,
执行单元A                                       执行单元B
DECLARE_COMPLETION(my_completion)                                   //在执行单元A执行完代码区域a时,wait_for_completion()会等待执行单元B的
                代码区域a                                       代码区域c              //completion()函数,此函数执行完了才能执行代码区域b
wait_for_completion(&my_completion)           completion(&com)
代码区域b


自旋锁 和 信号量 的区别
自旋锁和信号量都是解决互斥问题的基本手段,面对特定的情况,应该进行不同的选择。
严格意义上说,信号量和自旋锁属于不同层次的互斥手段,前者的实现依赖于后者,在信号量本身的实现上,为了保证信号量结构存取的原子性,在多CPU中需要自旋锁来互斥。
信号量是进程级的,用于多个进程之间对资源的互斥,虽然也是在内核中,但是该内核执行路径是以进程的身份,代表进程来争夺资源的,。如果竞争失败,会发生进程上下文切换,当前进程进入睡眠状态,,CPU将运行其他进程,鉴于进程上下文切换的开销很大,因此,只有当进程占用资源时间较长时,用信号量才是较好的选择。
当所要保护的临界区访问时间比较短时,用自旋锁是比较方便的,因为它节省了上下文切换的时间,但是CPU得不到自旋锁,会在那里空转直到其他执行单元解锁为止,所以要求锁不能在临界区理长时间停留,否则会降低系统的效率。


因此,自旋锁和信号量的选用有3个规则:
1:当锁不能被获取时,使用信号量的开销是进程上下文的切换时间tsw,使用自旋锁的开销是等待获取自旋锁tcs,若tcs比较小,应使用自旋锁,若tcs很大,应使用信号量。
2:信号量所保护的临界区可包含引起阻塞的代码,而自旋锁则绝对要避免用来保护包含这样代码的临界区,因为阻塞意味着要进行进程的切换,如果进程被切换出去后,另一个进程企图获取本自旋锁,死锁就会发生。
3:信号量存在于进程的上下文中,因此,如果被保护的共享资源需要在中断和软中断情况下使用,则在信号量和自旋锁之间只能选择自旋锁。当然,如果一定要使用信号量,则只能通过down_trylock()方式进行,不能获取就立刻返回以避免阻塞。

读写信号量
读写信号量类似于自旋锁中的读写自旋锁,读写信号量可能引起进程阻塞,但它可允许N个读执行单元同时访问共享资源,而最多只能有一个写执行单元,因此,读写信号量是一种相对放宽条件的粒度稍大于信号量的互斥机制。

1定义和初始化读写信号量
struct rw_semaphore my_rws;    /*定义读写信号量*/
void init_rwsem(struct rw_semaphore *my_rws); /*初始化读写信号量*/

2读信号量的获取
void down_read(struct rw_semaphore *sem);
void down_read_trylock(struct rw_semaphore *sem);

读信号量的释放
void up_read(struct rw_semaphore *sem);

3写信号量的获取
void down_write(struct rw_semaphoe *sem);
void down_write_trylock(struct rw_semaphore *sem);

写信号量的释放
void up_write(struct rw_semaphore *sem);


读写信号量的一般用法:
rw_semaphore rw_sem;    //定义读写信号量
init_rwsem(&rw_sem);    //初始化读写信号量
down_read(&rw_sem); //读时获取信号量
...  //读时临界区                                      //此时允许多个读执行单位进行对共享资源的读操作,但不允许对资源的写操作
up_read(&rw_sem); //释放读信号量
down_write(&rw_sem);    //写时获得信号量
...  //写时临界区
up_write(&rw_sem);      //释放写时信号量


互斥体
在Linux中互斥体mutex是真实存在的。
1定义并初始化互斥体
struct mutex my_mutex;
mutex_init(&my_mutex);
2获得互斥体
void fastcall mutex_lock(struct mutex *lock);
int fastcall mutex_lock_interruptible(struct mutex *lock);
int fastcall mutex_lock_trylock(struct mutex *lock);
mutex_lock()和mutex_lock_interruptible()的区别和down()和down_trylock()的区别完全一致,前者引起的睡眠不能被信号打断,而后者可以。mutex_trylock()用于尝试获得Mutex,获取不到mutex时不会引起进程睡眠。

3释放互斥体
void fastcall mutex_unlcok(struct mutex *lock);

mutex使用的方法和信号量使用的场合完全一致,使用方法为
struct mutex my_mutex;        //定义一个互斥体
init_mutex(&my_mutex);        //初始化一个互斥体
mutex_lock(&my_mutex);       //获取mutex
...  //临界区
mutex_unlock(&my_mutex); //释放mutex
阅读(353) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~