本文整理下之前的学习笔记，基于DPDK17.11版本源码分析。主要分析一下igb_uio驱动源码。

总线-设备-驱动

首先简单介绍一下kernel中的总线-设备-驱动模型，以pci总线为例，pci总线上有两个表，一个用于保存系统中的pci设备，一个用于保存pci设备对应的驱动。每当加载pci设备驱动时，就会遍历pci总线上的pci设备进行匹配，每当插入pci设备到系统中时，热插拔机制就会自动遍历pci总线上的pci设备驱动进行匹配，如果匹配成功则使用此驱动初始化设备。

注册pci总线
可以调用bus_register注册总线。比如下面的pci总线，平台总线和usb总线等。

//注册pci总线
struct bus_type pci_bus_type = {
    .name       = "pci",
    .match      = pci_bus_match,
    .uevent     = pci_uevent,
    .probe      = pci_device_probe,
    .remove     = pci_device_remove,
    .shutdown   = pci_device_shutdown,
    .dev_groups = pci_dev_groups,
    .bus_groups = pci_bus_groups,
    .drv_groups = pci_drv_groups,
    .pm     = PCI_PM_OPS_PTR,
};
bus_register(&pci_bus_type);

//注册平台总线
struct bus_type platform_bus_type = {
    .name       = "platform",
    .dev_groups = platform_dev_groups,
    .match      = platform_match,
    .uevent     = platform_uevent,
    .pm     = &platform_dev_pm_ops,
};
bus_register(&platform_bus_type);

//注册usb总线
struct bus_type usb_bus_type = {
    .name =     "usb",
    .match =    usb_device_match,
    .uevent =   usb_uevent,
};
bus_register(&usb_bus_type);

//注册virtio总线
static struct bus_type virtio_bus = {
    .name  = "virtio",
    .match = virtio_dev_match,
    .dev_groups = virtio_dev_groups,
    .uevent = virtio_uevent,
    .probe = virtio_dev_probe,
    .remove = virtio_dev_remove,
};
bus_register(&virtio_bus)

注册总线后，会在 /sys/bus 下生成总线目录，比如 pci 总线会生成目录 /sys/bus/pci

/**
 * bus_register - register a driver-core subsystem
 * @bus: bus to register
 *
 * Once we have that, we register the bus with the kobject
 * infrastructure, then register the children subsystems it has:
 * the devices and drivers that belong to the subsystem.
 */
int bus_register(struct bus_type *bus)
    struct subsys_private *priv;
    struct lock_class_key *key = &bus->lock_key;

    priv = kzalloc(sizeof(struct subsys_private), GFP_KERNEL);
    priv->bus = bus;
    bus->p = priv;
    kobject_set_name(&priv->subsys.kobj, "%s", bus->name);
    priv->subsys.kobj.kset = bus_kset;
    priv->subsys.kobj.ktype = &bus_ktype;
    kset_register(&priv->subsys);
    
    //此值为1加载驱动时会自动探测设备进行匹配
    priv->drivers_autoprobe = 1;
    
    bus_create_file(bus, &bus_attr_uevent);
    
    //在总线目录下，生成 devices 子目录，下面再包含具体pci设备子目录
    priv->devices_kset = kset_create_and_add("devices", NULL,
                         &priv->subsys.kobj);
    //在总线目录下，生成 drivers 子目录，下面再包含具体驱动子目录
    priv->drivers_kset = kset_create_and_add("drivers", NULL,
                         &priv->subsys.kobj);
    //此链表用于保存加载的pci设备驱动
    klist_init(&priv->klist_devices, klist_devices_get, klist_devices_put);
    //此链表用于保存扫描到的pci设备
    klist_init(&priv->klist_drivers, NULL, NULL);
    
    //在sys文件系统创建 drivers_probe 和 drivers_autoprobe 文件
    add_probe_files(bus);
        bus_create_file(bus, &bus_attr_drivers_probe);
        bus_create_file(bus, &bus_attr_drivers_autoprobe);
    
    bus_add_groups(bus, bus->bus_groups);

