1. set_guest_notifiers初始化流程

static void virtio_pci_bus_class_init(ObjectClass *klass, void *data){

k->set_guest_notifiers = virtio_pci_set_guest_notifiers;

}

2. guest_notifier的fdread函数初始化为virtio_queue_guest_notifier_read流程：

vhost_net_start

-> r = k->set_guest_notifiers(qbus->parent, total_queues * 2, true); //调用virtio_pci_set_guest_notifiers

-> virtio_pci_set_guest_notifiers

-> virtio_pci_set_guest_notifier

-> virtio_queue_set_guest_notifier_fd_handler

void virtio_queue_set_guest_notifier_fd_handler(VirtQueue *vq, bool assign, bool with_irqfd){

if (assign && !with_irqfd) {

event_notifier_set_handler(&vq->guest_notifier,virtio_queue_guest_notifier_read);

}

}

-> qemu_set_fd_handler

-> qemu_set_fd_handler2 (将virtio_queue_guest_notifier_read设置为guest_notifier的fdread函数，并加入到iohandlers中)

void pci_set_irq(PCIDevice *pci_dev, intlevel)

{int intx =pci_intx(pci_dev);

pci_irq_handler(pci_dev, intx, level);

}

/*0 <= irq_num <= 3. level must be 0 or 1*/

static void pci_irq_handler(void *opaque, int irq_num, intlevel)

{

PCIDevice*pci_dev =opaque;intchange;

change= level -pci_irq_state(pci_dev, irq_num);if (!change)return;

pci_set_irq_state(pci_dev, irq_num, level);

pci_update_irq_status(pci_dev);if(pci_irq_disabled(pci_dev))return;

pci_change_irq_level(pci_dev, irq_num, change);

}

3. PCI的中断处理函数初始化

PCIBus *i440fx_init(){

pci_bus_irqs(b, piix3_set_irq, pci_slot_get_pirq, piix3, PIIX_NUM_PIRQS); //设定bus->set_irq为piix3_set_irq

}

4. notify初始化流程

virtio_pci_bus_class_init(){

k->notify = virtio_pci_notify;  /*notify注册为virtio_pci_notify*/

}

5. 监听事件FD的过程

在vhost_net_start中，已经将guest_notifier加入到了iohandlers中

main

-> main_loop

-> main_loop_wait

-> qemu_iohandler_fill() //将iohandlers中所有的fd和处理函数加入到监听集合中

-> os_host_main_loop_wait

-> qemu_poll_ns //开始阻塞监听，返回时候说明有监听事件发生

6. Guest收包中断过程

os_host_main_loop_wait

-> qemu_poll_ns返回

-> qemu_iohandler_poll 遍历iohandlers对时间进行处理

-> 遍历iohandlers，处理所有的event

-> ioh->fd_read(ioh->opaque); //调用fdread函数，也就是virtio_queue_guest_notifier_read

-> virtio_queue_guest_notifier_read

-> virtio_irq

-> virtio_notify_vector

-> k->notify(qbus->parent, vector); //调用virtio_pci_notify

-> virtio_pci_notify

-> pci_set_irq

-> pci_irq_handler

-> pci_change_irq_level

-> bus->set_irq //调用的是piix3_set_irq

-> piix3_set_irq

-> piix3_set_irq_level

-> piix3_set_irq_pic

-> qemu_set_irq //产生中断

一. 概述

在上半部已经将GuestOS驱动与QEMU设备交互的过程描述了一下，描述的目的是便于理解Vhost-blk的工作原理，如果想从另外一个角度了解。

分享一个博文链接：http://blog.csdn.net/zhuriyuxiao/article/details/8824735

结合这篇文章，应该可以更好的理解virtio-block的原理。

言归正传，上部分总结到，GuestOS中virtio-block驱动其实只是一个请求触发，并且要一个请求处理结果，对于GuestOS virtio-blk驱动的对外接口如下：

1. virtio-blk驱动将IO请求通过virtio_queue同步给QEMU后，通过iowrite16写一个pci地址。

2.等虚拟硬件处理完IO请求以后，将请求结果通过virtio_queue同步回来，给GuestOS一个中断，调用中断处理函数，处理IO请求的结果就OK。

既然virtio-blk对外接口我们能确定，就算使用vhost-blk，也要遵循上面的接口，才能让GuestOS驱动正常运行。

后面就围绕着vhost-blk如何完成这些工作描述它的工作原理。

二. Vhost-blk架构

按照惯例，先上图：

如上图，与上部分virtio-blk的架构图有些区别，主要还是在handle_output到Disk的部分.

从GuestOS到kernel 和 kernel到GuestOS驱动 两个黑色箭头无论是否有vhost-blk都时一样的，就是上面介绍的两个接口。

值得关注的是在kernel部分，有一个vhost-blk模块，他是在驱动层(上半部分已经提到过)。

