1.　信号量

信号量（semaphone）是保护临界区的一种常用方法。当一个数据可能被多个进程访问，但是同时只能被一个进程访问，这时会用到信号量对该数据作一个保护。

一般会将该信号量和被保护的数据组合在一起形成一个结构体，如：

Struct globalmem_dev

{

Struct cdev cdev;

Unsigned char mem[SIZE];

Struct semaphore sem;

}

信号量的初始化：

Init_MUTEX(&globalmem_devp->sem);将一个互斥的信号量初始化为1，当然也可以设定为大于1的值，使用sema_init(sem, val)。注意参数是一个指针，指向信号量变量的地址。因为要对该信号量进行修改访问。

信号量的关键参数为count。因为一直只允许一个进程访问，所以有一个锁lock要对count操作进行保护。__SPIN_LOCK_UNLOCKED((name).lock),在初始化时候为unlock状态。

struct semaphore {

spinlock_tlock;

unsigned intcount;

struct list_headwait_list;

};

#define init_MUTEX(sem)sema_init(sem, 1)

#define __SEMAPHORE_INITIALIZER(name, n)\

{\

.lock= __SPIN_LOCK_UNLOCKED((name).lock),\

.count= n,\

.wait_list= LIST_HEAD_INIT((name).wait_list),\

}

LIST_HEAD_INIT((name).wait_list),为初始化一个等待队列头。等待队列头为一个双向链表的头，prev和next都为name的地址

#define LIST_HEAD_INIT(name) { &(name), &(name) }

获得信号量

/**

* down - acquire the semaphore

* @sem: the semaphore to be acquired

*

* Acquires the semaphore. If no more tasks are allowed to acquire the

* semaphore, calling this function will put the task to sleep until the

* semaphore is released.

*

* Use of this function is deprecated, please use down_interruptible() or

* down_killable() instead.

*/

void down(struct semaphore *sem);//会导致该进程睡眠，直到释放该信号量。而且不能被信号唤醒。不建议使用。

int __must_check down_interruptible(struct semaphore *sem);

int down_interruptible(struct semaphore *sem)

{

unsigned long flags;

int result = 0;

spin_lock_irqsave(&sem->lock, flags);

if (likely(sem->count > 0))

sem->count--;

else

result = __down_interruptible(sem);

spin_unlock_irqrestore(&sem->lock, flags);

return result;

}

down_interruptible如果获得信号量即count 值大于零，将count--，且返回值为零。

释放信号量

/**

* up - release the semaphore

* @sem: the semaphore to release

*

* Release the semaphore.Unlike mutexes, up() may be called from any

* context and even by tasks which have never called down().

*/

void up(struct semaphore *sem)

{

unsigned long flags;

spin_lock_irqsave(&sem->lock, flags);

if (likely(list_empty(&sem->wait_list)))

sem->count++;

else

__up(sem);

spin_unlock_irqrestore(&sem->lock, flags);

}

实际上对信号量中间的count操作前也要做获取自旋锁的操作。操作完count之后解锁。

2. 自旋锁

也是对临界资源进行互斥访问的典型手段。为了获取一个自旋锁，在CPU上运行的代码先执行一个原子操作，测试并设置某个内存变量。如果锁已经空闲，则获得这个自旋锁并继续执行。如果被占用，则在一个小的循环内重复这个测试并设置的操作，即所谓的自旋。直到该自旋锁被其它持有者释放。

定义自旋锁

Spinlock_t lock

初始化自旋锁

Spin_lock_init(&lock);

void __spin_lock_init(spinlock_t *lock, const char *name,

struct lock_class_key *key)

{

#ifdef CONFIG_DEBUG_LOCK_ALLOC

/*

* Make sure we are not reinitializing a held lock:

*/

debug_check_no_locks_freed((void *)lock, sizeof(*lock));

lockdep_init_map(&lock->dep_map, name, key, 0);

#endif

lock->raw_lock = (raw_spinlock_t)__RAW_SPIN_LOCK_UNLOCKED;

lock->magic = SPINLOCK_MAGIC;

lock->owner = SPINLOCK_OWNER_INIT;

lock->owner_cpu = -1;

}

初始化其关键字为0：lock->raw_lock = (raw_spinlock_t)__RAW_SPIN_LOCK_UNLOCKED;

获得自旋锁

Spin_lock(lock)

#define __LOCK(lock) \

do { preempt_disable(); __acquire(lock); (void)(lock); } while (0) 

# define __acquire(x)__context__(x,1)

Preempt_disable()应该是禁止中断，保持对cpu的独占

__context__(x,1)不断地对x进行测试，看值是否为0，如果为0，则获得锁，并加1。如果不为0则不断地进行测试等待操作。

Spin_trylock(&lock) 如果不能获得，立刻返回

释放自旋锁

Spin_unlock()

#define __UNLOCK(lock) \

do { preempt_enable(); __release(lock); (void)(lock); } while (0)

# define __release(x)__context__(x,-1)

本质上是进行一个-1操作。

3. 自旋锁和信号量

信号量：进程级，用于多个进程对资源访问的互斥。如果没能获得资源，会发生进程上下文切换。当前进程会睡眠挂起，直到资源能够访问。当然这需要结合等待队列来进行。进程上下文切换开销比较大，只有当进程占用资源比较长时间时，用信号量才是较好的选择。

自旋锁：当需要保护的临界区访问时间比较短时，用自旋锁很方便，可以节省进程上下文切换的时间。但是锁不能再临界区长时间停留，否则会降低系统效率。

可能引起阻塞的代码不能用自旋锁。否则会引起死锁。

在中断的情况下保护资源，自能使用自旋锁，避免阻塞。