注册总线后，会生成文件/sys/bus/pci/drivers_autoprobe，写此文件时在kernel中会调用如下函数，如果为1，表示 bus 支持自动探测 device，则加载驱动时，自动遍历所有pci设备进行匹配

store_drivers_autoprobe
static ssize_t store_drivers_autoprobe(struct bus_type *bus,
                       const char *buf, size_t count)
{
    if (buf[0] == '0')
        bus->p->drivers_autoprobe = 0;
    else
        bus->p->drivers_autoprobe = 1;
    return count;
}

注册驱动到pci总线
结构体struct pci_driver表示一个pci设备驱动，其中id_table和dynids用来保存此驱动支持的设备id等信息，如果有匹配的设备，则调用probe函数。

struct pci_driver {
    struct list_head node;
    const char *name;
    //静态table，用来保存驱动支持的id
    const struct pci_device_id *id_table;   /* must be non-NULL for probe to be called */
    int  (*probe)  (struct pci_dev *dev, const struct pci_device_id *id);   /* New device inserted */
    void (*remove) (struct pci_dev *dev);   /* Device removed (NULL if not a hot-plug capable driver) */
    int  (*suspend) (struct pci_dev *dev, pm_message_t state);  /* Device suspended */
    int  (*suspend_late) (struct pci_dev *dev, pm_message_t state);
    int  (*resume_early) (struct pci_dev *dev);
    int  (*resume) (struct pci_dev *dev);                   /* Device woken up */
    void (*shutdown) (struct pci_dev *dev);
    int (*sriov_configure) (struct pci_dev *dev, int num_vfs); /* PF pdev */
    const struct pci_error_handlers *err_handler;
    struct device_driver    driver;
    //动态table，通过写文件 new_id 动态添加id
    struct pci_dynids dynids;
};

调用函数pci_register_driver注册pci设备驱动。

static struct pci_driver igbuio_pci_driver = {
    .name = "igb_uio",
    .id_table = NULL,  //DPDK 用到的 igb_uio, vfio-pci等驱动的id_table默认为空
    .probe = igbuio_pci_probe,
    .remove = igbuio_pci_remove,
};
pci_register_driver(&igbuio_pci_driver);


static const struct pci_device_id igb_pci_tbl[] = {
    { PCI_VDEVICE(INTEL, E1000_DEV_ID_I354_BACKPLANE_1GBPS) },
    { PCI_VDEVICE(INTEL, E1000_DEV_ID_I354_SGMII) },
    ...
}

static struct pci_driver igb_driver = {
    .name     = igb_driver_name,
    .id_table = igb_pci_tbl,  //正常的kernel驱动都有一个静态的id_table
    .probe    = igb_probe,
    .remove   = igb_remove,
#ifdef CONFIG_PM
    .driver.pm = &igb_pm_ops,
#endif
    .shutdown = igb_shutdown,
    .sriov_configure = igb_pci_sriov_configure,
    .err_handler = &igb_err_handler
};
pci_register_driver(&igb_driver);

注册驱动后，会在/sys/bus/pci/drivers目录下创建以驱动名字命名的目录，并在此目录下创建new_id, bind和unbind等sys文件，可以通过这些文件动态修改驱动信息。

/*
 * pci_register_driver must be a macro so that KBUILD_MODNAME can be expanded
 */
#define pci_register_driver(driver)     \
    __pci_register_driver(driver, THIS_MODULE, KBUILD_MODNAME)