如果QEMU开启vhost-blk，handle_output就会跳过vfs，fs等kernel层，通过vhost-blk模块直接将请求提交给硬件，所以要补充，vhost-blk开启后，QEMU后端只能是block描述符，不能是一个文件，在vhost-blk内核模块中，会检查。

当vhost-blk执行完毕会返回到QEMU，但我用白色箭头表示，意思是vhost-blk将IO请求结果返回给GuestOS，并没有真正等到内核态切回QEMU的用户态再执行，而是直接从vhost-blk层就提交了中断，至于大家好奇，怎么从内核态就能通知QEMU用户态程序触发中断给GuestOS呢，这里QEMU利用了一个巧妙的通知机制，慢慢为大家分享。

三. IO的传送流

首先，因为上半部分已经为大家介绍过，virtio-blk是通过一个virtio_queue将IO请求同步给QEMU，当开启vhost-blk后，QEMU又将virtio_queue的数据，解析到vhost_queue的结构体中，QEMU通过vhost_queue将IO请求同步给host kernel的vhost_blk模块中，然后vhost_blk将vhost_queue的IO请求解析成一个bio，submit_io提交一个IO请求给硬件，二话不说，再上个图：

上面这个图不需要更多语言描述，看不懂就私信给我，我是不会回的^_^

广说原理也要有点依据，要依据，分享两个函数：

Fall in kernel

vhost_blk_ioctl

Virtio Queue  ----> Vhost Queue

void vhost_virtqueue_start(struct vhost_dev *dev,

struct VirtIODevice *vdev,

struct vhost_virtqueue *vq,

unsigned idx)

Qemu Vhost Queue ---> Kernel Vhost Queue

int vhost_virtqueue_set_addr(struct vhost_dev *dev,

struct vhost_virtqueue *vq,

unsigned idx, bool enable_log)

第一个函数，不用说，QEMU与vhost-blk都要通过ioctl来完成。

第二个函数和第三个函数，在QEMU中，看懂自然明白。

如果您确实把这三个函数看懂了，我再上个图，你会更清晰。

这个图的左半部就是virtio-blk的机制，当增加了vhost-blk，就增加了右半部。

GuestOS与QEMU之间有个VirtioQ，而QEMU与Vhost-blk之间有个VhostQ，VirtioQ通过QEMU转化成VhostQ，用于与Vhost-Blk同步请求。

当Vhost将请求处理完，再将结果放到VhostQ中的used中后，通知QEMU给GuestOS发送一个中断，Guest中断处理函数的处理方法参考上半部分享。

那么要补充的是，VirtioQ与VhostQ的同步也只是地址的同步，并没有数据的同步，所以VhostQ中的数据，也是VirtioQ中的数据。

目前为止，一个IO请求如何通过vhost-blk提交到硬件层，应该有个大致的了解。

上图又引入两个重要函数：

Host_kick与Guest_kick，在第四章为大家分享。

四. 重要函数

1. Vhost_blk重要函数

vhost_blk_handle_guest_kick：当一个IO请求同步到vhost_blk的vhost_queue中时，vhost-blk会调用此函数，将vhost_queue中的IO请求解析成一个bio，通过submit_io提交给硬件层。注意：这个函数在vhost_blk初始化的时候注册给【work_poll->work->fn】

vhost_blk_handle_host_kick：当一个IO请求处理完毕后，会调用此函数，将IO请求的处理结果同步到vhost_queue中，也就是同步到virtio_queue中，并 通知QEMU触发一个GuestOS的中断，通知GuestOS调用中断处理函数，处理IO返回的结果。注意：这个函数在vhost_blk初始化的时候注册给【blk->work->fn】

红色部分是一个遗留问题，后面为大家讲解如何在内核中通知用户程序的QEMU触发中断的。

先看vhost-blk是如何调用这两个函数的？引入了一个重要的内核线程【Vhost Worker thread】，再上个图：

如上图所示：首先紫色模块vhost_dev_set_owner，创建一个vhost_worker的线程(调用kthread_create),但不是一直运行的，使用通过唤醒函数进行唤醒。

这个线程的主要工作就是不停的在work_list取出之前被注册进来的work，调用work->fn函数，那整个流程如下：

1. 当IO请求被同步到vhost_queue中时，QEMU通过ioctl通知vhost_blk调用vhost_poll_start。

2. vhost_poll_start将poll->work通过vhost_work_queue注册给work_list，并调用唤醒函数唤醒vhost_worker线程。

3. vhost_worker取出work_list头的work，并调用work的fn，这个work->fn就是 vhost_blk_handle_guest_kick。

4. 当vhost_blk_handle_guest_kick后，会调用vhost_blk_req_done。

5. vhost_blk_req_done函数将blk->work通过vhost_work_queue添加到work_list的队尾，并启动进程。

6. 与第四步一样，此时work->fn就是 vhost_blk_handle_host_kick。

2. QEMU中的重要函数

