一個設備驅動的主要任務有兩個：
1. 存取設備的內存
2. 處理設備產生的中斷

對於第一個任務。UIO 核心實現了mmap()能夠處理物理內存(physical memory)，邏輯內存(logical memory)，
虛擬內存(virtual memory)。UIO驅動的編寫是就不須要再考慮這些繁瑣的細節。

第二個任務，對於設備中斷的應答必須在內核空間進行。所以在內核空間有一小部分代碼
用來應答中斷和禁止中斷，可是其余的工作所有留給用戶空間處理。

假設用戶空間要等待一個設備中斷，它僅僅須要簡單的堵塞在對 /dev/uioX的read()操作上。
當設備產生中斷時，read()操作馬上返回。

UIO 也實現了poll()系統調用。你能夠使用
select()來等待中斷的發生。select()有一個超時參數能夠用來實現有限時間內等待中斷。

對設備的控制還能夠通過/sys/class/uio下的各個文件的讀寫來完畢。你註冊的uio設備將會出如今該文件夾下。

假如你的uio設備是uio0那麽映射的設備內存文件出如今 /sys/class/uio/uio0/maps/mapX。對該文件的讀寫就是
對設備內存的讀寫。

例如以下的圖描寫敘述了uio驅動的內核部分。用戶空間部分。和uio 框架以及內核內部函數的關系。

二：UIO驅動註冊

首先來看一個簡單的UIO驅動代碼，代碼來自網上，非原創，旨在學習

內核部分：

/*

* This is simple demon of uio driver.

* Version 1

*Compile:
*    Save this file name it simple.c
*    #echo "obj -m := simple.o" > Makefile
*    #make -Wall -C /lib/modules/‘uname -r‘/build M=‘pwd‘ modules
*Load the module:
*    #modprobe uio
*    #insmod simple.ko
*/



#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/uio_driver.h>
#include <linux/slab.h>


/*struct uio_info { 
    struct uio_device   *uio_dev; // 在__uio_register_device中初始化
    const char      *name; // 調用__uio_register_device之前必須初始化
    const char      *version; //調用__uio_register_device之前必須初始化
    struct uio_mem      mem[MAX_UIO_MAPS];
    struct uio_port     port[MAX_UIO_PORT_REGIONS];
    long            irq; //分配給uio設備的中斷號，調用__uio_register_device之前必須初始化
    unsigned long       irq_flags;// 調用__uio_register_device之前必須初始化
    void            *priv; //
    irqreturn_t (*handler)(int irq, struct uio_info *dev_info); //uio_interrupt中調用，用於中斷處理
                                                                // 調用__uio_register_device之前必須初始化
    int (*mmap)(struct uio_info *info, struct vm_area_struct *vma); //在uio_mmap中被調用，
                                                                // 執行設備打開特定操作
    int (*open)(struct uio_info *info, struct inode *inode);//在uio_open中被調用，執行設備打開特定操作
    int (*release)(struct uio_info *info, struct inode *inode);//在uio_device中被調用，執行設備打開特定操作
    int (*irqcontrol)(struct uio_info *info, s32 irq_on);//在uio_write方法中被調用，執行用戶驅動的
                                                        //特定操作。
};*/

struct uio_info kpart_info = {  
        .name = "kpart",  
        .version = "0.1",  
        .irq = UIO_IRQ_NONE,  
}; 
static int drv_kpart_probe(struct device *dev);
static int drv_kpart_remove(struct device *dev);
static struct device_driver uio_dummy_driver = {
    .name = "kpart",
    .bus = &platform_bus_type,
    .probe = drv_kpart_probe,
    .remove = drv_kpart_remove,
};

static int drv_kpart_probe(struct device *dev)
{
    printk("drv_kpart_probe(%p)\n",dev);
    kpart_info.mem[0].addr = (unsigned long)kmalloc(1024,GFP_KERNEL);
    
    if(kpart_info.mem[0].addr == 0)
        return -ENOMEM;
    kpart_info.mem[0].memtype = UIO_MEM_LOGICAL;
    kpart_info.mem[0].size = 1024;

    if(uio_register_device(dev,&kpart_info))
        return -ENODEV;
    return 0;
}

static int drv_kpart_remove(struct device *dev)
{
    uio_unregister_device(&kpart_info);
    return 0;
}

static struct platform_device * uio_dummy_device;

static int __init uio_kpart_init(void)
{
    uio_dummy_device = platform_device_register_simple("kpart",-1,NULL,0);
    return driver_register(&uio_dummy_driver);
}

static void __exit uio_kpart_exit(void)
{
    platform_device_unregister(uio_dummy_device);
    driver_unregister(&uio_dummy_driver);
}

