zoukankan      html  css  js  c++  java

  • 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 钩子函数。

    当 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 代码流程
  • 相关阅读:
    SSD论文优秀句子
    A Case Study -- Performance Evaluation of a DRAM-Based Solid State Disk
    A Case for Flash Memory SSD in Enterprise Database Applications
    Understanding Manycore Scalability of File Systems
    slabs.c
    背包九讲
    redis async client 与自有框架集成
    同步git修改文件到远端服务器脚本
    服务发现：Zookeeper vs etcd vs Consul
    Linux 常用工具贴
  • 原文地址：https://www.cnblogs.com/dream397/p/13870170.html
Copyright © 2011-2022 走看看