并發

基本概念：

并發指的是多個執行單元同時、并行被執行，而并發的執行單元對共享資源（硬體資源和軟體上的全局變量、靜态變量等）的通路則很容易導緻競态。

當多個程序、線程或中斷同時通路同一個資源， 可能導緻錯誤. 

           

程序上下文:應用程式陷入核心運作時所處的核心環境

中斷上下文:中斷服務程式執行時所處的核心環境 

搶占式核心：使用者程式在執行系統調用期間可以被高優 先級程序搶占 

非搶占式核心：使用者程式執行系統調用不能被其他程序 搶占 

對稱多處理器（SMP）：一個計算機上彙集了多個處理 器，他們共享記憶體和總線，可并行處理資料 

單處理器：隻有一個CPU 
           

引起并發錯誤的原因有：

中斷

中斷的級别是最高的，中斷到來時會強奪程序的cpu使用權，如果程序和中斷都通路臨界區時，并發操作産生了。 
           

程序的搶占

一個程序正在使用一個全局變量（共享資源），而此時一個程序搶占了cpu的使用權，并且也對這個全局變量進行了操作，此時并發操作也産生了。 
           

多處理器

兩個程序分别在兩個cpu上同時執行，他們都在通路同一個共享資源，也會産生并發。 

           

linux中包含衆多的互斥與同步機制，包括中斷屏蔽、信号量、互斥體、自旋鎖、原子操作、讀寫鎖等

并發導緻的錯誤示範代碼：

驅動端：

#include <linux/device.h>
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/irq.h>
#include <asm/uaccess.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <mach/gpio.h>
#include <linux/delay.h>
#include <mach/regs-gpio.h>  /*S5PV210_GPH3_BASE*/
 
#define EINT_DEVICE_ID            1
 
#define DRIVER_NAME                "key_eint_race"
#define err(msg)                 printk(KERN_ERR "%s: " msg "\n", DRIVER_NAME)
#define __debug(fmt, arg...)    printk(KERN_DEBUG fmt, ##arg)
 
#define GPH3CON                    (unsigned long)(S5PV210_GPH3_BASE+ 0x00)
#define GPH3DAT                    (unsigned long)(S5PV210_GPH3_BASE + 0x04)
#define GPH2UP                    (unsigned long)(S5PV210_GPH2_BASE + 0x08)
 
static int major = 0;        /* Driver Major Number */
static int minor = 0;        /* Driver Minor Number */
struct class *key_class;
static struct device *key_device;
 
static unsigned int key;
 
 
static unsigned int deal_key_value(unsigned int data)
{
    key = data;
    udelay(1000);
    return key;
}
 
irqreturn_t buttons_interrupt(int irq, void *dev_id)
{    
    deal_key_value((unsigned int)dev_id);
    //__debug("in eint function...\n");
    return IRQ_HANDLED;
}
 
static void key_io_port_init(void)
{
    unsigned long reg_val;
    
    reg_val = readl(GPH3CON);
    reg_val &= ~((0x0f<<0) | (0x0f<<4));
    reg_val |= ((0x01<<0) | (0x01<<4));
    writel(reg_val, GPH3CON);
 
    reg_val = readl(GPH3DAT);
    reg_val &= ~((0x01<<0) | (0x01<<1));
    writel(reg_val, GPH3DAT);
 
    reg_val = readl(GPH2UP);
    reg_val &= ~(0x03<<8);
    reg_val |= 0x02<<8;
    writel(reg_val, GPH2UP);
}
 
static ssize_t key_read(struct file *filp, char *buf, size_t count, loff_t *f_pos)
{
    int key_num;
    int cpy_len;
    int retval;
 
    key_num =deal_key_value(current->pid);
    
    cpy_len = min(sizeof(key_num), count);
    retval = copy_to_user(buf, &key_num, cpy_len);
    
    return (cpy_len - retval);
}
 
/* Driver Operation structure */
static struct file_operations key_fops = {
    .owner = THIS_MODULE,
    .read = key_read,
};
 
 
static int __init key_eint_init(void)
{
    int retval;
    
    key_io_port_init();
    //__debug("in key_eint_init\n");
    
    retval = set_irq_type(IRQ_EINT(20),IRQ_TYPE_EDGE_FALLING);
    if(retval){
        err("IRQ_EINT20 set irq type failed");
        goto error;
    }
    
    retval = request_irq(IRQ_EINT(20), buttons_interrupt, IRQF_DISABLED, 
            "KEY1", (void *)EINT_DEVICE_ID);
    if(retval){
        err("request eint20 failed");
        goto error;
    }
    
    /* Driver register */
    major = register_chrdev(major, DRIVER_NAME, &key_fops);
    if(major < 0){
        err("register char device fail");
        retval = major;
        goto error_register;
    }
    key_class=class_create(THIS_MODULE,DRIVER_NAME);
    if(IS_ERR(key_class)){
        err("class create failed!");
        retval =  PTR_ERR(key_class);
        goto error_class;
    }
    key_device=device_create(key_class,NULL, MKDEV(major, minor), NULL,DRIVER_NAME);
    if(IS_ERR(key_device)){
        err("device create failed!");
        retval = PTR_ERR(key_device);
        goto error_device;
    }
    __debug("register myDriver OK! Major = %d\n", major);
    return 0;
 
error_device:
    class_destroy(key_class);
error_class:
    unregister_chrdev(major, DRIVER_NAME);
error_register:
    free_irq(IRQ_EINT(20), (void *)EINT_DEVICE_ID);
error:
    return retval;
}
 
static void __exit key_eint_exit(void)
{
    //__debug("in key_eint_exit\n");
    
    free_irq(IRQ_EINT(20), (void *)EINT_DEVICE_ID);
 
    unregister_chrdev(major, DRIVER_NAME);
    device_destroy(key_class,MKDEV(major, minor));
    class_destroy(key_class);
 
    return;
}
 
module_init(key_eint_init);
module_exit(key_eint_exit);
 
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Eric");