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 [email protected] $^
20
21 %.o:%.c
22     $(CC) -c $<
23
24 clean:
25     $(MAKE) -C $(KERNDIR) M=$(CURDIR) clean
26     rm $(SOURCE:.o=)
时间: 2024-10-12 18:07:17

linux 原子操作的相关文章

Linux的原子操作与同步机制

Linux的原子操作与同步机制 转载自:https://www.cnblogs.com/fanzhidongyzby/p/3654855.html 并发问题 现代操作系统支持多任务的并发,并发在提高计算资源利用率的同时也带来了资源竞争的问题.例如C语言语句"count++;"在未经编译器优化时生成的汇编代码为. 当操作系统内存在多个进程同时执行这段代码时,就可能带来并发问题. 假设count变量初始值为0.进程1执行完"mov eax, [count]"后,寄存器e

原子操作(atomic operation)

深入分析Volatile的实现原理 引言 在多线程并发编程中synchronized和Volatile都扮演着重要的角色,Volatile是轻量级的synchronized,它在多处理器开发中保证了共享变量的"可见性".可见性的意思是当一个线程修改一个共享变量时,另外一个线程能读到这个修改的值. 它在某些情况下比synchronized的开销更小,本文将深入分析在硬件层面上Inter处理器是如何实现Volatile的,通过深入分析能帮助我们正确的使用Volatile变量. 术语定义 术

Linux下信号量的P.V操作如何保证其原子性

并发问题: 现代操作系统支持多任务的并发,并发在提高计算资源利用率的同时也带来了资源竞争的问题.例如C语言语句"count++;"在未经编译器优化时生成的汇编代码 count++:                 mov eax,[count]                inc eax                mov [count],eax 当操作系统内存在多个进程同时执行这段代码时,就可能带来并发问题. 假设count变量初始值为0.进程1执行完"mov eax,

Linux内核同步原语之原子操作

避免对同一数据的并发访问(通常由中断.对称多处理器.内核抢占等引起)称为同步. --题记 内核源码:Linux-2.6.38.8.tar.bz2 目标平台:ARM体系结构 原子操作确保对同一数据的"读取-修改-写入"操作在它的执行期间不会被打断,要么全部执行完成,要么根本不会执行.例如在ARM上对全局变量的++运算至少要经历以下三步: [cpp] view plain copy print? ldr r3, [r3, #0] add r2, r3, #1 str r2, [r3, #0

大话Linux内核中锁机制之原子操作、自旋锁

转至:http://blog.sina.com.cn/s/blog_6d7fa49b01014q7p.html 很多人会问这样的问题,Linux内核中提供了各式各样的同步锁机制到底有何作用?追根到底其实是由于操作系统中存在多进程对共享资源的并发访问,从而引起了进程间的竞态.这其中包括了我们所熟知的SMP系统,多核间的相互竞争资源,单CPU之间的相互竞争,中断和进程间的相互抢占等诸多问题. 通常情况下,如图1所示,对于一段程序,我们的理想是总是美好的,希望它能够这样执行:进程1先对临界区完成操作,

linux内核同步之每CPU变量、原子操作、内存屏障、自旋锁【转】

转自:http://blog.csdn.net/goodluckwhh/article/details/9005585 版权声明:本文为博主原创文章,未经博主允许不得转载. 目录(?)[-] 一每CPU变量 二原子操作 三优化和内存屏障 四自旋锁 自旋锁 自旋锁的数据结构和宏函数 读写自旋锁 读写自旋锁的相关函数 linux内核中的各种“任务”都能看到内核地址空间,因而它们之间也需要同步和互斥.linux内核支持的同步/互斥手段包括: 技术 功能 作用范围 每CPU变量 为每个CPU复制一份数据

linux系统原子操作

一.概念 原子操作提供了指令原子执行,中间没有中断.就像原子被认为是不可分割颗粒一样,原子操作(atomic operation)是不可分割的操作.      c语言中一个变量的自加1操作,看起来很简单,好像只需要一条指令而不被打断.但这个操作实现起来,CPU的执行是有一个过程的,分为读取到寄存器,寄存器数学运算,回写到内存.这个实际情况,会给我们程序编写时带来隐患,举例来说明. Thread 1                  Thread 2      ------------------

Linux并发控制---解决竞态的一种操作---&gt;原子操作

-解决竞态的一种操作--->原子操作 解决竞态的途径是"保证对共享资源的互斥访问 原子操作 原子的操作指的就是在执行过程中不会被别的代码所中断的操作. 在Linux中原子操作的方法有很多,有整型原子和位原子,他们在任何情况下操作都是原子的,这些原子操作的实现都是依赖CPU来实现的,因此这些函数都与CPU架构密切相关. 整型原子 arm架构的原子实现在kernel/arch/arm/include/asm/atomic.h 内核中提供的宏定义 : 1. 设置源自变量的值 static inl

Linux内核同步 - 原子操作

一.源由 我们的程序逻辑经常遇到这样的操作序列: 1.读一个位于memory中的变量的值到寄存器中 2.修改该变量的值(也就是修改寄存器中的值) 3.将寄存器中的数值写回memory中的变量值 如果这个操作序列是串行化的操作(在一个thread中串行执行),那么一切OK,然而,世界总是不能如你所愿.在多CPU体系结构中,运行在两个CPU上的两个内核控制路径同时并行执行上面操作序列,有可能发生下面的场景: CPU1上的操作 CPU2上的操作 读操作     读操作 修改 修改 写操作     写操