Linux内核的同步互斥机制

互斥与同步机制是计算机系统中，用于控制进程对某些特定资源的访问的机制。
同步是指用于实现控制多个进程按照一定的规则或顺序访问某些系统资源的机制。
互斥是指用于实现控制某些系统资源在任意时刻只能允许一个进程访问的机制。
互斥是同步机制中的一种特殊情况。同步机制是linux操作系统可以高效稳定运行的重要机制。
同步：强调的是顺序性 
互斥：强调的是排他性
竞态：多个执行单元同时被执行，处理的是同一个资源，就会导致竞态
导致竞态原因： 
  1.多进程同时访问操作临界资源(进程和抢占它的进程之间会导致竞态) 
  2.进程和中断 
  3.对称多处理器

    要求：临界区代码执行时间足够短。
    中断屏蔽函数，只能屏蔽本CPU的中断

spin_lock_init(spinlock_t *lock) 功能：初始化自旋锁 参数： @lock 自旋锁结构体指针
void spin_lock(spinlock_t *lock) 功能：自旋锁上锁 参数： @lock 自旋锁结构体指针

  int spin_trylock(spinlock_t *lock) 功能：自旋锁上锁 参数： @lock    自旋锁结构体指针  特点：如果上锁失败，错误返回
  void spin_unlock(spinlock_t *lock) 功能：自旋锁解锁 参数： @lock    自旋锁结构体指针 

 void flags_init(int *flags,int val) 2 { 3  *flags = val; 4 } 5 int flags_sub_and_test(int *flags) 6 { 7  (*flags)‐‐;
8  if(*flags == 0){ 9  return 1; 10  }else{ 11  return 0; 12  } 13 } 14 void flags_add(int *flags,int val) 15 { 16  *flags+=val; 17 }
18 19 int demo_open(struct inode *inode, struct file *filp) 20 { 21  spin_lock(&(my_cdev‐>spin)); 22  if(!flags_sub_and_test(&(my_cdev‐>flags))){ 23  flags_add(&(my_cdev‐>flags),1); 24  spin_unlock(&(my_cdev‐>spin)); 25  return ‐EBUSY; 26  } 27  spin_unlock(&(my_cdev‐>spin)); 28  printk("‐‐‐devfile_minor:%d‐‐‐\n",MINOR(inode‐>i_rdev)); 29  printk(KERN_DEBUG "‐‐‐%s‐‐‐%s‐‐‐%d‐‐‐\n",__FILE__,__func__,__LINE__); 30  return 0; 31 }
32 33 int demo_release(struct inode *inode, struct file *filp) 34 { 35  spin_lock(&(my_cdev‐>spin)); 36  flags_add(&(my_cdev‐>flags),1); 37  spin_unlock(&(my_cdev‐>spin)); 38  printk(KERN_DEBUG "‐‐‐%s‐‐‐%s‐‐‐%d‐‐‐\n",__FILE__,__func__,__LINE__); 39  return 0; 40 }
41 42 int __init demo_init(void) 43 { 44  ... 45  flags_init(&(my_cdev‐>flags),1); 46  spin_lock_init(&(my_cdev‐>spin)); 47  return 0;
48 }

原子变量的数据类型： typedef struct { int counter; } atomic_t; atomic_set(atomic_t *v,int i) //设置原子变量值 void atomic_add(int i, atomic_t *v) //原子变量加i int atomic_add_return(int i, atomic_t *v) //对原子变量进行加操作，操作后，返回 加完以后的值 void atomic_sub(int i, atomic_t *v) //原子变量减i int atomic_sub_return(int i, atomic_t *v) //对原子变量进行减操作，操作后，返回 加完以后的值
#define atomic_inc(v) atomic_add(1, v) //自加 #define atomic_dec(v) atomic_sub(1, v) //自减
#define atomic_inc_and_test(v) (atomic_add_return(1, v) == 0) //自加并测 试，和0进行比较 #define atomic_dec_and_test(v) (atomic_sub_return(1, v) == 0) //自减并测 试，和0进行比较

1 int demo_open(struct inode *inode, struct file *filp) 2 { 3  if(!atomic_dec_and_test(&(my_cdev‐>ato))){ 4  atomic_inc(&(my_cdev‐>ato)); 5  return ‐EBUSY; 6  } 7  printk("‐‐‐devfile_minor:%d‐‐‐\n",MINOR(inode‐>i_rdev)); 8  printk(KERN_DEBUG "‐‐‐%s‐‐‐%s‐‐‐%d‐‐‐\n",__FILE__,__func__,__LINE__); 9  return 0; 10 }
11 12 int demo_release(struct inode *inode, struct file *filp) 13 { 14  atomic_inc(&(my_cdev‐>ato)); 15  printk(KERN_DEBUG "‐‐‐%s‐‐‐%s‐‐‐%d‐‐‐\n",__FILE__,__func__,__LINE__); 16  return 0; 17 }
18 19 int __init demo_init(void) 20 { 21  ... 22  atomic_set(&(my_cdev‐>ato),1); 23  ... 24  return 0; 25 }

<linux/mutex.h> 互斥体的数据类型： struct mutex
mutex_init(struct mutex *mutex) 功能：初始化互斥体
参数： @mutex 互斥体结构体指针
void mutex_lock(struct mutex *lock) //上锁 void mutex_unlock(struct mutex *lock) //解锁

<linux/semaphore.h>
信号量数据类型： struct semaphore
#define DEFINE_SEMAPHORE(name)     //定义并初始化信号量，name 信号量变 量名
void sema_init(struct semaphore *sem, int val) 功能：初始化信号量 参数： @sem  信号量结构体指针 @val        初始化信号量的值
void down(struct semaphore *sem);
功能：信号量减操作，减失败后进程休眠等（不可中断休眠态） int  down_interruptible(struct semaphore *sem); 功能：信号量减操作，减失败后进程休眠等（可中断休眠态） int  down_trylock(struct semaphore *sem); 功能：信号量减操作，减操作失败，报错返回 void up(struct semaphore *sem); 功能：信号量加操作