module_init(uio_kpart_init);
module_exit(uio_kpart_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("IGB_UIO_TEST");
MODULE_DESCRIPTION("UIO dummy driver");

UIO的驅動註冊與其他驅動類似，通過調用linux提供的uio API接口進行註冊，在註冊之前，所做的主要工作是填充uio_info結構體的信息，主要包括內存大小、類型等信息的填充。填充完畢後調用uio_register_device()函數，將uio_info註冊到內核中。註冊後，在/sys/class/uio/uioX，其中X是我們註冊的第幾個uio設備，比如uio0，在該文件夾下的map/map0會有我們剛才填充的一些信息，包括addr、name、size、offset，其中addr保存的是設備的物理地址，size保存的是地址的大小，這些在用戶態會將其讀出，並mmap至用戶態進程空間，這樣用戶態便可直接操作設備的內存空間。

用戶態：

#include <stdio.h>
#include <fcntl.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/mman.h>
#include <errno.h>

#define UIO_DEV "/dev/uio0"
#define UIO_ADDR "/sys/class/uio/uio0/maps/map0/addr"
#define UIO_SIZE "/sys/class/uio/uio0/maps/map0/size"

static char uio_addr_buf[16]={0};
static char uio_size_buf[16]={0};

int main(void)
{
    int uio_fd,addr_fd,size_fd;
    int uio_size;
    void *uio_addr, *access_address;
    int n=0;
    uio_fd = open(UIO_DEV,O_RDWR);
    addr_fd = open(UIO_ADDR,O_RDONLY);
    size_fd = open(UIO_SIZE,O_RDONLY);
    if(addr_fd < 0 || size_fd < 0 || uio_fd < 0){
        fprintf(stderr,"mmap:%s\n",strerror(errno));
        exit(-1);
    }

    n=read(addr_fd,uio_addr_buf,sizeof(uio_addr_buf));
    if(n<0){
        fprintf(stderr, "%s\n", strerror(errno));
        exit(-1);
    }
    n=read(size_fd,uio_size_buf,sizeof(uio_size_buf));
    if(n<0){
        fprintf(stderr, "%s\n", strerror(errno));
        exit(-1);
    }
    uio_addr = (void*)strtoul(uio_addr_buf,NULL,0);
    uio_size = (int)strtol(uio_size_buf,NULL,0);

    access_address = mmap(NULL,uio_size,PROT_READ | PROT_WRITE,
                            MAP_SHARED,uio_fd,0);
    if(access_address == (void*)-1){
        fprintf(stderr,"mmap:%s\n",strerror(errno));
        exit(-1);
    }

    printf("The device address %p (lenth %d)\n"
        "can be accessed over\n"
        "logical address %p\n",uio_addr,uio_size,access_address);
/*
    access_address = (void*)(long)mremap(access_address, getpagesize(),uio_size + getpagesize()+ 11111, MAP_SHARED);

    if(access_address == (void*)-1){
        fprintf(stderr,"mremap: %s\n",strerror(errno));
        exit(-1);
    }

    printf(">>>AFTER REMAP:""logical address %p\n",access_address);
*/
    return 0;
}

代碼很簡單，就是講剛才那幾個文件讀出來，並且重新mmap出來，最後將其打印出來。由此我們可以簡單的看到，想要操作uio設備，只需要重新mmap，而後我們便可操作一般的內存一樣操作設備內存，那麽dpdk的實現也是類似的，只不過更加復雜一點。

dpdk的uio實現的內核的代碼主要在igb_uio.c中，整理一下主要的代碼：

static struct pci_driver igbuio_pci_driver = {
    .name = "igb_uio",
    .id_table = NULL,
    .probe = igbuio_pci_probe,
    .remove = igbuio_pci_remove,
};

module_init(igbuio_pci_init_module);

static int __init
igbuio_pci_init_module(void)
{
    int ret;

    ret = igbuio_config_intr_mode(intr_mode);
    if (ret < 0)
        return ret;

    return pci_register_driver(&igbuio_pci_driver);
}



#if LINUX_VERSION_CODE < KERNEL_VERSION(3,8,0)
static int __devinit
#else
static int
#endif
igbuio_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
{
    struct rte_uio_pci_dev *udev;

    udev = kzalloc(sizeof(struct rte_uio_pci_dev), GFP_KERNEL);
    if (!udev)
        return -ENOMEM;

    /*
     * enable device: ask low-level code to enable I/O and
     * memory
     */
    if (pci_enable_device(dev)) {
        printk(KERN_ERR "Cannot enable PCI device\n");
        goto fail_free;
    }

    /*
     * reserve device‘s PCI memory regions for use by this
     * module
     */
    if (pci_request_regions(dev, "igb_uio")) {
        printk(KERN_ERR "Cannot request regions\n");
        goto fail_disable;
    }

    /* enable bus mastering on the device */
    pci_set_master(dev);

    /* remap IO memory */
    if (igbuio_setup_bars(dev, &udev->info))
        goto fail_release_iomem;

    /* set 64-bit DMA mask */
    if (pci_set_dma_mask(dev,  DMA_BIT_MASK(64))) {
        printk(KERN_ERR "Cannot set DMA mask\n");
        goto fail_release_iomem;
    } else if (pci_set_consistent_dma_mask(dev, DMA_BIT_MASK(64))) {
        printk(KERN_ERR "Cannot set consistent DMA mask\n");
        goto fail_release_iomem;
    }

    /* fill uio infos */
    udev->info.name = "Intel IGB UIO";
    udev->info.version = "0.1";
    udev->info.handler = igbuio_pci_irqhandler;
    udev->info.irqcontrol = igbuio_pci_irqcontrol;
#ifdef CONFIG_XEN_DOM0
    /* check if the driver run on Xen Dom0 */
    if (xen_initial_domain())
        udev->info.mmap = igbuio_dom0_pci_mmap;
#endif
    udev->info.priv = udev;
    udev->pdev = dev;
    udev->mode = RTE_INTR_MODE_LEGACY;
    spin_lock_init(&udev->lock);

    /* check if it need to try msix first */
    if (igbuio_intr_mode_preferred == RTE_INTR_MODE_MSIX) {
        int vector;

        for (vector = 0; vector < IGBUIO_NUM_MSI_VECTORS; vector ++)
            udev->msix_entries[vector].entry = vector;

        if (pci_enable_msix(udev->pdev, udev->msix_entries, IGBUIO_NUM_MSI_VECTORS) == 0) {
            udev->mode = RTE_INTR_MODE_MSIX;
        }
        else {
            pci_disable_msix(udev->pdev);
            printk(KERN_INFO "fail to enable pci msix, or not enough msix entries\n");
        }
    }
    switch (udev->mode) {
    case RTE_INTR_MODE_MSIX:
        udev->info.irq_flags = 0;
        udev->info.irq = udev->msix_entries[0].vector;
        break;
    case RTE_INTR_MODE_MSI:
        break;
    case RTE_INTR_MODE_LEGACY:
        udev->info.irq_flags = IRQF_SHARED;
        udev->info.irq = dev->irq;
        break;
    default:
        break;
    }

    pci_set_drvdata(dev, udev);
    igbuio_pci_irqcontrol(&udev->info, 0);

    if (sysfs_create_group(&dev->dev.kobj, &dev_attr_grp))
        goto fail_release_iomem;

    /* register uio driver */
    if (uio_register_device(&dev->dev, &udev->info))
        goto fail_release_iomem;

    printk(KERN_INFO "uio device registered with irq %lx\n", udev->info.irq);

    return 0;

fail_release_iomem:
    sysfs_remove_group(&dev->dev.kobj, &dev_attr_grp);
    igbuio_pci_release_iomem(&udev->info);
    if (udev->mode == RTE_INTR_MODE_MSIX)
        pci_disable_msix(udev->pdev);
    pci_release_regions(dev);
fail_disable:
    pci_disable_device(dev);
fail_free:
    kfree(udev);

    return -ENODEV;
}

代碼經過整理後，對比上面簡單的uio驅動實現，dpdk的uio實現也是首先初始化一個pci_driver結構體，在igbuio_pci_init_module()函數中直接調用linux提供的pci註冊API,pci_register_driver(&igbuio_pci_driver)，接著便跳到igbuio_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)函數中，這個函數的功能就是類似於上面例子中內核態代碼，rte_uio_pci_dev結構體是dpdk自己封裝的，如下：

//在igb_uio自己封裝的
struct rte_uio_pci_dev {
    struct uio_info info;
    struct pci_dev *pdev;
    spinlock_t lock; /* spinlock for accessing PCI config space or msix data in multi tasks/isr */
    enum igbuio_intr_mode mode;
    struct msix_entry         msix_entries[IGBUIO_NUM_MSI_VECTORS]; /* pointer to the msix vectors to be allocated later */
};

可以看到，裏面有uio_info這個結構體，從igbuio_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)函數代碼中可以看到，主要是在填充uio_info結構體的信息，並且圍繞的也是pci設備的物理地址及大小，最後調用linux提供的uio註冊接口uio_register_device(&dev->dev, &udev->info)，完成整個uio註冊。

Linux 設備驅動之 UIO 機制