到目前位置，已经描述了Vhost-blk最重要的两个函数，其中 vhost_blk_handle_host_kick在处理完请求后，需要通知QEMU向GuestOS发送一个中断，那么这个通知机制是如何完成的呢？

请看下面两个函数

virtio_queue_host_notifier_read：当GuestOS的virtio_blk把IO请求同步到virtio_queue中时，会调用此函数，此函数实际就是调用handle_output去处理IO请求。

virtio_queue_guest_notifier_read：当Vhost-blk处理完请求时，通过vhost_blk_handle_host_kick发送信号，让Qemu调用此函数，为GuestOS发送一个中断。

这里必须要引入一个概念eventfd。

它是一个系统调用，它会返回一个描述符，描述符实际是一个对象，这个对象包含一个由内核维护的计数器。

当read这个描述符的时候，如果这个描述符的对象计数器大于0，read将会返回，并且将计数器清0。

当write这个描述符的时候，就是将一个uint64的数值写到计数器中。

当poll这个描述符的时候，如果计数器大于0，poll会认为它是可读的，如果计数器等于0，poll认为它是不可读的。(select亦如此)

QEMU中有个轮询io_handler的主循环，还是要贴一个链接：http://blog.csdn.net/zhuriyuxiao/article/details/8835593

简而言之，这个主循环在poll这个io_handler列表中所有的描述符，当poll返回值为真的，就会调用该描述符对应的函数。

说回来，QEMU就是分别创建了一个host_notifier和一个guest_notifier两个eventfd，并将这两个eventfd绑定上面的两个函数：

virtio_queue_host_notifier_read -> host_notifier

virtio_queue_guest_notifier_read -> guest_notifier

并将这两个eventfd注册到io_handler里面。

最关键的是，QEMU将host_notifier通过ioctl注册给内核vhost-blk中的kick。将guest_notifer通过ioctl注册给内核vhost-blk中的call。

到这，大家是不是看出点门道，当在内核vhost-blk中，给call的计数器做+1操作，QEMU中的guest_notifier就会被poll认为是可读的，io_handler主循环中就会调用 virtio_queue_guest_notifier_read给GuestOS发中断。

那么vhost-blk的kick又是干什么的呢？

每次vhost-blk启动vhost_worker线程之前，都要检测一下kick是不是可读，如果可读，才会启动线程，处理vhost_queue中的IO请求，而在QEMU中的 virtio_queue_host_notifier_read函数中，调用handle_output之前，需要将host_notifier的计数器清零，言外之意，就是QEMU中的handle_output与vhost-blk的 vhost_blk_handle_guest_kick不能同时进行，因为他们都会操作vhost_queue，这是保证一个vhost_queue处理的完整性。

五. 总结

总结必不可少，那就是vhost-blk到底优化空间又多少，先把两张老图拿出来对比下：

第一张图是没有vhos-blk架构图，红色箭头发出一次IO请求，要走完第三张图的vfs层一直到Block Device层，而请求处理完毕后，要返回到QEMU，将IO请求的处理结果填充到Virtio_queue中，再触发中断，让GuestOS中断处理函数对IO请求的结果进行处理。

第二张图是有vhost-blk的架构图，与红色箭头处对应的是，直接跳过其他层，到Block Device Driver层，提交IO请求，当IO请求的结果到Vhost-blk驱动中，在block device driver层将请求结果填充到vhost_queue中，就通知QEMU触发一次中断，让GuestOS中断处理函数对IO请求结果进行处理。

也就是说开启vhost-blk的IO路径 从请求发出到请求结果返回，两次都有缩短。

但是！！但是优化空间到底有多少？

在上文提到过，vhost-blk开启后，QEMU后端必须是block设备(可以是逻辑卷LV)，那么上面第三个图，表示QEMU后端为一个Raw文件的IO路径。

这样是不在一个基准线上的竞争，假如不开启vhost-blk，QEMU的virtio-blk后端为一个LV的话， 我们知道LVM是建立在硬盘和分区之上的一个逻辑层，接近于驱动层。

大家应该明白我的结论，我接触QEMU不久，而且以上都是基于代码分析出来的，没有官网给出结论，所以有任何不同意见，欢迎提出来，大家一起把这个社区没接受的 非官方的 大家都好奇的vhost-blk搞清楚。

virtio_queue_set_guest_notifier_fd_handler

host是virtio的另一种方案，用于跳过qemu，减少qemu和内核之间上下文切换的开销，对于网络IO而言提升尤其明显。vhost目前有两种实现方案，内核态和用户态，本文重点讨论内核态的vhost

vhost内核模块主要处理数据面的事情，控制面上还是交给qemu，

下面来看下vhost的数据流，vhost与kvm模块之间通过eventfd来实现，guest到host方向的kick event，通过ioeventfd实现，host到guest方向的call event，通过irqfd实现

host到guest方向

-> r = k->set_guest_notifiers(qbus->parent, total_queues * 2, true); //调用virtio_pci_set_guest_notifiers

