首页 > 代码库 > linux 原子操作
linux 原子操作
原子操作
原子操作，顾名思义，就是说像原子一样不可再细分不可被中途打断。一个操作是原子操作，意思就是说这个操作是以原子的方式被执行，要一口气执行完，执行过程不能够被OS的其他行为打断，是一个整体的过程，在其执行过程中，OS的其它行为是插不进来的。
在linux中提供了两种形式的原子操作：
一种是对整数进行的操作
一种是对单独的位进行操作
在linux中有一个专门的atomic_t类型(一个24位原子访问计数器)和一些对atomic类型变量进行相应操作的的函数
其atomic_t原型如下：
typedef struct { volatile int counter; } atomic_t;
它是一个只含有一个volatile类型的成员变量的结构体；因此编译器不对相应的值进行访问优化(因为是volatile类型的)。
原子整数操作的使用：
常见的用途是计数器，因为计数器是一个很简单的操作，所以无需复杂的锁机制；
能使用原子操作的地方，尽量不使用复杂的锁机制；
对atomic_t类型的变量的使用方法以及对其所能进行的操作：
下面是相应的函数及其原型：
小提示：
******
在其函数的实现体中，有一个LOCK_PREFIX宏定义，如果选了CONFIG_SMP，就会定义这么一个宏，与SMP相关的一些设置，否则LOCK_PREFIX的定义就为空；
******
//原子的读取atomic_t变量的值，v是这个变量的地址
#define atomic_read(v) ((v)->counter)
//原子的设置atomic_t变量的值，v是这个变量的地址，i要设置的新值；
#define atomic_set(v,i) (((v)->counter) = (i))
//原子的增加atomic_t变量的值，i是要增加的数值，v是这个变量的地址
static __inline__ void atomic_add(int i, atomic_t *v)
{
__asm__ __volatile__(
LOCK_PREFIX "addl %1,%0"
:"=m" (v->counter)
:"ir" (i), "m" (v->counter));
}
//原子的减少atomic_t变量的值，i是要减少的数值，v是这个变量的地址；
static __inline__ void atomic_sub(int i, atomic_t *v)
{
__asm__ __volatile__(
LOCK_PREFIX "subl %1,%0"
:"=m" (v->counter)
:"ir" (i), "m" (v->counter));
}
//原子的对atomic_t变量的值进行减少i的操作，并且检测其结果是否为0；若为0，返回true，否则，返回false；
//i是要减少的数值，v是这个变量的地址；
static __inline__ int atomic_sub_and_test(int i, atomic_t *v)
{
unsigned char c;
__asm__ __volatile__(
LOCK_PREFIX "subl %2,%0; sete %1"
:"=m" (v->counter), "=qm" (c)
:"ir" (i), "m" (v->counter) : "memory");
return c;
}
//原子的对atomic_t变量的值进行加1的操作，v是这个变量的地址；
static __inline__ void atomic_inc(atomic_t *v)
{
__asm__ __volatile__(
LOCK_PREFIX "incl %0"
:"=m" (v->counter)
:"m" (v->counter));
}
//原子的对atomic_t变量的值进行减1的操作，v是这个变量的地址；
static __inline__ void atomic_dec(atomic_t *v)
{
__asm__ __volatile__(
LOCK_PREFIX "decl %0"
:"=m" (v->counter)
:"m" (v->counter));
}
//原子的对atomic_t变量的值进行减少1的操作，并且检测其结果是否为0；若为0，返回true，否则，返回false；
//v是这个变量的地址；
static __inline__ int atomic_dec_and_test(atomic_t *v)
{
unsigned char c;
__asm__ __volatile__(
LOCK_PREFIX "decl %0; sete %1"
:"=m" (v->counter), "=qm" (c)
:"m" (v->counter) : "memory");
return c != 0;
}
//原子的对atomic_t变量的值进行加1的操作，并且检测其结果是否为0；若为0，返回true，否则，返回false；
//v是这个变量的地址；
static __inline__ int atomic_inc_and_test(atomic_t *v)
{
unsigned char c;
__asm__ __volatile__(
LOCK_PREFIX "incl %0; sete %1"
:"=m" (v->counter), "=qm" (c)
:"m" (v->counter) : "memory");
return c != 0;
}
//原子的对atomic_t变量的值进行加i的操作，并且检测其结果是否为负；若为负，返回true，否则，返回false；
//i是要增加的数值，v是这个变量的地址；
static __inline__ int atomic_add_negative(int i, atomic_t *v)
{
unsigned char c;
__asm__ __volatile__(
LOCK_PREFIX "addl %2,%0; sets %1"
:"=m" (v->counter), "=qm" (c)
:"ir" (i), "m" (v->counter) : "memory");
return c;
}
//原子的对atomic_t变量的值进行加i的操作，并且将所得结果返回；
//i是要增加的数值，v是这个变量的地址；
static __inline__ int atomic_add_return(int i, atomic_t *v)
{
int __i;
#ifdef CONFIG_M386
unsigned long flags;
if(unlikely(boot_cpu_data.x86==3))
goto no_xadd;
#endif
/* Modern 486+ processor */
__i = i;
__asm__ __volatile__(
LOCK_PREFIX "xaddl %0, %1;"
:"=r"(i)
:"m"(v->counter), "0"(i));
return i + __i;
#ifdef CONFIG_M386
no_xadd: /* Legacy 386 processor */
local_irq_save(flags);
__i = atomic_read(v);
atomic_set(v, i + __i);
local_irq_restore(flags);
return i + __i;
#endif
}
//原子的对atomic_t变量的值进行减i的操作，并且将所得结果返回；
//i是要减少的数值，v是这个变量的地址；
static __inline__ int atomic_sub_return(int i, atomic_t *v)
{
return atomic_add_return(-i,v);
}
//原子的比较old与v是否相等，若相等，则把new的值写入到v中，并且返回old的值；
#define atomic_cmpxchg(v, old, new) ((int)cmpxchg(&((v)->counter), old, new))
//原子的比较
#define atomic_xchg(v, new) (xchg(&((v)->counter), new))
/**
* atomic_add_unless - add unless the number is a given value
* @v: pointer of type atomic_t
* @a: the amount to add to v...
* @u: ...unless v is equal to u.
*
* Atomically adds @a to @v, so long as it was not @u.
* Returns non-zero if @v was not @u, and zero otherwise.
*/
//原子的对atomic_t变量的值进行加a的操作，直到v等于u，如果v与u不等，返回非零值；否则返回0；
//a是要增加的数值，v是这个变量的地址，u是要比较的值；
#define atomic_add_unless(v, a, u) \
({ \
int c, old; \
c = atomic_read(v); \
for (;;) { \
if (unlikely(c == (u))) \
break; \
old = atomic_cmpxchg((v), c, c + (a)); \
if (likely(old == c)) \
break; \
c = old; \
} \
c != (u); \
})
#define atomic_inc_not_zero(v) atomic_add_unless((v), 1, 0)
#define atomic_inc_return(v) (atomic_add_return(1,v))
#define atomic_dec_return(v) (atomic_sub_return(1,v))
//掩码
/* These are x86-specific, used by some header files */
#define atomic_clear_mask(mask, addr) \
__asm__ __volatile__(LOCK_PREFIX "andl %0,%1" \
: : "r" (~(mask)),"m" (*addr) : "memory")
#define atomic_set_mask(mask, addr) \
__asm__ __volatile__(LOCK_PREFIX "orl %0,%1" \
: : "r" (mask),"m" (*(addr)) : "memory")
下面举例说明原子操作的用法：
定义一个atomic_c类型的数据很简单，还可以定义时给它设定初值：
(1) atomic_t u; /*定义 u*/
(2) atomic_t v = ATOMIC_INIT(0) /*定义 v 并把它初始化为0*/
对其操作：
(1) atomic_set(&v,4) /* v = 4 ( 原子地)*/
(2) atomic_add(2,&v) /* v = v + 2 = 6 (原子地) */
(3) atomic_inc(&v) /* v = v + 1 =7（原子地)*/
如果需要将atomic_t转换成int型，可以使用atomic_read()来完成：
printk(“%d\n”,atomic_read(&v)); /* 会打印7*/
原子整数操作最常见的用途就是实现计数器。使用复杂的锁机制来保护一个单纯的计数器是很笨拙的，所以，开发者最好使用atomic_inc()和atomic_dec()这两个相对来说轻便一点的操作。
还可以用原子整数操作原子地执行一个操作并检查结果。一个常见的例子是原子的减操作和检查。
int atomic_dec_and_test(atomic_t *v)
这个函数让给定的原子变量减1，如果结果为0，就返回1；否则返回0
原子位操作
操作函数的参数是一个指针和一个位号
第0位是给定地址的最低有效位
原子位操作中没有特殊的数据类型
例如：set_bit(0, &word);
如：标志寄存器EFLSGS的系统标志，用于控制I/O访问，可屏蔽硬件中断。共32位，不同的位代表不同的信息，对其中信息改变都是通过位操作实现的
原子操作中的位操作部分函数如下：
void set_bit(int nr, void *addr) 原子设置addr所指的第nr位
void clear_bit(int nr, void *addr) 原子的清空所指对象的第nr位
void change_bit(nr, void *addr) 原子的翻转addr所指的第nr位
int test_bit(nr, void *addr) 原子的返回addr位所指对象nr位
int test_and_set_bit(nr, void *addr) 原子设置addr所指对象的第nr位，并返回原先的值
int test_and_clear_bit(nr, void *addr) 原子清空addr所指对象的第nr位，并返回原先的值
int test_and_change_bit(nr, void *addr) 原子翻转addr所指对象的第nr位，并返回原先的值
#include <linux/kernel.h> #include <linux/module.h> #include <linux/kernel.h> #include <linux/miscdevice.h> #include <linux/fs.h> #include <linux/interrupt.h> #include <linux/gpio.h> #include <mach/gpio.h> #include <asm-generic/ioctl.h> #include <asm/uaccess.h> #include <linux/wait.h> #include <linux/sched.h> #include <linux/timer.h> #include<asm/atomic.h> #define MAGIC ‘B‘ #define GET_BTN_VAL _IOR(MAGIC,1,unsigned long) typedef struct { unsigned int gpio; unsigned int btn; unsigned int irq; char* name; }irq_typedef; static irq_typedef irq_source[]= { {EXYNOS4_GPX3(2),1,0,"btn1"}, {EXYNOS4_GPX3(3),2,0,"btn2"}, {EXYNOS4_GPX3(4),3,0,"btn3"}, {EXYNOS4_GPX3(5),4,0,"btn4"} }; //等待队列静态申请 static int condition; //static wait_queue_head_t btn_wait_que; //static init_waitqueue_head(&btn_wait_que); DECLARE_WAIT_QUEUE_HEAD(btn_wait_que); //定时器 struct timer_list btn_timer; static unsigned long btn_num; irq_typedef* curdev; static int timer_flag; //中断函数 static irq_handler_t gpio_btn_handler(int irq, void *dev) { curdev = (irq_typedef*)dev; if(!timer_flag) { add_timer(&btn_timer); timer_flag=1; } else mod_timer(&btn_timer, jiffies+msecs_to_jiffies(200)); return 0; } //定时器处理函数 static void btn_tim_function(unsigned long data) { printk("%s\n",curdev->name); printk("curbtn :%d\n",curdev->btn); condition=1; wake_up(&btn_wait_que); //全局变量在ioctrl中调用 btn_num = curdev->btn; } atomic_t btn_atomic = ATOMIC_INIT(1); static int btn_open(struct inode *node, struct file *fil) { int i,ret; if(!atomic_dec_and_test(&btn_atomic)) { atomic_inc(&btn_atomic); return -1; } for(i=0;i<4;i++) { //设置相应IO口为中断 irq_source[i].irq = gpio_to_irq(irq_source[i].gpio); //请求中断 ret = request_irq(irq_source[i].irq,(irq_handler_t)gpio_btn_handler, IRQF_TRIGGER_FALLING,irq_source[i].name,&irq_source[i]); } btn_timer.expires =jiffies+msecs_to_jiffies(200); btn_timer.function =btn_tim_function; btn_timer.data =0; init_timer(&btn_timer); return ret; } static int btn_release(struct inode *node, struct file *fil) { int i; atomic_inc(&btn_atomic); del_timer(&btn_timer); //释放中断号和中断那个结构体成员 //free_irq(unsigned int irq, void * dev_id) for(i=0;i<4;i++) free_irq(irq_source[i].irq,&irq_source[i]); return 0; } static long btn_ioctl(struct file *fil, unsigned int cmd, unsigned long arg) { //int ret; //把数据转换成用户空间类型 和上层进行通信 void __user *argp = (void __user *)arg; wait_event_interruptible(btn_wait_que, condition); condition=0; switch(cmd) { case GET_BTN_VAL: //printk("btn_num :%ld\n",btn_num); put_user(btn_num, (unsigned int __user *) argp); //ret = copy_to_user((void __user *) argp, (void *)&btn_num,4); //copy_to_user(void __user * to, const void * from, unsigned long n); break; default: return -EINVAL; } return 0; } //文件操作集合 static struct file_operations btn_irq_fops = { .owner = THIS_MODULE, .unlocked_ioctl = btn_ioctl, .open = btn_open, .release = btn_release, }; //杂项注册 static struct miscdevice btn_misc= { .minor = 255, .name = "btn", .fops = &btn_irq_fops, }; static __init int btn_irq_init(void) { int ret; ret = misc_register(&btn_misc); return ret; } static __exit void btn_irq_exit(void) { misc_deregister(&btn_misc); } module_init(btn_irq_init); module_exit(btn_irq_exit); MODULE_LICENSE("GPL");
1 #include <stdio.h> 2 #include <sys/types.h> 3 #include <sys/stat.h> 4 #include <fcntl.h> 5 #include <unistd.h> 6 #include <stdlib.h> 7 #include <sys/ioctl.h> 8 9 #define MAGIC ‘B‘ 10 #define GET_BTN_VAL _IOR(MAGIC, 1, unsigned long) 11 12 int main(int argc,char *argv[]) 13 { 14 int btn_fd,btn_val=0; 15 16 if(argc!=2) 17 { 18 printf("Usage:<%s> </dev/?node>\n",argv[0]); 19 return -1; 20 } 21 22 btn_fd = open(argv[1],O_RDONLY); 23 24 if(btn_fd<0) 25 { 26 printf("busy!!!!!\n"); 27 return -1; 28 29 } 30 31 32 while(1) 33 { 34 ioctl(btn_fd,GET_BTN_VAL,&btn_val); 35 //ioctl(btn_fd,GET_BTN_VAL,btn_val); 36 //sleep(1); 37 38 printf("btn_val(irq):%d\n",btn_val); 39 } 40 }
1 obj-m += btnirq.o 2 SOURCE = btntest.o 3 4 CROSS_COMPLIE = arm-linux- 5 CC = $(CROSS_COMPLIE)gcc 6 7 KERNDIR = /centos/xyd/linux-3.5 8 #CURDIR = $(shell pwd) 9 CURDIR = `pwd` 10 11 .PHONY: module clean 12 13 all: module $(SOURCE:.o=) 14 15 module: 16 $(MAKE) -C $(KERNDIR) M=$(CURDIR) modules 17 18 $(SOURCE:.o=):$(SOURCE) 19 $(CC) -o $@ $^ 20 21 %.o:%.c 22 $(CC) -c $< 23 24 clean: 25 $(MAKE) -C $(KERNDIR) M=$(CURDIR) clean 26 rm $(SOURCE:.o=)
linux 原子操作