int __pci_register_driver(struct pci_driver *drv, struct module *owner,
              const char *mod_name)
{
    /* initialize common driver fields */
    drv->driver.name = drv->name;
    //bus固定为 pci_bus_type
    drv->driver.bus = &pci_bus_type;
    drv->driver.owner = owner;
    drv->driver.mod_name = mod_name;

    spin_lock_init(&drv->dynids.lock);
    INIT_LIST_HEAD(&drv->dynids.list);

    /* register with core */
    driver_register(&drv->driver);
        bus_add_driver(drv);
            struct bus_type *bus;
            struct driver_private *priv;
            
            bus = bus_get(drv->bus);
            priv = kzalloc(sizeof(*priv), GFP_KERNEL);
            klist_init(&priv->klist_devices, NULL, NULL);
            priv->driver = drv;
            drv->p = priv;
            priv->kobj.kset = bus->p->drivers_kset;
            kobject_init_and_add(&priv->kobj, &driver_ktype, NULL, "%s", drv->name);

            //将驱动添加到pci总线
            klist_add_tail(&priv->knode_bus, &bus->p->klist_drivers);

            //如果pci总线支持自动探测设备，则在加载驱动时就遍历所有pci设备进行匹配
            if (drv->bus->p->drivers_autoprobe) {
                driver_attach(drv);
                    //遍历所有的pci设备，和drv进行匹配
                    bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);
                        //设备和驱动进行匹配
                        driver_match_device(drv, dev)
                        //如果匹配成功，并且设备还没有加载其他驱动，则使用当前驱动drv
                        if (!dev->driver)
                            driver_probe_device(drv, dev);
            }

            module_add_driver(drv->owner, drv);

            driver_create_file(drv, &driver_attr_uevent);

            //bus->drv_groups 为 pci_drv_groups，
            //在sys文件系统创建 new_id 和 remove_id 文件
            driver_add_groups(drv, bus->drv_groups);
            
            //在sys文件系统创建 bind 和 unbind 文件，用来将驱动绑定和解绑定设备
            if (!drv->suppress_bind_attrs) {
                add_bind_files(drv);
                    driver_create_file(drv, &driver_attr_unbind);
                    driver_create_file(drv, &driver_attr_bind);
            }
}

向new_id写入"0x0806 0x1521"信息(0x0806表示vendor id，0x1521为device id)时，会调用kernel中的store_new_id，解析相关字段后，保存到动态链表dynids，然后遍历当前所有的pci设备进行匹配。

//定义struct driver_attribute driver_attr_new_id
static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
//定义 //struct driver_attribute driver_attr_remove_id
static DRIVER_ATTR(remove_id, S_IWUSR, NULL, store_remove_id);

//定义 struct attribute_group pci_drv_groups
static struct attribute *pci_drv_attrs[] = {
    &driver_attr_new_id.attr,
    &driver_attr_remove_id.attr,
    NULL,
};
ATTRIBUTE_GROUPS(pci_drv);

static ssize_t store_new_id(struct device_driver *driver, const char *buf,size_t count)
    fields = sscanf(buf, "%x %x %x %x %x %x %lx",
            &vendor, &device, &subvendor, &subdevice,
            &class, &class_mask, &driver_data);
    if (fields < 2)
        return -EINVAL;
        
    pci_add_dynid(pdrv, vendor, device, subvendor, subdevice, class, class_mask, driver_data);  
        struct pci_dynid *dynid;

        dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
        dynid->id.vendor = vendor;
        dynid->id.device = device;
        dynid->id.subvendor = subvendor;
        dynid->id.subdevice = subdevice;
        dynid->id.class = class;
        dynid->id.class_mask = class_mask;
        dynid->id.driver_data = driver_data;

        spin_lock(&drv->dynids.lock);
        list_add_tail(&dynid->node, &drv->dynids.list);
        spin_unlock(&drv->dynids.lock);

        //设置new id时，也会自动匹配设备
        return driver_attach(&drv->driver);

向bind文件写入网卡的pci地址时，会调用kernel中的bind_store，将此网卡绑定到此驱动。
向unbind文件写入网卡的pci地址时，会调用kernel中的unbind_store，将此网卡和此驱动解绑。

//定义 struct driver_attribute driver_attr_bind，写文件时，调用 bind_store
static DRIVER_ATTR_WO(bind);
//定义 struct driver_attribute driver_attr_unbind，写文件时，调用 unbind_store
static DRIVER_ATTR_WO(unbind);

/*
 * Manually attach a device to a driver.
 * Note: the driver must want to bind to the device,
 * it is not possible to override the driver's id table.
 */