1、-> virtio_pci_set_guest_notifiers --> kvm_vm_ioctl

2、 -> virtio_pci_set_guest_notifier-> virtio_queue_set_guest_notifier_fd_handler

1、有中断irqfd通过kvm_vm_ioctl来设置kvm模块的irqfd

首先host处理used ring，然后判断如果KVM_IRQFD成功设置，kvm模块会通过irqfd把中断注入guest。qemu是通过virtio_pci_set_guest_notifiers -> kvm_virtio_pci_vector_use -> kvm_virtio_pci_irqfd_use -> kvm_irqchip_add_irqfd_notifier ->kvm_irqchip_assign_irqfd最终调用kvm_vm_ioctl来设置kvm模块的irqfd的，包含write fd和read fd(可选)

static int kvm_virtio_pci_vector_use(VirtIOPCIProxy *proxy, intnvqs)

{

PCIDevice*dev = &proxy->pci_dev;

VirtIODevice*vdev = virtio_bus_get_device(&proxy->bus);

VirtioDeviceClass*k =VIRTIO_DEVICE_GET_CLASS(vdev);

unsignedintvector;intret, queue_no;

MSIMessage msg;for (queue_no = 0; queue_no < nvqs; queue_no++) {if (!virtio_queue_get_num(vdev, queue_no)) {break;

}

vector=virtio_queue_vector(vdev, queue_no);if (vector >=msix_nr_vectors_allocated(dev)) {continue;

}

msg=msix_get_message(dev, vector);

ret=kvm_virtio_pci_vq_vector_use(proxy, queue_no, vector, msg);if (ret < 0) {gotoundo;

}/*If guest supports masking, set up irqfd now.

* Otherwise, delay until unmasked in the frontend.*/

if (k->guest_notifier_mask) {

ret=kvm_virtio_pci_irqfd_use(proxy, queue_no, vector);if (ret < 0) {

kvm_virtio_pci_vq_vector_release(proxy, vector);gotoundo;

}

}

}return 0;

undo:while (--queue_no >= 0) {

vector=virtio_queue_vector(vdev, queue_no);if (vector >=msix_nr_vectors_allocated(dev)) {continue;

}if (k->guest_notifier_mask) {

kvm_virtio_pci_irqfd_release(proxy, queue_no, vector);

}

kvm_virtio_pci_vq_vector_release(proxy, vector);

}returnret;

}

2、如果没有设置irqfd，则guest notifier fd会通知到等待fd的qemu进程，进入注册函数virtio_queue_guest_notifier_read，调用virtio_irq，最终调用到virtio_pci_notify

static void virtio_queue_guest_notifier_read(EventNotifier *n)

{

VirtQueue*vq =container_of(n, VirtQueue, guest_notifier);if(event_notifier_test_and_clear(n)) {

virtio_irq(vq);

}

}void virtio_irq(VirtQueue *vq)

{

trace_virtio_irq(vq);

vq->vdev->isr |= 0x01;

virtio_notify_vector(vq->vdev, vq->vector);

}static void virtio_notify_vector(VirtIODevice *vdev, uint16_t vector)

{

BusState*qbus =qdev_get_parent_bus(DEVICE(vdev));

VirtioBusClass*k =VIRTIO_BUS_GET_CLASS(qbus);if (k->notify) {

k->notify(qbus->parent, vector);

}

}static void virtio_pci_notify(DeviceState *d, uint16_t vector)

{

VirtIOPCIProxy*proxy =to_virtio_pci_proxy_fast(d);if (msix_enabled(&proxy->pci_dev))

msix_notify(&proxy->pci_dev, vector);else{

VirtIODevice*vdev = virtio_bus_get_device(&proxy->bus);

pci_set_irq(&proxy->pci_dev, vdev->isr & 1);

}

}

1 技术简介

1.1 virtio-net 简介

virtio-net 在 guest 前端驱动 kick 后端驱动时，采用 I/O 指令方式退出到 host KVM。kvm 通过 eventfd_signal 唤醒阻塞的 qemu 线程。qemu 通过 vring 处理报文。qemu 把报文从用户态传送给 tap 口。

1.2 vhost-net 简介

与 virtio-net 不同的是，eventfd_signal 唤醒的是内核 vhost_worker 进程。vhost_worker 从 vring 提取报文数据，然后发送给 tap。与 virtio-net 相比，vhost-net 处理数据在内核态，在发送到 tap 口的时候少了一次数据的拷贝。

1.3 ovs 转发涉及的模块概要

VM->VM 流程：

2 virtio-net.ko 前端驱动部分

2.1 guest->host 数据发送

当前端 virtio-net 有想发送的报文数据时将会 kick 后端，右面是前端 kick 后端的流程。前端调用 xmit_skb 发送数据，virtqueue_add_outbuf 是把 sk_buff 里的内容(frag[]数组)逐一的填入 scatterlist 数组中。这里可以理解成填写分散聚合描述符表。

