深入理解VFIO驱动框架
作者介绍：
Jack,目前就职于通信行业某上市公司，主要从事Linux相关系统软件开发工作，负责基带芯片Soc芯片建模仿真以及虚拟化系统软件开发，基带芯片soc芯片BringUp及驱动开发，喜欢阅读内核源代码，在不断的学习和工作中深入理解外设虚拟化，网络虚拟化，用户态驱动等内核子系统。
VFIO（Virtual Function I/O）驱动框架是一个用户态驱动框架，在intel平台它充分利用了VT-d等技术提供的DMA Remapping和Interrupt Remapping特性， 在保证直通设备的DMA安全性同时可以达到接近物理设备的I/O的性能。VFIO是一个可以安全的把设备I/O、中断、DMA等暴露到用户空间，用户态进程可以直接使用VFIO驱动访问硬件，从而可以在用户空间完成设备驱动的框架。在内核源码附带的文档<<Documentation/vfio.txt>>中对VFIO描述的相关概念有比较清楚的描述，也对VFIO的使用方法有清楚的描述。对于VT-d，DMAR 等硬件技术细节，可以参考VT-d的SPEC等文档，本文不对具体的物理硬件特性进行描述，涉及到相关部分只是做简单介绍。
在VFIO驱动框架中，有几个核心概念需要理解。包括：IOMMU，device , group ,container。
IOMMU是一个硬件单元，它可以把设备的IO地址映射成虚拟地址，为设备提供页表映射，设备通过IOMMU将数据直接DMA写到用户空间。
Device 是指要操作的硬件设备，这里的设备需要从IOMMU拓扑的角度来看。如果device 是一个硬件拓扑上是独立那么这个设备构成了一个IOMMU group。如果多个设备在硬件是互联的，需要相互访问数据，那么这些设备需要放到一个IOMMU group 中隔离起来。
Group 是IOMMU 能进行DMA隔离的最小单元。一个group 可以有一个或者多个device。
container 是由多个group 组成。虽然group 是VFIO 的最小隔离单元，但是并不是最好的分割粒度，比如多个group 需要共享一个页表的时候。将多个group 组成一个container来提高系统的性能，也方便用户管理。一般一个进程作为一个container。
下图描述了device , group ,container和用户进程（app）的关系。
图1 container、group与device关系
01
VFIO 驱动框架设计分析
VFIO 驱动框架设计的比较清晰，最上层的vifo interface 是和用户进行ioctl 交互的接口。在内核源码中代码路径为：drivers\vfio\vfio.c。vifo_iommu 是对IOMMU driver 的封装，为vifo interface 提供IOMMU 功能，在内核源码中代码路径为：drivers\vfio\vfio_iommu_type1.c。iommu driver 是物理硬件的IOMMU 实现，例如intel VT-D。vfio_pci 是的device 驱动的封装，为vfio interface 提供设备的访问能力，例如访问设备的配置空间，bar空间。在内核源码中代码路径为：drivers\vfio \pci\ vfio_pci.c 。pci_bus driver 是物理PCI 设备的驱动。VFIO的中断重映射相关的部分需要有kvm 相关的代码分析，本文没有分析。
图2 vfio 驱动框架
02
VFIO 用户接口三个层面
VFIO 给用户空间提供的接口主要是有三个层面上的，第一个是container 层面，第二个是group 层面，第三个是device层面。
第一个层面，container的操作是通过打开/dev/vifo/vifo 文件对其执行ioctl操作，主要的操作有：
VFIO_GET_API_VERSION：获取VFIO版本信息
VFIO_CHECK_EXTENSION：检测是否支持特定扩展，支持哪些类型的IOMMU
VFIO_SET_IOMMU:设置指定的IOMMU类型
VFIO_IOMMU_GET_INFO：获取IOMMU的信息
VFIO_IOMMU_MAP_DMA：指定设备端看到的IO地址到进程的虚拟地址之间的映射
第二个层面，group的操作是通过打开/dev/vifo/<group_id>文件, 对其执行ioctl操作，主要的操作有：
VFIO_GROUP_GET_STATUS:获取group 的状态信息
VFIO_GROUP_SET_CONTAINER:设置group 和container 之间的绑定关系
VFIO_GROUP_GET_DEVICE_FD:获取device 的文件描述符fd.
第三个层面的是device ,通过group 层面的ioctl的VFIO_GROUP_GET_DEVICE_FD 命令获取fd, 对获取的fd执行ioctl操作，主要的操作有：
VFIO_DEVICE_GET_REGION_INFO:用来获得设备指定区域region的数据，这里的region 不仅仅是指bar 空间还包括rom空间和配置空间。
VFIO_DEVICE_GET_IRQ_INFO:得到设备的中断信息
VFIO_DEVICE_RESET:重置设备
下图展示了用户态app,内核态VFIO, vfio-pci驱动，VFIO IOMMU 驱动，PCI驱动，IOMMU 驱动以及内核态和用户态通过三个层面的接口示意图：
图3 应用程序和VFIO接口
03
VFIO 驱动主要数据结构
static struct vfio {
struct class*class;
struct list_headiommu_drivers_list;
struct mutexiommu_drivers_lock;
struct list_headgroup_list;
struct idrgroup_idr;
struct mutexgroup_lock;
struct cdevgroup_cdev;
dev_tgroup_devt;
wait_queue_head_trelease_q;
} vfio;struct vfio 的主要成员变量有：iommu_drivers_list：挂接在container 上的所有vfio iommu_drivers，是对IOMMU driver 的一种封装。group_list：挂接所有 vfio_group, group_idr :idr 值，关联次设备号，group_devt：group 的设备号，group_cdev：表明为一个字符设备。
struct vfio_container {
struct krefkref;
struct list_headgroup_list;
struct rw_semaphoregroup_lock;
struct vfio_iommu_driver*iommu_driver;
void*iommu_data;
boolnoiommu;
};struct vfio_container 的主要变量有：group_list：关联到vfio_container 上的所有vifo_ group, iommu_driver: vfio_container对iommu设备驱动的封装。iommu_data：iommu_driver->open（）函数的返回值，vifo_iommu对象。
struct vfio_group {
struct krefkref;
intminor;
atomic_tcontainer_users;
struct iommu_group*iommu_group;
struct vfio_container*container;
struct list_headdevice_list;
struct mutexdevice_lock;
struct device*dev;
struct notifier_blocknb;
struct list_headvfio_next;
struct list_headcontainer_next;
struct list_headunbound_list;
struct mutexunbound_lock;
atomic_topened;
wait_queue_head_tcontainer_q;
boolnoiommu;
struct kvm*kvm;
struct blocking_notifier_headnotifier;
};struct vfio_group 的主要变量有：minor为在注册group设备时的次设备号，container_users为该group的container的计数，iommu_group为该group封装的iommu-group, container为该group关联的container，device_list将属于该group下的所有设备连接起来，vfio_next 挂接在vfio. group_list 上，container_next挂接在vfio_container. group_list上，unbound_lock 是挂在vfio_unbound_dev. unbound_next 上，opened表明该group 是否初始化完成。
struct vfio_device {
struct krefkref;
struct device*dev;
const struct vfio_device_ops*ops;
struct vfio_group*group;
struct list_headgroup_next;
void*device_data;
};vfio_device的主要变量有：ops,指向vfio_pci_ops,group表示所属group,group_next连接同一个group 中的设备，device_data指向vfio_pci_device.
struct vfio_iommu {
struct list_headdomain_list;
struct vfio_domain*external_domain; /* domain for external user */
struct mutexlock;
struct rb_rootdma_list;
struct blocking_notifier_head notifier;
unsigned intdma_avail;
boolv2;
boolnesting;
};vfio_iommu的主要变量有：domain_list 为该vfio_iommu下挂接的vfio_domain，external_domain 用于pci_mdev下的vfio_domain，dma_list为dma 的rb_root的根节点，dma_avail表示dma 条目数量。
struct vfio_domain {
struct iommu_domain*domain;
struct list_headnext;
struct list_headgroup_list;
intprot;/* IOMMU_CACHE */
boolfgsp;/* Fine-grained super pages */
};vfio_domain的主要变量有：domain为对iommu_domain的封装，next挂接到vfio_iommu. domain_list, group_list是挂在该vfio_domain上的vfio_group。
struct vfio_group {
struct iommu_group*iommu_group;
struct list_headnext;
boolmdev_group;/* An mdev group */
};vfio_group的主要成员变量有：iommu_group是对iommu_group的封装，next挂接到vfio_domain. group_list.
04
VFIO 驱动框架分析
1）vfio 驱动分析
在vfio.ko驱动加载和卸载的时候会执行vfio_init（），vfio_cleanup（）函数。下面分步对这2个函数进行分析。
static int __init vfio_init(void)
{
………
ret = misc_register(&vfio_dev);
if (ret) {
pr_err("vfio: misc device register failed\n");
return ret;
}
……………
}
static void __exit vfio_cleanup(void)
{
…….
misc_deregister(&vfio_dev);
}
module_init(vfio_init);
module_exit(vfio_cleanup);上面代码说明vifo 作为一个混杂字符设备注册进内核，混杂设备为定义为vfio_dev。
static struct miscdevice vfio_dev = {
.minor = VFIO_MINOR,
.name = "vfio",
.fops = &vfio_fops,
.nodename = "vfio/vfio",
.mode = S_IRUGO | S_IWUGO,
};完成混杂设备注册后，会在/dev/vifo/fifo 创建设备节点，用户可以对其进行操作。具体的操作函数为vfio_fops
static const struct file_operations vfio_fops = {
.owner= THIS_MODULE,
.open= vfio_fops_open,
.release= vfio_fops_release,
.read= vfio_fops_read,
.write= vfio_fops_write,
.unlocked_ioctl= vfio_fops_unl_ioctl,
#ifdef CONFIG_COMPAT
.compat_ioctl= vfio_fops_compat_ioctl,
#endif
.mmap= vfio_fops_mmap,
};vfio_fops_open（）函数主要完成struct vfio_container 对象的实例化，并将实例化的对象放到filep->private_data中。
vfio_fops_release（）函数主要完成vfio_container对象的释放。
vfio_fops_read（），vfio_fops_write（），vfio_fops_mmap（）主要是对vfio_iommu_driver 的read(),write(),mmap()函数的封装。
vfio_fops_unl_ioctl（）函数大部分cmd 也是对vfio_iommu_driver 的ioctl()函数的封装，主要有一个VFIO_SET_IOMMU命令，完成vfio_container和vfio_iommu_driver的绑定。
static long vfio_ioctl_set_iommu(struct vfio_container *container,
unsigned long arg)
{
……
list_for_each_entry(driver, &vfio.iommu_drivers_list, vfio_next)
{
…………
if (driver->ops->ioctl(NULL, VFIO_CHECK_EXTENSION, arg) <= 0) {
module_put(driver->ops->owner);
continue;
}
data = driver->ops->open(arg);
if (IS_ERR(data)) {
ret = PTR_ERR(data);
module_put(driver->ops->owner);
continue;
}
ret = __vfio_container_attach_groups(container, driver, data);
if (ret) {
driver->ops->release(data);
module_put(driver->ops->owner);
continue;
}
container->iommu_driver = driver;
container->iommu_data = data;
break;
}
………
}vfio_ioctl_set_iommu（）函数的参数arg 是用户态进程指定vfio_iommu驱动类型，例如VFIO_TYPE1_IOMMU等。vfio_ioctl_set_iommu（）会遍历vfio.iommu_drivers_list，如果driver->ops->ioctl(NULL, VFIO_CHECK_EXTENSION, arg)大于0，表明支持用户态所指定的驱动，否则继续遍历。如果遍历到了，调用vfio_iommu 驱动函数open（）返回一个vfio_iommu 对象，然后执行__vfio_container_attach_groups(container, driver, data)将container 上所有group都附加到该vfio_iommu 驱动上，并且设置container 的成员变量。其中__vfio_container_attach_groups（）函数最终是调用vfio_iommu驱动的attach_group（）函数完成该container 上的group都附加到该vfio_iommu 驱动上。
2）vfio iommu驱动分析
以intel iommu 为例，vfio_iommu_type1.c 为vfio驱动对iommu驱动的封装。vfio_iommu_type1_init（），vfio_iommu_type1_cleanup（）为vfio_iommu_type1.ko模块的加载和卸载时调用的函数。这2个函数分别主要是执行vfio_register_iommu_driver（），vfio_unregister_iommu_driver（）完成vifo iommu driver 的注册和注销。具体函数如下：
static int __init vfio_iommu_type1_init(void)
{
return vfio_register_iommu_driver(&vfio_iommu_driver_ops_type1);
}
static void __exit vfio_iommu_type1_cleanup(void)
{
vfio_unregister_iommu_driver(&vfio_iommu_driver_ops_type1);
}
int vfio_register_iommu_driver(const struct vfio_iommu_driver_ops *ops)
{
struct vfio_iommu_driver *driver, *tmp;
driver = kzalloc(sizeof(*driver), GFP_KERNEL);
if (!driver)
return -ENOMEM;
driver->ops = ops;
mutex_lock(&vfio. iommu_drivers_lock);
/* Check for duplicates */
list_for_each_entry(tmp, &vfio.iommu_drivers_list, vfio_next) {
if (tmp->ops == ops) {
mutex_unlock(&vfio.iommu_drivers_lock);
kfree(driver);
return -EINVAL;
}
}
list_add(&driver->vfio_next, &vfio.iommu_drivers_list);
mutex_unlock(&vfio.iommu_drivers_lock);
return 0;
}vfio_register_iommu_driver（）函数申请一个vfio_iommu_driver 对象，并将传入的ops 挂在对象上，将vfio_iommu_driver 对象添加到vfio.iommu_drivers_list链表上。Container在执行相关操作的时候会通过vfio.iommu_drivers_list链表找到最终的操作函数ops。即：
static const struct vfio_iommu_driver_ops vfio_iommu_driver_ops_type1 = {
.name= "vfio-iommu-type1",
.owner= THIS_MODULE,
.open= vfio_iommu_type1_open,
.release= vfio_iommu_type1_release,
.ioctl= vfio_iommu_type1_ioctl,
.attach_group= vfio_iommu_type1_attach_group,
.detach_group= vfio_iommu_type1_detach_group,
.pin_pages= vfio_iommu_type1_pin_pages,
.unpin_pages= vfio_iommu_type1_unpin_pages,
.register_notifier= vfio_iommu_type1_register_notifier,
.unregister_notifier= vfio_iommu_type1_unregister_notifier,
};vfio_iommu_driver_ops_type1 是对intel iommu 驱动的封装，最主要的功能是完成group 内的设备的内存映射和解映射。这个功能是通过vfio_iommu_type1_ioctl 的VFIO_IOMMU_MAP_DMA和VFIO_IOMMU_UNMAP_DMA命令来完成。用户空间传递的参数结构体如下：
struct vfio_iommu_type1_dma_map {
__u32argsz;
__u32flags;
#define VFIO_DMA_MAP_FLAG_READ (1 << 0)/* readable from device */
#define VFIO_DMA_MAP_FLAG_WRITE (1 << 1)/* writable from device */
__u64vaddr;/* Process virtual address */
__u64iova;/* IO virtual address */
__u64size;/* Size of mapping (bytes) */
};内核在接收这个参数后调用vfio_dma_do_map（），vfio_dma_do_unmap（）完成对内存的映射/解映射。这里以dma 映射为例说明，解映射过程可以参考内核代码。
static int vfio_dma_do_map(struct vfio_iommu *iommu,struct vfio_iommu_type1_dma_map *map)
{
dma_addr_t iova = map->iova;
unsigned long vaddr = map->vaddr;
size_t size = map->size;
int ret = 0, prot = 0;
uint64_t mask;
struct vfio_dma *dma;
……
dma = kzalloc(sizeof(*dma), GFP_KERNEL);
if (!dma) {
ret = -ENOMEM;
goto out_unlock;
}
iommu->dma_avail--;
dma->iova = iova;
dma->vaddr = vaddr;
dma->prot = prot;
get_task_struct(current->group_leader);
dma->task = current->group_leader;
dma->lock_cap = capable(CAP_IPC_LOCK);
dma->pfn_list = RB_ROOT;
ret = vfio_pin_map_dma(iommu, dma, size);
……
}首先对入参进行检查，再申请一个dma 对象并填充其成员变量，然后对填充完了的dma 进行vfio_pin_map_dma（）操作。
static int vfio_pin_map_dma(struct vfio_iommu *iommu, struct vfio_dma *dma,
size_t map_size)
{
dma_addr_t iova = dma->iova;
unsigned long vaddr = dma->vaddr;
size_t size = map_size;
long npage;
unsigned long pfn, limit = rlimit(RLIMIT_MEMLOCK) >> PAGE_SHIFT;
int ret = 0;
while (size) {
/* Pin a contiguous chunk of memory */
npage = vfio_pin_pages_remote(dma, vaddr + dma->size,
size >> PAGE_SHIFT, &pfn, limit);
if (npage <= 0) {
WARN_ON(!npage);
ret = (int)npage;
break;
}
/* Map it! */
ret = vfio_iommu_map(iommu, iova + dma->size, pfn, npage,
dma->prot);
if (ret) {
vfio_unpin_pages_remote(dma, iova + dma->size, pfn,
npage, true);
break;
}
size -= npage << PAGE_SHIFT;
dma->size += npage << PAGE_SHIFT;
}
dma->iommu_mapped = true;
if (ret)
vfio_remove_dma(iommu, dma);
return ret;
}vfio_pin_pages_remote（）函数是将将要映射的npage页pin 到该用户态应用程序中，然后调用vfio_iommu_map（）进行dma 内存映射，vfio_iommu_map（）函数调用iommu_map（）函数，该函数最终使用ops->map（）完成硬件的映射操作。对于vfio_iommu_driver_ops_type1，Ops为intel_iommu_ops。同理vfio_iommu_driver_ops_type1的其他成员函数最终调用intel_iommu_ops，完成对真实iommu 硬件的操作。
从上面分析可知，vfio_iommu主要功能就是完成dma 映射内存页的pin操作和相关内存管理以及对硬件iommu驱动的封装，同时也为vfio 的container提供接口操作。
3）vfio group驱动分析
继续回到vfio_init（）函数，
static int __init vfio_init(void)
{
………
/* /dev/vfio/$GROUP */
vfio.class = class_create(THIS_MODULE, "vfio");
if (IS_ERR(vfio.class)) {
ret = PTR_ERR(vfio.class);
goto err_class;
}
vfio.class->devnode = vfio_devnode;
ret = alloc_chrdev_region(&vfio.group_devt, 0, MINORMASK + 1, "vfio");
if (ret)
goto err_alloc_chrdev;
cdev_init(&vfio.group_cdev, &vfio_group_fops);
ret = cdev_add(&vfio.group_cdev, vfio.group_devt, MINORMASK + 1);
if (ret)
goto err_cdev_add;
……………
}
static void __exit vfio_cleanup(void)
{
……
idr_destroy(&vfio. group_idr);
cdev_del(&vfio.group_cdev);
unregister_chrdev_region(vfio.group_devt, MINORMASK + 1);
class_destroy(vfio.class);
vfio.class = NULL;
………
}
module_init(vfio_init);
module_exit(vfio_cleanup);这部分代码是对vfio 中vfio_group设备的初始化相关的代码。为创建/dev/vfio/GROUP 设备文件准备好对应的操作数据，GROUP是对应的group id。最终使用vfio_group_fops 函数的是vfio_create_group（）函数
static struct vfio_group *vfio_create_group(struct iommu_group *iommu_group)
{
……
dev = device_create(vfio.class, NULL,
MKDEV(MAJOR(vfio.group_devt), minor),
group, "%s%d", group->noiommu ? "noiommu-" : "",
iommu_group_id(iommu_group));
if (IS_ERR(dev)) {
vfio_free_group_minor(minor);
vfio_group_unlock_and_free(group);
return ERR_CAST(dev);
}
……
}
创建好/dev/vfio/$GROUP后对其设备文件操作的接口是vfio_group_fops
static const struct file_operations vfio_group_fops = {
.owner= THIS_MODULE,
.unlocked_ioctl= vfio_group_fops_unl_ioctl,
#ifdef CONFIG_COMPAT
.compat_ioctl= vfio_group_fops_compat_ioctl,
#endif
.open= vfio_group_fops_open,
.release= vfio_group_fops_release,
};vfio_group_fops_open（）函数完成对vfio_group 对象的检查，该对象是vfio_create_group（）中创建，同时设置该对象正在使用并加入到container 中，最后将其对象放入filep->private_data中。
vfio_group_fops_release（）函数完成从container中去掉该vfio_group对象，并取消该对象正在使用。
vfio_group_fops_unl_ioctl（）函数完成对vfio_group控制，其中
VFIO_GROUP_GET_STATUS：获取vfio_group 的状态
VFIO_GROUP_SET_CONTAINER：将vfio_group 和vfio_iommu 绑定
VFIO_GROUP_UNSET_CONTAINER：将vfio_group 和vfio_iommu 解绑定
VFIO_GROUP_GET_DEVICE_FD：获取vifo_device设备描述符号。
4）vfio device驱动分析
vifo_device 的创建函数为struct vfio_device *vfio_group_create_device(struct vfio_group *group,struct device *dev,const struct vfio_device_ops *ops,void *device_data)。
vifo_device 表示在VFIO 层面的设备，dev 为物理设备，ops为物理设备的操作回调，这里是vfio_pci_ops,group 表示设备所属的vfio_group,device_data保存私有数据，这里是vfio_pci_device结构体。
在vfio_group 设备文件操作的ioctl命令中，使用VFIO_GROUP_GET_DEVICE_FD 来获取设备描述符,该命令调用的函数为：static int vfio_group_get_device_fd(struct vfio_group *group, char *buf)，buf中保存了用户空间传过来的设备地址（pci设备地址:domain:bus:dev:function）。
static int vfio_group_get_device_fd(struct vfio_group *group, char *buf)
{
……
device = vfio_device_get_from_name(group, buf);
if (!device)
return -ENODEV;
ret = device->ops->open(device->device_data);
if (ret) {
vfio_device_put(device);
return ret;
}
ret = get_unused_fd_flags(O_CLOEXEC);
if (ret < 0) {
device->ops->release(device->device_data);
vfio_device_put(device);
return ret;
}
filep = anon_inode_getfile("[vfio-device]", &vfio_device_fops,
device, O_RDWR);
if (IS_ERR(filep)) {
put_unused_fd(ret);
ret = PTR_ERR(filep);
device->ops->release(device->device_data);
vfio_device_put(device);
return ret;
}
/*
* TODO: add an anon_inode interface to do this.
* Appears to be missing by lack of need rather than
* explicitly prevented. Now there's need.
*/
filep->f_mode |= (FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE);
atomic_inc(&group->container_users);
fd_install(ret, filep);
……
}首先通过group和设备名称找到设备（用户空间传进来的buf），找到后打开该设备。接着使用get_unused_fd_flags 获取一个空闲的fd,调用anon_inode_getfile获取一个文件结构体并设置该文件结构体的操作函数为vfio_device_fops，调用fd_install将空闲fd 和文件结构关联起来，最后返回该fd 给用户空间，用户空间操作该fd 的操作函数变成了vfio_device_fops操作了。
static const struct file_operations vfio_device_fops = {
.owner= THIS_MODULE,
.release= vfio_device_fops_release,
.read= vfio_device_fops_read,
.write= vfio_device_fops_write,
.unlocked_ioctl= vfio_device_fops_unl_ioctl,
#ifdef CONFIG_COMPAT
.compat_ioctl= vfio_device_fops_compat_ioctl,
#endif
.mmap= vfio_device_fops_mmap,
};vfio_device_fops 操作只是对物理设备的封装，最终调用的是vfio_pci_ops的操作。
5）vfio-pci驱动分析
通过上面对group ，device 的介绍，应用程序最终的是需要操作具体的物理设备的，具体的物理设备是挂在pci 总线上，vfio-pci 是对pci 设备的封装。vfio_pci.ko模块的加载和卸载执行函数为：
static int __init vfio_pci_init(void)
{
……
ret = pci_register_driver(&vfio_pci_driver);
……
}
static void __exit vfio_pci_cleanup(void)
{
pci_unregister_driver(&vfio_pci_driver);
……
}
static struct pci_driver vfio_pci_driver = {
.name= "vfio-pci",
.id_table= NULL, /* only dynamic ids */
.probe= vfio_pci_probe,
.remove= vfio_pci_remove,
.err_handler= &vfio_err_handlers,
};vfio_pci_driver驱动的id_table= NULL，这就表明在驱动加载的时候无法通过pci 总线match 到该设备驱动，需要用户主动绑定/解绑vfio-pci 设备才能调用pci 设备probe/remove 函数。先看probe 函数
static int vfio_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)
{
struct vfio_pci_device *vdev;
……
vdev = kzalloc(sizeof(*vdev), GFP_KERNEL);
if (!vdev) {
vfio_iommu_group_put(group, &pdev->dev);
return -ENOMEM;
}
……
ret = vfio_add_group_dev(&pdev->dev, &vfio_pci_ops, vdev);
if (ret) {
vfio_iommu_group_put(group, &pdev->dev);
kfree(vdev);
return ret;
}
……
}vfio_pci_probe 函数主要处理的是struct vfio_pci_device *vdev，vfio_pci_device 结构体是对实际的pci设备的抽象，通过vfio_add_group_dev（）函数完成vfio_pci_device和vfio_grop,vfio_device 的绑定，也实现对vifo_group,vifo_device 的创建，还实现将vifo_device的操作方法挂接到vfio_pci_device的操作方法上。
int vfio_add_group_dev(struct device *dev,const struct vfio_device_ops *ops, void *device_data) 函数的三个入参：第一个表示物理设备，第二个参数是作为vfio_device 的回调，第三个参数是vfio_pci_device 作为vfio_device一个私有数据保存下来。对于第二个参数，最终调用的是vfio_pci_ops。
static const struct vfio_device_ops vfio_pci_ops = {
.name= "vfio-pci",
.open= vfio_pci_open,
.release= vfio_pci_release,
.ioctl= vfio_pci_ioctl,
.read= vfio_pci_read,
.write= vfio_pci_write,
.mmap= vfio_pci_mmap,
.request= vfio_pci_request,
};vfio_pci_open（），vfio_pci_release（），vfio_pci_read（），vfio_pci_write（）是对物理设备pci 操作的封装。vfio_pci_mmap（）是对pci 的空间进行映射，当用户空间执行mmap 操作是实现地址转换。vfio_pci_request（）是通过eventfd_signal（）向用户空间发生请求信号。最主要的操作是vfio_pci_ioctl（）函数，通过不同命令字，对物理pci设备的操作。主要有以下操作：
VFIO_DEVICE_GET_INFO：获取设备信息，通过struct vfio_device_info 返回给用户空间。argsz表示参数大小，输入参数，flags表示设备支持的特性，regions表示区域个数，num_irqs 表示中断个数，后三个为输出参数。
struct vfio_device_info {
__u32argsz;
__u32flags;
#define VFIO_DEVICE_FLAGS_RESET(1 << 0)/* Device supports reset */
#define VFIO_DEVICE_FLAGS_PCI(1 << 1)/* vfio-pci device */
#define VFIO_DEVICE_FLAGS_PLATFORM (1 << 2)/* vfio-platform device */
#define VFIO_DEVICE_FLAGS_AMBA (1 << 3)/* vfio-amba device */
#define VFIO_DEVICE_FLAGS_CCW(1 << 4)/* vfio-ccw device */
#define VFIO_DEVICE_FLAGS_AP(1 << 5)/* vfio-ap device */
__u32num_regions;/* Max region index + 1 */
__u32num_irqs;/* Max IRQ index + 1 */
};VFIO_DEVICE_GET_REGION_INFO：获取设备内存区域信息，通过struct vfio_region_info返回给用户空间。argsz表示参数大小，输入参数，flags表示内存区域支持的操作，输出参数，index表示区域索引，输入参数，size 表示region大小，输出参数，cap_offset，对第一个cap 的偏移，输出参数，offset表示内存区域在fd 设备文件中对应的偏移，输出参数。
struct vfio_region_info {
__u32argsz;
__u32flags;
#define VFIO_REGION_INFO_FLAG_READ(1 << 0) /* Region supports read */
#define VFIO_REGION_INFO_FLAG_WRITE(1 << 1) /* Region supports write */
#define VFIO_REGION_INFO_FLAG_MMAP(1 << 2) /* Region supports mmap */
#define VFIO_REGION_INFO_FLAG_CAPS(1 << 3) /* Info supports caps */
__u32index;/* Region index */
__u32cap_offset;/* Offset within info struct of first cap */
__u64size;/* Region size (bytes) */
__u64offset;/* Region offset from start of device fd */
};VFIO_DEVICE_GET_IRQ_INFO：获取设备中断信息，通过struct vfio_irq_info info返回给用户空间。argsz表示参数大小，输入参数，flags表示中断支持的特性，index表示中断索引，输入参数，count 表示对应索引中断个数，输出参数。
struct vfio_irq_info {
__u32argsz;
__u32flags;
#define VFIO_IRQ_INFO_EVENTFD(1 << 0)
#define VFIO_IRQ_INFO_MASKABLE(1 << 1)
#define VFIO_IRQ_INFO_AUTOMASKED(1 << 2)
#define VFIO_IRQ_INFO_NORESIZE(1 << 3)
__u32index;/* IRQ index */
__u32count;/* Number of IRQs within this index */
};VFIO_DEVICE_SET_IRQS：设置设备中断信息，通过struct vfio_irq_set 从用户空间设置给设备。
struct vfio_irq_set {
__u32argsz;
__u32flags;
#define VFIO_IRQ_SET_DATA_NONE(1 << 0) /* Data not present */
#define VFIO_IRQ_SET_DATA_BOOL(1 << 1) /* Data is bool (u8) */
#define VFIO_IRQ_SET_DATA_EVENTFD(1 << 2) /* Data is eventfd (s32) */
#define VFIO_IRQ_SET_ACTION_MASK(1 << 3) /* Mask interrupt */
#define VFIO_IRQ_SET_ACTION_UNMASK(1 << 4) /* Unmask interrupt */
#define VFIO_IRQ_SET_ACTION_TRIGGER(1 << 5) /* Trigger interrupt */
__u32index;
__u32start;
__u32count;
__u8data[];
};VFIO_DEVICE_RESET：复位设备
vfio-pci驱动作为一个中间桥梁，是vfio模块和物理pci 设备之间的纽带。向下提供控制pci物理设备的行为，向上提供vfio的接口信息。对pci 设备的控制主要是获取和配置pci 的配置空间寄存器信息，中断信息等操作。
通过对vfio驱动框架中的vfio_container，vfio_iommu, vfio_group, vfio_device, vfio_pci的分析，可以看出如下操作调用关系：
图4 VFIO驱动框架通信接口
05
VFIO 驱动框架总结
VFIO驱动是内核提供的用户态驱动的一种，本文介绍了VFIO驱动框架中各个层次模块之间的调用关系，以及VFIO框架中各个层次的主要数据结构和这些数据结构的相关关系。VFIO驱动为用户空间操作外设提供了便利的接口，在设备虚拟化中具有广泛的应用。