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");

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/ioctl.h>

#define     MAGIC                     'B'
#define     GET_BTN_VAL              _IOR(MAGIC, 1, unsigned long)

int main(int argc,char *argv[])
{
    int btn_fd,btn_val=0;

    if(argc!=2)
    {
        printf("Usage:<%s> </dev/?node>\n",argv[0]);
        return -1;
    }

    btn_fd = open(argv[1],O_RDONLY);    

    if(btn_fd<0)
    {
        printf("busy!!!!!\n");
        return -1;

    }
        
    
    while(1)
    {
        ioctl(btn_fd,GET_BTN_VAL,&btn_val);
        //ioctl(btn_fd,GET_BTN_VAL,btn_val);
        //sleep(1);

        printf("btn_val(irq):%d\n",btn_val);
    }
}

obj-m    += btnirq.o
SOURCE = btntest.o

CROSS_COMPLIE = arm-linux-
CC = $(CROSS_COMPLIE)gcc

KERNDIR = /centos/xyd/linux-3.5
#CURDIR  = $(shell pwd)
CURDIR  = `pwd`

.PHONY: module clean

all: module $(SOURCE:.o=)

module:
    $(MAKE) -C $(KERNDIR) M=$(CURDIR) modules

$(SOURCE:.o=):$(SOURCE)
    $(CC) -o $@ $^

%.o:%.c
    $(CC) -c $<

clean:
    $(MAKE) -C $(KERNDIR) M=$(CURDIR) clean
    rm $(SOURCE:.o=)