但前端和后端数据传递是通过 struct vring_desc 传递的，所以 virtqueue_add() 再把 struct scatterlist 里的数据填写到 struct vring_desc 里。

struct vring_desc 这个数据结构的使用，后面我们再详细说。

最后通过 vq->notify(&vq->vq) (vp_notify()) kick 后端，后续流程到了 kvm.ko 部分的第 4 小节。

2.2 guest->host 代码流程

2.3 host->guest 数据发送

guest 通过 NAPI 接口的 virtnet_poll 接收数据，通过 virtqueue_get_buf_ctx 从 Vring 中获取报文数据。再通过 receive_buf 把报文数据保存到 skb 中。

这样目的端就成功接收了来自源端的报文。

2.4 host->guest 代码流程

3 kvm.ko 部分

3.1 eventfd 注册

由上图可见 eventfd 的注册是在 qemu 中发起的。qemu 调用 kvm 提供的系统调用。

3.2 eventfd 通知流程

eventfd 一半的用法是用户态通知用户态，或者内核态通知用户态。例如 virtio-net 的实现是 guest 在 kick host 时采用 eventfd 通知的 qemu，然后 qemu 在用户态做报文处理。但 vhost-net 是在内核态进行报文处理，guest 在 kick host 时采用 eventfd 通知的是内核线程 vhost_worker。所以这里的用法就跟常规的 eventfd 的用法不太一样。

下面介绍 eventfd 通知的使用。

eventfd 核心数据结构：

structeventfd_ctx {

structkref kref;

wait_queue_head_twqh;

__u64 count;

unsignedintflags;

};

eventfd 的数据结构其实就是包含了一个等待队列头。当调用 eventfd_signal 函数时就是唤醒 wgh 上等待队列。

__u64 eventfd_signal(structeventfd_ctx *ctx,__u64 n)

