virtio event fd + 中断 前后端通信机制 +class_init {vhost worker方式}(二)

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, int level)
{
    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, int level)
{
    PCIDevice *pci_dev = opaque;
    int change;

    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, int nvqs)
{
    PCIDevice *dev = &proxy->pci_dev;
    VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
    VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
    unsigned int vector;
    int ret, 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) {
            goto undo;
        }
        /* 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);
                goto undo;
            }
        }
    }
    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);
    }
    return ret;
}

 

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 核心数据结构：

1. struct eventfd_ctx {
2. struct kref kref;
3. wait_queue_head_t wqh;
4. __u64 count;
5. unsigned int flags;
6. };

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

1. __u64 eventfd_signal(struct eventfd_ctx *ctx, __u64 n)
2. {
3. unsigned long flags;
5. spin_lock_irqsave(&ctx->wqh.lock, flags);
6. if (ULLONG_MAX - ctx->count < n)
7. n = ULLONG_MAX - ctx->count;
8. ctx->count += n;
9. if (waitqueue_active(&ctx->wqh))
10. wake_up_locked_poll(&ctx->wqh, POLLIN);
11. spin_unlock_irqrestore(&ctx->wqh.lock, flags);
13. return n;
14. }
15. #define wake_up_locked_poll(x, m)
16. __wake_up_locked_key((x), TASK_NORMAL, (void *) (m))
18. void __wake_up_locked_key(struct wait_queue_head *wq_head, unsigned int mode, void *key)
19. {
20. __wake_up_common(wq_head, mode, 1, 0, key, NULL);
21. }
22. static int __wake_up_common(struct wait_queue_head *wq_head, unsigned int mode,
23. int nr_exclusive, int wake_flags, void *key,
24. wait_queue_entry_t *bookmark)
25. {
26. ...
27. list_for_each_entry_safe_from(curr, next, &wq_head->head, entry) {
28. unsigned flags = curr->flags;
29. int ret;
31. if (flags & WQ_FLAG_BOOKMARK)
32. continue;
34. ret = curr->func(curr, mode, wake_flags, key); /* 调用vhost_poll_wakeup */
35. if (ret < 0)
36. break;
37. if (ret && (flags & WQ_FLAG_EXCLUSIVE) && !--nr_exclusive)
38. break;
40. if (bookmark && (++cnt > WAITQUEUE_WALK_BREAK_CNT) &&
41. (&next->entry != &wq_head->head)) {
42. bookmark->flags = WQ_FLAG_BOOKMARK;
43. list_add_tail(&bookmark->entry, &next->entry);
44. break;
45. }
46. }
47. return nr_exclusive;
48. }
50. static int vhost_poll_wakeup(wait_queue_entry_t *wait, unsigned mode, int sync,
51. void *key)
52. {
53. struct vhost_poll *poll = container_of(wait, struct vhost_poll, wait);
55. if (!((unsigned long)key & poll->mask))
56. return 0;
58. vhost_poll_queue(poll);
59. return 0;
60. }
62. void vhost_poll_queue(struct vhost_poll *poll)
63. {
64. vhost_work_queue(poll->dev, &poll->work);
65. }
67. void vhost_work_queue(struct vhost_dev *dev, struct vhost_work *work)
68. {
69. if (!dev->worker)
70. return;
72. if (!test_and_set_bit(VHOST_WORK_QUEUED, &work->flags)) {
73. /* We can only add the work to the list after we're
74. * sure it was not in the list.
75. * test_and_set_bit() implies a memory barrier.
76. */
77. llist_add(&work->node, &dev->work_list); /* 添加到 dev->work_list)*/
78. wake_up_process(dev->worker); /* 唤醒vhost_worker线程 */
79. }
80. }

这里有一个疑问，就是 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 设备进行初始化。

1. static int vhost_net_open(struct inode *inode, struct file *f)
2. {
3. ...
4. dev = &n->dev;
5. vqs[VHOST_NET_VQ_TX] = &n->vqs[VHOST_NET_VQ_TX].vq;
6. vqs[VHOST_NET_VQ_RX] = &n->vqs[VHOST_NET_VQ_RX].vq;
7. n->vqs[VHOST_NET_VQ_TX].vq.handle_kick = handle_tx_kick;
8. n->vqs[VHOST_NET_VQ_RX].vq.handle_kick = handle_rx_kick;
9. ...
10. vhost_poll_init(n->poll + VHOST_NET_VQ_TX, handle_tx_net, POLLOUT, dev);
11. vhost_poll_init(n->poll + VHOST_NET_VQ_RX, handle_rx_net, POLLIN, dev);
13. f->private_data = n;
15. return 0;
16. }
18. void vhost_poll_init(struct vhost_poll *poll, vhost_work_fn_t fn,
19. unsigned long mask, struct vhost_dev *dev)
20. {
21. init_waitqueue_func_entry(&poll->wait, vhost_poll_wakeup); /* 给curr->fn赋值 vhost_poll_wakeup */
22. init_poll_funcptr(&poll->table, vhost_poll_func); /* 给poll_table->_qproc赋值vhost_poll_func */
23. poll->mask = mask;
24. poll->dev = dev;
25. poll->wqh = NULL;
27. vhost_work_init(&poll->work, fn); /* 给 work->fn 赋值为handle_tx_net和handle_rx_net */
28. }

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