static ssize_t bind_store(struct device_driver *drv, const char *buf, size_t count)
    dev = bus_find_device_by_name(bus, NULL, buf);
    if (dev && dev->driver == NULL && driver_match_device(drv, dev)) {
        if (dev->parent)    /* Needed for USB */
            device_lock(dev->parent);
        device_lock(dev);
        err = driver_probe_device(drv, dev);
        device_unlock(dev);
        if (dev->parent)
            device_unlock(dev->parent);

        if (err > 0) {
            /* success */
            err = count;
        } else if (err == 0) {
            /* driver didn't accept device */
            err = -ENODEV;
        }
    }
    
/* Manually detach a device from its associated driver. */
static ssize_t unbind_store(struct device_driver *drv, const char *buf, size_t count)
{
    struct bus_type *bus = bus_get(drv->bus);
    struct device *dev;
    int err = -ENODEV;

    dev = bus_find_device_by_name(bus, NULL, buf);
    if (dev && dev->driver == drv) {
        if (dev->parent)    /* Needed for USB */
            device_lock(dev->parent);
        device_release_driver(dev);
        if (dev->parent)
            device_unlock(dev->parent);
        err = count;
    }
    put_device(dev);
    bus_put(bus);
    return err;
}

发现pci设备
系统启动时会扫描所有的pci设备，以他们的pci地址为名字创建目录，并在此目录下创建相关的sys文件。并且会遍历所有的pci设备驱动进行匹配。

pci_scan_root_bus
    pci_scan_child_bus(b);
        pci_scan_slot
            pci_scan_single_device
                pci_scan_device
                pci_device_add
                    device_add(&dev->dev);
                        bus_add_device(dev);
                            //bus->dev_groups为pci_dev_groups，
                            //会在 /sys/bus/pci/devices/'pci address'/ 目录下创建 vendor, device等目录
                            device_add_groups(dev, bus->dev_groups);
                            //将设备添加到pci总线链表
                            klist_add_tail(&dev->p->knode_bus, &bus->p->klist_devices);

    pci_bus_add_devices
        pci_bus_add_device
            pci_create_sysfs_dev_files(dev);
                //如果pci配置空间大于 PCI_CFG_SPACE_SIZE(256字节),则创建 /sys/bus/pci/devices/0000:81:00.0/config文件，
                //大小为 4096 字节
                if (pdev->cfg_size > PCI_CFG_SPACE_SIZE)
                    retval = sysfs_create_bin_file(&pdev->dev.kobj, &pcie_config_attr);
                else //否则config文件大小为 256 字节
                    retval = sysfs_create_bin_file(&pdev->dev.kobj, &pci_config_attr);

                //创建 resource 文件，用户态可以使用mmap映射 resource0 实现对网卡寄存器的操作
                pci_create_resource_files(pdev);
                    //创建 /sys/bus/pci/devices/0000:81:00.0/resource0 等文件
                    /* Expose the PCI resources from this device as files */
                    for (i = 0; i < PCI_ROM_RESOURCE; i++) {
                        /* skip empty resources */
                        if (!pci_resource_len(pdev, i))
                            continue;

                        retval = pci_create_attr(pdev, i, 0);
                            struct bin_attribute *res_attr;
                            res_attr = kzalloc(sizeof(*res_attr) + name_len, GFP_ATOMIC);
                            sysfs_bin_attr_init(res_attr);
                            if (write_combine) {
                                pdev->res_attr_wc[num] = res_attr;
                                sprintf(res_attr_name, "resource%d_wc", num);
                                res_attr->mmap = pci_mmap_resource_wc;
                            } else {
                                pdev->res_attr[num] = res_attr;
                                sprintf(res_attr_name, "resource%d", num);
                                res_attr->mmap = pci_mmap_resource_uc;
                            }
                            if (pci_resource_flags(pdev, num) & IORESOURCE_IO) {
                                res_attr->read = pci_read_resource_io;
                                res_attr->write = pci_write_resource_io;
                            }
                            res_attr->attr.name = res_attr_name;
                            res_attr->attr.mode = S_IRUSR | S_IWUSR;
                            res_attr->size = pci_resource_len(pdev, num);
                            res_attr->private = &pdev->resource[num];
                            //创建 kernel 文件
                            sysfs_create_bin_file(&pdev->dev.kobj, res_attr);

                        /* for prefetchable resources, create a WC mappable file */
                        if (!retval && pdev->resource[i].flags & IORESOURCE_PREFETCH)
                            retval = pci_create_attr(pdev, i, 1);
                    }

            //尝试匹配驱动
            device_attach(&dev->dev);
                //遍历所有driver，查看是否有匹配此设备的driver
                bus_for_each_drv(dev->bus, NULL, dev, __device_attach);
                    //判断驱动和设备是否匹配
                    driver_match_device
                        //pci_bus_match
                        drv->bus->match
                            pci_match_device(pci_drv, pci_dev);
                    //如果有匹配的，则调用驱动的probe函数
                    driver_probe_device
                        really_probe(dev, drv);
                            //pci_device_probe
                            dev->bus->probe
                                __pci_device_probe
                                    pci_call_probe
                                        local_pci_probe
                                            pci_drv->probe(pci_dev, ddi->id);