{

unsignedlongflags;

spin_lock_irqsave(&ctx->wqh.lock,flags);

if(ULLONG_MAX -ctx->count

n =ULLONG_MAX -ctx->count;

ctx->count +=n;

if(waitqueue_active(&ctx->wqh))

wake_up_locked_poll(&ctx->wqh,POLLIN);

spin_unlock_irqrestore(&ctx->wqh.lock,flags);

returnn;

}

#definewake_up_locked_poll(x,m)\

__wake_up_locked_key((x),TASK_NORMAL,(void*)(m))

void__wake_up_locked_key(structwait_queue_head *wq_head,unsignedintmode,void*key)

{

__wake_up_common(wq_head,mode,1,0,key,NULL);

}

staticint__wake_up_common(structwait_queue_head *wq_head,unsignedintmode,

intnr_exclusive,intwake_flags,void*key,

wait_queue_entry_t*bookmark)

{

...

list_for_each_entry_safe_from(curr,next,&wq_head->head,entry){

unsignedflags =curr->flags;

intret;

if(flags &WQ_FLAG_BOOKMARK)

continue;

ret =curr->func(curr,mode,wake_flags,key);/* 调用vhost_poll_wakeup */

if(ret <0)

break;

if(ret &&(flags &WQ_FLAG_EXCLUSIVE)&&!--nr_exclusive)

break;

if(bookmark &&(++cnt >WAITQUEUE_WALK_BREAK_CNT)&&

(&next->entry !=&wq_head->head)){

bookmark->flags =WQ_FLAG_BOOKMARK;

list_add_tail(&bookmark->entry,&next->entry);

break;

}

}

returnnr_exclusive;

}

staticintvhost_poll_wakeup(wait_queue_entry_t*wait,unsignedmode,intsync,

void*key)

{

structvhost_poll *poll =container_of(wait,structvhost_poll,wait);

if(!((unsignedlong)key &poll->mask))

return0;

vhost_poll_queue(poll);

return0;

}

voidvhost_poll_queue(structvhost_poll *poll)

{

vhost_work_queue(poll->dev,&poll->work);

}

voidvhost_work_queue(structvhost_dev *dev,structvhost_work *work)

{

if(!dev->worker)

return;

if(!test_and_set_bit(VHOST_WORK_QUEUED,&work->flags)){

/* We can only add the work to the list after we're

* sure it was not in the list.

* test_and_set_bit() implies a memory barrier.

*/

llist_add(&work->node,&dev->work_list);/* 添加到 dev->work_list)*/

wake_up_process(dev->worker);/* 唤醒vhost_worker线程 */

}

}

这里有一个疑问，就是 vhost_worker 什么时候加入到 eventfd 的 wgh 字段的，__wake_up_common 函数里 curr->func 又是什么时候被设置成 vhost_poll_wakeup 函数的呢？请看下一节。

3.3 eventfd 与 vhost_worker 绑定

vhost.ko 创建了一个字符设备，vhost_net_open 在打开这个设备文件的时候会调用 vhost_net_open 函数。这里为 vhost_dev 设备进行初始化。

staticintvhost_net_open(structinode *inode,structfile *f)

{

...

dev =&n->dev;

vqs[VHOST_NET_VQ_TX]=&n->vqs[VHOST_NET_VQ_TX].vq;

vqs[VHOST_NET_VQ_RX]=&n->vqs[VHOST_NET_VQ_RX].vq;

n->vqs[VHOST_NET_VQ_TX].vq.handle_kick =handle_tx_kick;

n->vqs[VHOST_NET_VQ_RX].vq.handle_kick =handle_rx_kick;

...

vhost_poll_init(n->poll +VHOST_NET_VQ_TX,handle_tx_net,POLLOUT,dev);

vhost_poll_init(n->poll +VHOST_NET_VQ_RX,handle_rx_net,POLLIN,dev);

f->private_data =n;

return0;

}

voidvhost_poll_init(structvhost_poll *poll,vhost_work_fn_tfn,

unsignedlongmask,structvhost_dev *dev)

{

init_waitqueue_func_entry(&poll->wait,vhost_poll_wakeup);/* 给curr->fn赋值 vhost_poll_wakeup */

init_poll_funcptr(&poll->table,vhost_poll_func);/* 给poll_table->_qproc赋值vhost_poll_func */

poll->mask =mask;

poll->dev =dev;

poll->wqh =NULL;

vhost_work_init(&poll->work,fn);/* 给 work->fn 赋值为handle_tx_net和handle_rx_net */

}

qemu 使用 ioctl 系统调用 VHOST_SET_VRING_KICK 时会把 eventfd 的 struct file 指针付给 pollstart 和 pollstop，同时调用 vhost_poll_start()。

longvhost_vring_ioctl(structvhost_dev *d,intioctl,void__user *argp)

{

...

caseVHOST_SET_VRING_KICK:

if(copy_from_user(&f,argp,sizeoff)){

r =-EFAULT;

break;

}

eventfp =f.fd ==-1?NULL :eventfd_fget(f.fd);

if(IS_ERR(eventfp)){

r =PTR_ERR(eventfp);

break;

}

if(eventfp !=vq->kick){

pollstop =(filep =vq->kick)!=NULL;

pollstart =(vq->kick =eventfp)!=NULL;

}else

filep =eventfp;

break;

...

if(pollstart &&vq->handle_kick)

r =vhost_poll_start(&vq->poll,vq->kick);

...

}

intvhost_poll_start(structvhost_poll *poll,structfile *file)

{

unsignedlongmask;

intret =0;

if(poll->wqh)

return0;

mask =file->f_op->poll(file,&poll->table);/* 执行eventfd_poll */

if(mask)

vhost_poll_wakeup(&poll->wait,0,0,(void*)mask);

if(mask &POLLERR){

vhost_poll_stop(poll);

ret =-EINVAL;

}

returnret;

}

staticunsignedinteventfd_poll(structfile *file,poll_table *wait)

{

structeventfd_ctx *ctx =file->private_data;

unsignedintevents =0;

u64 count;

poll_wait(file,&ctx->wqh,wait);

。。。

}

staticinlinevoidpoll_wait(structfile *filp,wait_queue_head_t*wait_address,poll_table *p)

{

if(p &&p->_qproc &&wait_address)

p->_qproc(filp,wait_address,p);/* 调用vhost_poll_func */

}

staticvoidvhost_poll_func(structfile *file,wait_queue_head_t*wqh,

poll_table *pt)

{

structvhost_poll *poll;

poll =container_of(pt,structvhost_poll,table);

poll->wqh =wqh;

add_wait_queue(wqh,&poll->wait);

}

关键数据结构关系如下图：

3.4 guest->host 的通知流程(唤醒 vhost_worker 线程)

Kick host 的原理是通过 io 指令实现的。前端执行 io 指令，就会发生 vm exit。KVM 捕捉到 vm exit 会去查询退出原因，由于是 io 指令，所以执行对应的 handle_io 处理。handle_io() 从 exit_qualification 中得到 io 操作地址。kvm_fast_pio_out() 会根据 io 操作的地址找到对应的处理函数。第 1 小节 eventfd 注册的流程可知，kvm_fast_pio_out() 最终会调用 eventfd 对应的回调函数 ioeventfd_write()。再根据第 3 小节可知 eventfd 最终会唤醒 vhost_worker 内核进程。

流程进入 vhost.ko 的第3小节。

3.5 host 给 guest 注入中断

到目前位置，发送给 guest 的报文已经准备好了。通过注入中断通知 guest 接收报文。这里要为虚机的 virtio-net 设备模拟一个 MSI 中断，并且准备了中断向量号。调用 vmx_deliver_posted_interrupt 给目的 VCPU 线程所在的物理核注入终端。

流程将跳转到 virtio-net.ko 前端驱动的第3小节。

3.6 host 给 guest 注入中断代码流程 ------------------------非host方式通过virtio_notify_irqfd

4 vhost.ko 部分

前面有提到 vhost_worker 线程被唤醒后将执行 vhost_poll_init() 函数这册的 handle_tx_net 和 handle_rx_net 函数。

4.1 vhost_worker 线程创建

longvhost_dev_set_owner(structvhost_dev *dev)

{

...

/* No owner, become one */

dev->mm =get_task_mm(current);

worker =kthread_create(vhost_worker,dev,"vhost-%d",current->pid);

if(IS_ERR(worker)){

err =PTR_ERR(worker);

gotoerr_worker;

}

dev->worker =worker;

wake_up_process(worker);/* avoid contributing to loadavg */

err =vhost_attach_cgroups(dev);

if(err)

gotoerr_cgroup;

err =vhost_dev_alloc_iovecs(dev);

if(err)

gotoerr_cgroup;

...

}

让 vhost-dev 的 worker 指向刚创建出的 worker 线程。

4.2 vhost_worker 实现

staticintvhost_worker(void*data)

{

structvhost_dev *dev =data;

structvhost_work *work,*work_next;

structllist_node *node;

mm_segment_toldfs =get_fs();

set_fs(USER_DS);

use_mm(dev->mm);

for(;;){

/* mb paired w/ kthread_stop */

set_current_state(TASK_INTERRUPTIBLE);

if(kthread_should_stop()){

__set_current_state(TASK_RUNNING);

break;

}

node =llist_del_all(&dev->work_list);/*vhost_work_queue 添加 */

if(!node)

schedule();

node =llist_reverse_order(node);

/* make sure flag is seen after deletion */

smp_wmb();

llist_for_each_entry_safe(work,work_next,node,node){

clear_bit(VHOST_WORK_QUEUED,&work->flags);

__set_current_state(TASK_RUNNING);

work->fn(work);/* 由vhost_poll_init赋值 handle_tx_net和handle_rx_net*/

if(need_resched())

schedule();

}

}

unuse_mm(dev->mm);

set_fs(oldfs);

return0;

}

从代码可以看到在循环的开始部分是摘除 dev->work_list 链表中的头表项。这里如果链表为空则返回 NULL，如果链表不为空则返回头结点。如果链表为空则调用 schedule() 函数 vhost_worker 进程进入阻塞状态，等待被唤醒。

当 vhost_worker 被唤醒后将执行 fn 函数，对于 vhost-net 将被赋值为 handle_tx_net 和 handle_rx_net。

4.3 从 guest->host 方向的发送报文函数 handle_tx_net

handle_tx_net 的代码逻辑比较短，里面直接调用了 tun.ko 的接口函数发送报文。流程走到了 tun.ko 章节的第1小节。

staticvoidhandle_tx_net(structvhost_work *work)

{

structvhost_net *net =container_of(work,structvhost_net,

poll[VHOST_NET_VQ_TX].work);

handle_tx(net);

}

staticvoidhandle_tx(structvhost_net *net)

{

...

for(;;){

...

/* TODO: Check specific error and bomb out unless ENOBUFS? */

err =sock->ops->sendmsg(sock,&msg,len);/* tup.c中定义 tup_sendmsg ()*/

if(unlikely(err <0)){

...

}

out:

mutex_unlock(&vq->mutex);

}

4.4 guest->host 代码流程

4.5 从 host->guest 方向的接收

vhost-worker 进程调用 handle_rx_net。vhost_add_used_and_signal_n 负责从 vring 中接收报文，vhost_signal 函数通知 guest 报文的到来。目前都是通过注入中断的方式通知 guest。 流程将跳转到 kvm.ko 的第5小节。

4.6 host->guest 代码流程

host->guest 方向：

5 tun.ko 部分

5.1 报文发送处理流程

tun 模块首先通过调用 __napi_schedue() 接口去挂起 NET_RX_SOFTIRQ 软中断的，并且调度的是 sd->backlog 这个 struct napi。然后在 tun_rx_batched() 函数在使能中断下半部时会调用 do_softirq()，从而执行刚刚挂起的 NET_RX_SOFTIRQ 对应的 net_rx_action 软中断响应函数 net_rx_aciton。net_rx_action 会执行 sd->backlog 对应的 napi 接口函数。process_backlog 是内核的 netdev 在初始化时在每 CPU 变量中填入的 struct napi_struct 结构体。最后从 process_backlog 执行到 openvswitch 注册的 hook 函数 netdev_frame_hook (openvswitch.ko 第 2小节)。

流程将跳转到 openvswitch.ko 第3小节。

5.2 process_backlog 的注册

staticint__init net_dev_init(void)

{

inti,rc =-ENOMEM;

…

for_each_possible_cpu(i){/* 遍历各个CPU的每CPU变量 */

structwork_struct *flush =per_cpu_ptr(&flush_works,i);

structsoftnet_data *sd =&per_cpu(softnet_data,i);/* sd是个每CPU变量 */

INIT_WORK(flush,flush_backlog);

skb_queue_head_init(&sd->input_pkt_queue);

skb_queue_head_init(&sd->process_queue);

INIT_LIST_HEAD(&sd->poll_list);

sd->output_queue_tailp =&sd->output_queue;

#ifdefCONFIG_RPS

sd->csd.func =rps_trigger_softirq;

sd->csd.info =sd;

sd->cpu =i;

#endif

sd->backlog.poll =process_backlog;/* 定义napi_struct的poll函数 */

sd->backlog.weight =weight_p;

}

…

if(register_pernet_device(&loopback_net_ops))

gotoout;

if(register_pernet_device(&default_device_ops))

gotoout;

open_softirq(NET_TX_SOFTIRQ,net_tx_action);/* 设置软中断NET_TX_SOFTIRQ的响应函数 */

open_softirq(NET_RX_SOFTIRQ,net_rx_action);/*设置软中断NET_RX_SOFTIRQ的响应函数 */

rc =cpuhp_setup_state_nocalls(CPUHP_NET_DEV_DEAD,"net/dev:dead",

NULL,dev_cpu_dead);

WARN_ON(rc <0);

rc =0;

out:

returnrc;

}

6 openvswitch 部分

openvswitch.ko 作为 openvswitch 的一个内核模块内核态报文的接收和转发。通过给 tun 设备挂接 hook 函数，来处理 tun 接收和发送的报文。在创建虚机时给虚机分配的 vnet 口会暴露给 host，我们一般通过 xml 文件指定到桥入那个 ovs 网桥。在桥入的时候，用户态代码通过 netlink 与 openvswitch.ko 进行通信。把 vnet 口桥入 ovs 网桥时会给 vnet 这个设备挂 netdev_frame_hook 钩子函数。

6.1 netlink 注册

当 ovs 添加一个 vport 时会通过 netlink 发送到 openvswitch.ko，openvswitch 注册的 netlink 处理函数负责处理相关命令。

staticstructgenl_ops dp_vport_genl_ops[]={

{.cmd =OVS_VPORT_CMD_NEW,

.flags =GENL_UNS_ADMIN_PERM,/* Requires CAP_NET_ADMIN privilege. */

.policy =vport_policy,

.doit =ovs_vport_cmd_new /* OVS_VPORT_CMD_NEW消息的 */

},

{.cmd =OVS_VPORT_CMD_DEL,

.flags =GENL_UNS_ADMIN_PERM,/* Requires CAP_NET_ADMIN privilege. */

.policy =vport_policy,

.doit =ovs_vport_cmd_del

},

{.cmd =OVS_VPORT_CMD_GET,

.flags =0,/* OK for unprivileged users. */

.policy =vport_policy,

.doit =ovs_vport_cmd_get,

.dumpit =ovs_vport_cmd_dump

},

{.cmd =OVS_VPORT_CMD_SET,

.flags =GENL_UNS_ADMIN_PERM,/* Requires CAP_NET_ADMIN privilege. */

.policy =vport_policy,

.doit =ovs_vport_cmd_set,

},

};

structgenl_family dp_vport_genl_family __ro_after_init ={

.hdrsize =sizeof(structovs_header),

.name =OVS_VPORT_FAMILY,

.version =OVS_VPORT_VERSION,

.maxattr =OVS_VPORT_ATTR_MAX,

.netnsok =true,

.parallel_ops =true,

.ops =dp_vport_genl_ops,

.n_ops =ARRAY_SIZE(dp_vport_genl_ops),

.mcgrps =&ovs_dp_vport_multicast_group,

.n_mcgrps =1,

.module=THIS_MODULE,

};

staticstructgenl_family *dp_genl_families[]={

&dp_datapath_genl_family,

&dp_vport_genl_family,

&dp_flow_genl_family,

&dp_packet_genl_family,

&dp_meter_genl_family,

};

staticint__init dp_register_genl(void)

{

interr;

inti;

for(i =0;i

err =genl_register_family(dp_genl_families[i]);注册netlink处理函数

if(err)

gotoerror;

}

return0;

error:

dp_unregister_genl(i);

returnerr;

}

6.2 netdev_frame_hook 函数的注册

6.3 ovs 对报文的转发流程

OVS 首先通过 key 值找到对应的流表，然后转发到对应的端口。这篇文章的重点是讲解 vhost 的流程，OVS 具体流程并不是我们的讲解的重点。所以这方面有什么疑问请大家自行搜索一下 OVS 的资料。

这段代码的大体目的就是找到目的虚机所在的端口，也就是目的虚机所在的 vnet 端口。

流程跳转到内核部分第1小节。

7 内核部分

7.1 发送报文唤醒目的端的 vhost-worker 进程

内核的发送函数 __dev_queue_xmit 将会找到 vnet 设备对应的等待队列，并唤醒等待队列里对应的进程。这里将唤醒的进程就是 vhost_worker 进程了。

流程跳转到 vhost.ko 的第5小节。

7.2 代码流程