1. long vhost_vring_ioctl(struct vhost_dev *d, int ioctl, void __user *argp)
2. {
3. ...
4. case VHOST_SET_VRING_KICK:
5. if (copy_from_user(&f, argp, sizeof f)) {
6. r = -EFAULT;
7. break;
8. }
9. eventfp = f.fd == -1 ? NULL : eventfd_fget(f.fd);
10. if (IS_ERR(eventfp)) {
11. r = PTR_ERR(eventfp);
12. break;
13. }
14. if (eventfp != vq->kick) {
15. pollstop = (filep = vq->kick) != NULL;
16. pollstart = (vq->kick = eventfp) != NULL;
17. } else
18. filep = eventfp;
19. break;
20. ...
21. if (pollstart && vq->handle_kick)
22. r = vhost_poll_start(&vq->poll, vq->kick);
23. ...
24. }
26. int vhost_poll_start(struct vhost_poll *poll, struct file *file)
27. {
28. unsigned long mask;
29. int ret = 0;
31. if (poll->wqh)
32. return 0;
34. mask = file->f_op->poll(file, &poll->table); /* 执行eventfd_poll */
35. if (mask)
36. vhost_poll_wakeup(&poll->wait, 0, 0, (void *)mask);
37. if (mask & POLLERR) {
38. vhost_poll_stop(poll);
39. ret = -EINVAL;
40. }
42. return ret;
43. }
45. static unsigned int eventfd_poll(struct file *file, poll_table *wait)
46. {
47. struct eventfd_ctx *ctx = file->private_data;
48. unsigned int events = 0;
49. u64 count;
51. poll_wait(file, &ctx->wqh, wait);
52. 。。。
53. }
54. static inline void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p)
55. {
56. if (p && p->_qproc && wait_address)
57. p->_qproc(filp, wait_address, p); /* 调用vhost_poll_func */
58. }
59. static void vhost_poll_func(struct file *file, wait_queue_head_t *wqh,
60. poll_table *pt)
61. {
62. struct vhost_poll *poll;
64. poll = container_of(pt, struct vhost_poll, table);
65. poll->wqh = wqh;
66. add_wait_queue(wqh, &poll->wait);
67. }

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

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 线程创建

1. long vhost_dev_set_owner(struct vhost_dev *dev)
2. {
3. ...
4. /* No owner, become one */
5. dev->mm = get_task_mm(current);
6. worker = kthread_create(vhost_worker, dev, "vhost-%d", current->pid);
7. if (IS_ERR(worker)) {
8. err = PTR_ERR(worker);
9. goto err_worker;
10. }
12. dev->worker = worker;
13. wake_up_process(worker); /* avoid contributing to loadavg */
15. err = vhost_attach_cgroups(dev);
16. if (err)
17. goto err_cgroup;
19. err = vhost_dev_alloc_iovecs(dev);
20. if (err)
21. goto err_cgroup;
22. ...
23. }

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

4.2 vhost_worker 实现

1. static int vhost_worker(void *data)
2. {
3. struct vhost_dev *dev = data;
4. struct vhost_work *work, *work_next;
5. struct llist_node *node;
6. mm_segment_t oldfs = get_fs();
8. set_fs(USER_DS);
9. use_mm(dev->mm);
11. for (;;) {
12. /* mb paired w/ kthread_stop */
13. set_current_state(TASK_INTERRUPTIBLE);
15. if (kthread_should_stop()) {
16. __set_current_state(TASK_RUNNING);
17. break;
18. }
20. node = llist_del_all(&dev->work_list); /*vhost_work_queue 添加 */
21. if (!node)
22. schedule();
24. node = llist_reverse_order(node);
25. /* make sure flag is seen after deletion */
26. smp_wmb();
27. llist_for_each_entry_safe(work, work_next, node, node) {
28. clear_bit(VHOST_WORK_QUEUED, &work->flags);
29. __set_current_state(TASK_RUNNING);
30. work->fn(work); /* 由vhost_poll_init赋值 handle_tx_net和handle_rx_net*/
31. if (need_resched())
32. schedule();
33. }
34. }
35. unuse_mm(dev->mm);
36. set_fs(oldfs);
37. return 0;
38. }

从代码可以看到在循环的开始部分是摘除 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小节。