向设备的driver_override文件写入驱动名字，表示此设备只能绑定到此驱动。

static ssize_t driver_override_store(struct device *dev,
                     struct device_attribute *attr,
                     const char *buf, size_t count)
    struct pci_dev *pdev = to_pci_dev(dev);
    driver_override = kstrndup(buf, count, GFP_KERNEL);
    pdev->driver_override = driver_override;

如何匹配？
前面多次提到设备和驱动进行匹配，究竟如何匹配呢？

先看一下用来表示一个pci设备的结构体pci_dev，其中如下几个成员变量表示此pci设备的类型，一般vendor和device就足够，vendor表示此设备是哪个厂商的，device表示此设备的类型。

struct pci_dev {
    ...
    unsigned short  vendor;
    unsigned short  device;
    unsigned short  subsystem_vendor;
    unsigned short  subsystem_device;
    unsigned int    class;      /* 3 bytes: (base,sub,prog-if) */
    ...
}

再看一下用来表示设备驱动的pci_driver，其中id_table和dynids用来保存此驱动支持的设备类型，前者是静态值，后者可以通过驱动目录下的new_id动态添加。设备类型使用pci_device_id结构体来表示，其成员变量也是vendor,device等信息，和pci_dev中的信息是一样的，所以可以使用这几个字段进行匹配。

struct pci_device_id {
    __u32 vendor, device;       /* Vendor and device ID or PCI_ANY_ID*/
    __u32 subvendor, subdevice; /* Subsystem ID's or PCI_ANY_ID */
    __u32 class, class_mask;    /* (class,subclass,prog-if) triplet */
    kernel_ulong_t driver_data; /* Data private to the driver */
};

struct pci_driver {
    struct pci_device_id *id_table
    struct pci_dynids dynids;
    ...
}

最终使用函数pci_match_device进行驱动和设备的匹配。

static const struct pci_device_id pci_device_id_any = {
    .vendor = PCI_ANY_ID,
    .device = PCI_ANY_ID,
    .subvendor = PCI_ANY_ID,
    .subdevice = PCI_ANY_ID,
};

static const struct pci_device_id *pci_match_device(struct pci_driver *drv, struct pci_dev *dev)
    //如果设备设置了 driver_override，则只能绑定到driver_override指定的驱动上。
    //如果不是此驱动直接返回NULL
    /* When driver_override is set, only bind to the matching driver */
    if (dev->driver_override && strcmp(dev->driver_override, drv->name))
        return NULL;

    //首先查找驱动的动态链表和设备进行匹配
    /* Look at the dynamic ids first, before the static ones */
    spin_lock(&drv->dynids.lock);
    list_for_each_entry(dynid, &drv->dynids.list, node) {
        if (pci_match_one_device(&dynid->id, dev)) {
            found_id = &dynid->id;
            break;
        }
    }
    spin_unlock(&drv->dynids.lock);

    //如果没匹配到，则查找驱动的静态table
    if (!found_id)
        found_id = pci_match_id(drv->id_table, dev);
            while (ids->vendor || ids->subvendor || ids->class_mask) {
                if (pci_match_one_device(ids, dev))
                    return ids;
                ids++;
            }

    //如果仍然没匹配到，但是指定了驱动，则强制认为匹配成功，返回 pci_device_id_any
    /* driver_override will always match, send a dummy id */
    if (!found_id && dev->driver_override)
        found_id = &pci_device_id_any;

    return found_id;

