内核开发中的竞争及其解决

单处理器上，因为Linux运行内核代码的进程是非抢占式的（普通的PC版），一般不会有什么太大的问题，但是再SMP系统上，则会出现相互干扰。但是新的版本可能会使内核成为可抢占式的，则要进行竞争的处理。关于竞争，操作系统中还有一个词，就是同步。竞争描述了一种不好的状态，而同步则是为解决这个问题，而出现的机制。

 

 

一.              事情发生的处理

当竞争状态会出现时，我们可以使用下面的对象进行处理。

u       信号量Semaphore

信号量是用于资源访问控制的一般机制，其可以用于互斥操作。定义在<asm/semaphore.h>中，类型struct semaphore。

1.         初始化

使用信号量之前，要初始化，并指定初始值，对于互斥功能，则指定1。初始化函数：

sema_init(semaphore &, int nInit);

2.         使用

对信号量的使用，分2种，请求占用，释放。

请求：down, down_interruptible: 检查信号量的值，大于0则递减信号量的值，并返回，否则，函数进入休眠，直到其他进程释放该信号并将其唤醒之后，再进行尝试。其中，down_interruptible可以由一个信号中断，而down则不允许有信号传送到进程。在大多数情况下，都是希望信号起作用，否则可能进程无法杀掉。但是，允许信号中断使得信号量的处理复杂化了。

int  down_interruptible(struct semaphore& ) 返回0 表示成功，否则出错。

 

 

释放：函数 up(struct semaphore & ) 会递增信号量的值，并唤醒所有正在等待信号量转为可用的进程。

u       内核中所有的同步处理对象都可以使用。像 Mutex等。

 

 

u       自旋锁spin_lock （303）

通常情况下，使用信号量的代价太大，因为他们会使进程休眠。而自旋锁永远不会使进程休眠。在锁不可用时，它只是简单地不停重试，直到锁被释放。在进程不会锁很长时间的情况下，使用spin_lock的开销很小。

自旋锁申明为 stuct spinlock_t类型，头文件<linux/spinlock.h>，使用前，先初始化：

spin_lock_init(spin_lock_t *lock);

在进入临界区时，使用：

spin_lick( spinlock_t *lock)

来获得锁。

释放锁时使用：

spin_unlock(spinlock_t *lock);

这是最基本的，实际上，自旋锁还有很多的操作，可以很复杂。

 

 

u       读者写者自旋锁（305）

这是一种比较特殊的的自旋锁。多个线程可以在同一时间拥有该锁进行读操作，但是当写进程或线程出现时，它会一直等待直到它获得互斥的访问。

类型是rwlock_t，可以被初始化为RW_LOCK_UNLOCKED：

rwlock_t rwl = RW_LOCK_UNLOCKED;

 

 

其使用的函数：

read_lock(rwlock_t *)

read_lock_irqsave(rwlock_t *, unsigned long flags);

read_lock_irq( rwlock_t );

read_lock_bh( rwlock_t *)

read_unlock(rwlock_t *)

read_unlock_irqrestore( relock_t*, unsigned long flags)

read_unlock_irq(rwlock_t *)

read_unlock_bh(rwlock_t *)

 

 

write_lock(rwlock_t *)

write_lock_irqsave(rwlock_t *, unsigned long flags)

write_lock_irq( rwlock_t *)
write_lock_bh( rwlock_t *)

write_unlock( rwlock_t *)

write_unlock_irqstore(rwlock_t *, unsigned long flags)

write_unlock_irq( rwlock_t *)

write_unlock_bh(rwlock_t *)

 

 

u       锁变量

内核中提供了一组对变量提供原子访问，使用他们可以减少使用更复杂的锁方案的需求。

Linux内核导出2组函数来处理锁：位操作，对“原子”数据类型的访问。

1.         位操作（307）

位操作使用单个位的锁变量或者在中断期间更新设备的状态标志（而这时可能某个进程正在访问它们）。他们定义在<asm/bitops.h>中。

void set_bit(nr, void *addr);

void clear_bit(nr, void *addr)

void change_bit(nr, void *addr)

…………

int test_and_set_bit(nr, void *addr)

int test_and_clear_bit(nr, void *addr)

int test_and_change_bit(nr, void *addr)

要说明的是，这些函数用于访问和修改一个共享的标志时，不需要其他的额外工作。而当使用它们来管理锁变量（其控制对共享标志的访问）时，则复杂一些。通常是测试并设置test_and_set_bit失败时，就循环等待测试，直到成功。而后完成工作，最后再循环进行test_and_clear_bit直到成功。

 

 

2.         整数的原子操作

在中断处理程序中，经常要和其他的函数共享整型变量。内核提供了一组独立的函数来进行原子操作，以实现共享。（308）它们在<asm/atomic.h>中定义。

现在要使用的是新的类型：atomic_t，只能通过原子操作来访问它。

void atomic_set( atomic_t *v, int i)

int atomic_read(atomic_t );

void atomic_add(int i, atomic_t *v);

void atomic_sub(int i, atomic_t *v);

 

 

void atomic_inc(atomic_t *v);

void atomic_dec(atomic_t *v);

 

 

int atomic_inc_and_test(atomic_t *v);

int atomic_dec_and_test(atomic *v);

int atomic_add_and_test(int i, atomic_t *v);

int atomic_sub_and_test(int i, atomic_t *v);

 

 

 

 

u       操作kiovec的锁（452）

int lock_kiovec( int nr, struct kiobuf *iovec[], int wait)

int unlock_kiovec(int nr, struct kiobuf *iovec[] );

 

 

u       DMA自旋锁(454)

unsigned long claim_dma_lock()

void release_dma_lock()

 

 

 

 

二.              事前处理

前面介绍的是解决竞争问题，是在有竞争的情况下使用的。除此之外，我们当然可以从源头上开始，避免竞争的出现。―― 处理并发访问的最好办法就是不允许并发访问。就是找出一个行之有效的办法，避免出现并发访问――避免实际上是不可能的，那么就想些办法来避免。

使用循环缓冲区就是一种有效处理并发访问的方法。做过过多线程开发，或研究过操作系统的都知道一个模型：生产者－消费者模型。生产者生成数据，放到缓冲区中，消费者从缓冲区中消费，取走数据。缓冲区数据满时，生产者等待。缓冲区空时，消费者等待。

 

 

使用2个指针来寻址循环缓冲区：head和tail。Head指向数据写入位置，只能被生产者更新。而tail指向数据读出位置，只能被消费者更新。

但是如果数据在中断期间被写入，当多次访问head时，要小心，可以使用某种锁，或者申明为volatile。

另外，当缓冲区满后，你也要选择一种解决方法，要么丢弃新到的数据，要么覆盖掉最老的数据，又或者分配新的数据区。