1. static void handle_tx_net(struct vhost_work *work)
2. {
3. struct vhost_net *net = container_of(work, struct vhost_net,
4. poll[VHOST_NET_VQ_TX].work);
5. handle_tx(net);
6. }
7. static void handle_tx(struct vhost_net *net)
8. {
9. ...
10. for (;;) {
11. ...
12. /* TODO: Check specific error and bomb out unless ENOBUFS? */
13. err = sock->ops->sendmsg(sock, &msg, len); /* tup.c中定义 tup_sendmsg ()*/
14. if (unlikely(err < 0)) {
15. ...
16. }
17. out:
18. mutex_unlock(&vq->mutex);
19. }

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 的注册

1. static int __init net_dev_init(void)
2. {
3. int i, rc = -ENOMEM;
4. …
5. for_each_possible_cpu(i) { /* 遍历各个CPU的每CPU变量 */
6. struct work_struct *flush = per_cpu_ptr(&flush_works, i);
7. struct softnet_data *sd = &per_cpu(softnet_data, i); /* sd是个每CPU变量 */
9. INIT_WORK(flush, flush_backlog);
11. skb_queue_head_init(&sd->input_pkt_queue);
12. skb_queue_head_init(&sd->process_queue);
13. INIT_LIST_HEAD(&sd->poll_list);
14. sd->output_queue_tailp = &sd->output_queue;
15. #ifdef CONFIG_RPS
16. sd->csd.func = rps_trigger_softirq;
17. sd->csd.info = sd;
18. sd->cpu = i;
19. #endif
21. sd->backlog.poll = process_backlog; /* 定义napi_struct的poll函数 */
22. sd->backlog.weight = weight_p;
23. }
25. …
26. if (register_pernet_device(&loopback_net_ops))
27. goto out;
29. if (register_pernet_device(&default_device_ops))
30. goto out;
32. open_softirq(NET_TX_SOFTIRQ, net_tx_action); /* 设置软中断NET_TX_SOFTIRQ的响应函数 */
33. open_softirq(NET_RX_SOFTIRQ, net_rx_action); /*设置软中断NET_RX_SOFTIRQ的响应函数 */
35. rc = cpuhp_setup_state_nocalls(CPUHP_NET_DEV_DEAD, "net/dev:dead",
36. NULL, dev_cpu_dead);
37. WARN_ON(rc < 0);
38. rc = 0;
39. out:
40. return rc;
41. }

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 处理函数负责处理相关命令。

1. static struct genl_ops dp_vport_genl_ops[] = {
2. { .cmd = OVS_VPORT_CMD_NEW,
3. .flags = GENL_UNS_ADMIN_PERM, /* Requires CAP_NET_ADMIN privilege. */
4. .policy = vport_policy,
5. .doit = ovs_vport_cmd_new /* OVS_VPORT_CMD_NEW消息的 */
6. },
7. { .cmd = OVS_VPORT_CMD_DEL,
8. .flags = GENL_UNS_ADMIN_PERM, /* Requires CAP_NET_ADMIN privilege. */
9. .policy = vport_policy,
10. .doit = ovs_vport_cmd_del
11. },
12. { .cmd = OVS_VPORT_CMD_GET,
13. .flags = 0, /* OK for unprivileged users. */
14. .policy = vport_policy,
15. .doit = ovs_vport_cmd_get,
16. .dumpit = ovs_vport_cmd_dump
17. },
18. { .cmd = OVS_VPORT_CMD_SET,
19. .flags = GENL_UNS_ADMIN_PERM, /* Requires CAP_NET_ADMIN privilege. */
20. .policy = vport_policy,
21. .doit = ovs_vport_cmd_set,
22. },
23. };
24. struct genl_family dp_vport_genl_family __ro_after_init = {
25. .hdrsize = sizeof(struct ovs_header),
26. .name = OVS_VPORT_FAMILY,
27. .version = OVS_VPORT_VERSION,
28. .maxattr = OVS_VPORT_ATTR_MAX,
29. .netnsok = true,
30. .parallel_ops = true,
31. .ops = dp_vport_genl_ops,
32. .n_ops = ARRAY_SIZE(dp_vport_genl_ops),
33. .mcgrps = &ovs_dp_vport_multicast_group,
34. .n_mcgrps = 1,
35. .module = THIS_MODULE,
36. };
37. static struct genl_family *dp_genl_families[] = {
38. &dp_datapath_genl_family,
39. &dp_vport_genl_family,
40. &dp_flow_genl_family,
41. &dp_packet_genl_family,
42. &dp_meter_genl_family,
43. };
44. static int __init dp_register_genl(void)
45. {
46. int err;
47. int i;
48. for (i = 0; i < ARRAY_SIZE(dp_genl_families); i++) {
49. err = genl_register_family(dp_genl_families[i]); 注册netlink处理函数
50. if (err)
51. goto error;
52. }
53. return 0;
54. error:
55. dp_unregister_genl(i);
56. return err;
57. }

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 代码流程