//具体的匹配规则
static inline const struct pci_device_id *
pci_match_one_device(const struct pci_device_id *id, const struct pci_dev *dev)
{
    if ((id->vendor == PCI_ANY_ID || id->vendor == dev->vendor) &&
        (id->device == PCI_ANY_ID || id->device == dev->device) &&
        (id->subvendor == PCI_ANY_ID || id->subvendor == dev->subsystem_vendor) &&
        (id->subdevice == PCI_ANY_ID || id->subdevice == dev->subsystem_device) &&
        !((id->class ^ dev->class) & id->class_mask))
        return id;
    return NULL;
}

绑定到 igb_uio 驱动

网卡如何绑定到igb_uio驱动呢？这里拿DPDK提供的脚步文件dpdk-devbind.py中的函数bind_one进行分析。

def bind_one(dev_id, driver, force):
    '''Bind the device given by "dev_id" to the driver "driver". If the device
    is already bound to a different driver, it will be unbound first'''
    dev = devices[dev_id]
    saved_driver = None  # used to rollback any unbind in case of failure

    //如果网卡已经绑定到某个驱动，则判断是否是要绑定的驱动，如果是则返回，
    //如果不是，则解绑之前的驱动。unbind_one只要向驱动的unbind写入此网卡的pci地址即可解绑。
    # unbind any existing drivers we don't want
    if has_driver(dev_id):
        if dev["Driver_str"] == driver:
            print("%s already bound to driver %s, skipping\n"
                  % (dev_id, driver))
            return
        else:
            saved_driver = dev["Driver_str"]
            unbind_one(dev_id, force)
            dev["Driver_str"] = ""  # clear driver string

    //绑定方法根据kernel版本有不同的绑定方法。
    //对于kernel版本大于等于3.15的，首先将驱动名字写入到网卡的文件 driver_override来指定此驱动。
    //而小于3.15的，需要将网卡的vendor和device id写入驱动的new_id文件。
    //为什么大于等于3.15的不使用new_id呢？这是因为高版本的new_id不只是将设备类型添加到驱动的
    //动态链表，也会遍历所有的设备将此类型的设备全部绑定到此驱动。如果你只想绑定一个网卡，
    //结果把同类型的网卡都绑定了，岂不是很尴尬。
    # For kernels >= 3.15 driver_override can be used to specify the driver
    # for a device rather than relying on the driver to provide a positive
    # match of the device.  The existing process of looking up
    # the vendor and device ID, adding them to the driver new_id,
    # will erroneously bind other devices too which has the additional burden
    # of unbinding those devices
    if driver in dpdk_drivers:
        filename = "/sys/bus/pci/devices/%s/driver_override" % dev_id
        if os.path.exists(filename):
            try:
                f = open(filename, "w")
            except:
                print("Error: bind failed for %s - Cannot open %s"
                      % (dev_id, filename))
                return
            try:
                f.write("%s" % driver)
                f.close()
            except:
                print("Error: bind failed for %s - Cannot write driver %s to "
                      "PCI ID " % (dev_id, driver))
                return
        # For kernels < 3.15 use new_id to add PCI id's to the driver
        else:
            filename = "/sys/bus/pci/drivers/%s/new_id" % driver
            try:
                f = open(filename, "w")
            except:
                print("Error: bind failed for %s - Cannot open %s"
                      % (dev_id, filename))
                return
            try:
                # Convert Device and Vendor Id to int to write to new_id
                f.write("%04x %04x" % (int(dev["Vendor"],16),
                        int(dev["Device"], 16)))
                f.close()
            except:
                print("Error: bind failed for %s - Cannot write new PCI ID to "
                      "driver %s" % (dev_id, driver))
                return

    //第二步是将网卡的pci地址写入驱动的文件 /sys/bus/pci/drivers/%s/bind，这样就能将
    //网卡和驱动绑定到一起。
    # do the bind by writing to /sys
    filename = "/sys/bus/pci/drivers/%s/bind" % driver
    try:
        f = open(filename, "a")
    except:
        print("Error: bind failed for %s - Cannot open %s"
              % (dev_id, filename))
        if saved_driver is not None:  # restore any previous driver
            bind_one(dev_id, saved_driver, force)
        return
    try:
        f.write(dev_id)
        f.close()
    except:
        # for some reason, closing dev_id after adding a new PCI ID to new_id
        # results in IOError. however, if the device was successfully bound,
        # we don't care for any errors and can safely ignore IOError
        tmp = get_pci_device_details(dev_id, True)
        if "Driver_str" in tmp and tmp["Driver_str"] == driver:
            return
        print("Error: bind failed for %s - Cannot bind to driver %s"
              % (dev_id, driver))
        if saved_driver is not None:  # restore any previous driver
            bind_one(dev_id, saved_driver, force)
        return

    //对于kernel版本大于等于3.15的，还要将文件 driver_override 清空，以便绑定到其他驱动。
    # For kernels > 3.15 driver_override is used to bind a device to a driver.
    # Before unbinding it, overwrite driver_override with empty string so that
    # the device can be bound to any other driver
    filename = "/sys/bus/pci/devices/%s/driver_override" % dev_id
    if os.path.exists(filename):
        try:
            f = open(filename, "w")
        except:
            print("Error: unbind failed for %s - Cannot open %s"
                  % (dev_id, filename))
            sys.exit(1)
        try:
            f.write("\00")
            f.close()
        except:
            print("Error: unbind failed for %s - Cannot open %s"
                  % (dev_id, filename))
            sys.exit(1)

igb_uio驱动的id_table为空，则在加载此驱动时，是不会匹配到任何设备的。

static struct pci_driver igbuio_pci_driver = {
    .name = "igb_uio",
    .id_table = NULL,  //DPDK 用到的 igb_uio, vfio-pci等驱动的id_table默认为空
    .probe = igbuio_pci_probe,
    .remove = igbuio_pci_remove,
};

经过上面的分析，有三种方法可以将网卡绑定到驱动igb_uio

a. 如果kernel版本大于等于3.15，先向网卡的文件 /sys/bus/pci/devices/'pci address'/driver_override 写入驱动名字igb_uio，再向驱动igb_uio的文件 /sys/bus/pci/drivers/igb_uio/bind写入网卡的pci地址即可。
b. 如果kernel版本大于等于3.15，向驱动igb_uio的文件 /sys/bus/pci/drivers/igb_uio/new_id写入网卡的vendor和device id，则会自动将所有此类型并且没有绑定到任何驱动的网卡绑定到igb_uio。
c. 如果kernel版本小于3.15，先向驱动igb_uio的文件 /sys/bus/pci/drivers/igb_uio/new_id写入网卡的vendor和device id，再向驱动igb_uio的文件 /sys/bus/pci/drivers/igb_uio/bind写入网卡的pci地址即可。注意低版本的kernel，在向new_id写入值时，只会将设备类型添加到此驱动的动态链表，而不会自动探测设备。

igb_uio probe
经过前面的分析网卡绑定到了igb_uio驱动后，会调用驱动的probe函数igbuio_pci_probe，主要做了如下几个事情：
a. 调用pci_enable_device使能pci设备
b. 设置DMA mask
c. 填充struct uio_info信息，注册uio设备
d. 注册中断处理函数

static int
igbuio_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
    struct rte_uio_pci_dev *udev;
    dma_addr_t map_dma_addr;
    void *map_addr;

    udev = kzalloc(sizeof(struct rte_uio_pci_dev), GFP_KERNEL);
    
    //使能pci设备
    /*
     * enable device: ask low-level code to enable I/O and
     * memory
     */
    pci_enable_device(dev);

    /* enable bus mastering on the device */
    pci_set_master(dev);
    
    //将设备的memory类型BAR信息保存到 struct uio_info->mem中，
    //将设备的io类型BAR信息保存到 struct uio_info->port中
    /* remap IO memory */
    igbuio_setup_bars(dev, &udev->info);
    
    /* set 64-bit DMA mask */
    pci_set_dma_mask(dev,  DMA_BIT_MASK(64));
    pci_set_consistent_dma_mask(dev, DMA_BIT_MASK(64));

    //填充 struct uio_info 其他字段
    /* fill uio infos */
    udev->info.name = "igb_uio";
    udev->info.version = "0.1";
    udev->info.irqcontrol = igbuio_pci_irqcontrol;
    udev->info.open = igbuio_pci_open;
    udev->info.release = igbuio_pci_release;
    udev->info.priv = udev;
    udev->pdev = dev;
    
    //创建 /sys/bus/pci/devices/'pci address'/max_vf 文件，
    //写此文件用来生成 VF，这说明即使网卡绑定到igb_uio口，仍然可以
    //生成 VF。
    sysfs_create_group(&dev->dev.kobj, &dev_attr_grp);
    
    //注册uio，会生成 /dev/uiox 字符设备文件，
    //同时生成目录 /sys/bus/pci/devices/'pci address'/uio/uiox
    /* register uio driver */
    uio_register_device(&dev->dev, &udev->info);

    //保存 struct rte_uio_pci_dev 到 dev->driver_data
    pci_set_drvdata(dev, udev);
        dev_set_drvdata(&pdev->dev, data);
            dev->driver_data = data;

宏uio_register_device用来注册uio设备。

/* use a define to avoid include chaining to get THIS_MODULE */
#define uio_register_device(parent, info) \
    __uio_register_device(THIS_MODULE, parent, info)

int __uio_register_device(struct module *owner,
              struct device *parent,
              struct uio_info *info)
    //根据 uio_info 生成 uio_device
    struct uio_device *idev;
    idev = devm_kzalloc(parent, sizeof(*idev), GFP_KERNEL);

    idev->owner = owner;
    idev->info = info;
    init_waitqueue_head(&idev->wait);
    atomic_set(&idev->event, 0);

    //分配最小未使用的id，保存到 idev->minor
    uio_get_minor(idev);
    //创建字符设备 /dev/uiox
    idev->dev = device_create(&uio_class, parent, MKDEV(uio_major, idev->minor), idev, "uio%d", idev->minor);
    
    //在 /sys/class/uio/uiox/下创建maps目录，maps目录下根据 struct uio_info->mem和port信息
    //分别生成 mapx 和 portx 等目录，这些目录下又存放对应类型的信息，比如起始地址，name，offset和size。
    //用户态可以通过mmap mapx下的文件来操作网卡寄存器。
    //但是DPDK没有使用此方法，而是直接mmap /sys/bus/pci/devices/'pci address'/resource0 文件实现。
    uio_dev_add_attributes(idev);
    info->uio_dev = idev;
    
    //注册中断。但是在新版本的DPDK中，注册uio时没有分配info->irq来注册中断，
    //而是在用户态 open /dev/uiox 时，在函数 igbuio_pci_open 中注册中断。
    if (info->irq && (info->irq != UIO_IRQ_CUSTOM)) {
        devm_request_irq(idev->dev, info->irq, uio_interrupt, info->irq_flags, info->name, idev);
    }

简单总结一下，igb_uio是DPDK使用网卡的一个通用驱动，不只intel网卡可以用，其他厂商的网卡也可以用(有一个例外，mellanox的网卡不用绑定到igb_uio就能被使用DPDK)，因为它只使能了pci设备，注册uio，和注册中断处理函数，这些工作是不区分网卡类型的。
加载igb_uio时，不会自动探测pci设备，而是需要写sys文件将设备绑定到igb_uio。

igb_uio依赖uio驱动，注册uio设备后，会生成/dev/uiox，和网卡一一对应，用户态可以poll /dev/uiox监听中断是否到来。
同时uio设备还会将网卡的BAR地址通过sys文件系统暴露出去，用户态可以mmap sys文件后操作网卡寄存器。但是DPDK没有采用这种方式，而是直接mmap网卡自身暴露出去的sys文件 /sys/bus/pci/devices/'pci address'/resource0。

参考

https://www.cnblogs.com/jungle1996/p/12398915.html
https://www.cnblogs.com/jungle1996/p/12452636.html