QEMU源码全解析 —— virtio（12）

已于 2024-08-19 22:30:02 修改
阅读量1.2k 收藏 20
点赞数 27
分类专栏： QEMU/KVM KVM 文章标签： QEMU KVM virtio
于 2023-12-17 10:21:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接： https://blog.csdn.net/phmatthaus/article/details/135037471
版权
QEMU/KVM 同时被 2 个专栏收录
123 篇文章 36 订阅 ¥49.90 ¥99.00
已订阅 8折续费
KVM
88 篇文章 19 订阅
订阅专栏
您已是超级会员，正在免费阅读会员专享内容
查看更多超级会员权益
本文详细解析了QEMU中virtio balloon设备的实现，重点介绍了virtio_balloon_device_realize函数。该函数首先调用virtio_init初始化设备的公共部分，然后通过virtio_add_queue创建3个virtqueue，用于与虚拟机的数据传输。这些virtqueue使用VirtQueue结构表示，并设置处理输出的回调函数。
摘要由CSDN通过智能技术生成

接前一篇文章：

上一回对于virtio_device_realize函数进行了详细解析。在第2步中virtio_device_realize 函数调用 了具体类的realize函数，对于virtio balloon设备来说是virtio_balloon_device_realize函数。本回就来对于virtio_balloon_device_realize函数进行解析。

为了便于理解，再次贴出virtio_device_realize函数源码，在hw/ virtio /virtio.c中，如下： 

  1. static void virtio_device_realize(DeviceState *dev, Error **errp)
  2. {
  3.     VirtIODevice *vdev = VIRTIO_DEVICE(dev);
  4.     VirtioDeviceClass *vdc = VIRTIO_DEVICE_GET_CLASS(dev);
  5.     Error *err = NULL;
  6.  
  7.     /* Devices should either use vmsd or the load/save methods */
  8.     assert(!vdc->vmsd || !vdc->load);
  9.  
  10.     if (vdc->realize != NULL) {
  11.         vdc->realize(dev, &err);
  12.         if (err != NULL) {
  13.             error_propagate(errp, err);
  14.             return;
  15.         }
  16.     }
  17.  
  18.     virtio_bus_device_plugged(vdev, &err);
  19.     if (err != NULL) {
  20.         error_propagate(errp, err);
  21.         vdc->unrealize(dev);
  22.         return;
  23.     }
  24.  
  25.     vdev->listener.commit = virtio_memory_listener_commit;
  26.     vdev->listener.name = "virtio";
  27.     memory_listener_register(&vdev->listener, vdev->dma_as);
  28.     QTAILQ_INSERT_TAIL(&virtio_list, vdev, next);
  29. }

调用具体类的realize函数的代码片段如下： 

  1.     if (vdc->realize != NULL) {
  2.         vdc->realize(dev, &err);
  3.         if (err != NULL) {
  4.             error_propagate(errp, err);
  5.             return;
  6.         }
  7.     }

virtio_balloon_device_realize函数在hw/virtio/virtio-balloon.c中，代码如下： 

  1. static void virtio_balloon_device_realize(DeviceState *dev, Error **errp)
  2. {
  3.     VirtIODevice *vdev = VIRTIO_DEVICE(dev);
  4.     VirtIOBalloon *s = VIRTIO_BALLOON(dev);
  5.     int ret;
  6.  
  7.     virtio_init(vdev, VIRTIO_ID_BALLOON, virtio_balloon_config_size(s));
  8.  
  9.     ret = qemu_add_balloon_handler(virtio_balloon_to_target,
  10.                                    virtio_balloon_stat, s);
  11.  
  12.     if (ret < 0) {
  13.         error_setg(errp, "Only one balloon device is supported");
  14.         virtio_cleanup(vdev);
  15.         return;
  16.     }
  17.  
  18.     if (virtio_has_feature(s->host_features, VIRTIO_BALLOON_F_FREE_PAGE_HINT) &&
  19.         !s->iothread) {
  20.         error_setg(errp, "'free-page-hint' requires 'iothread' to be set");
  21.         virtio_cleanup(vdev);
  22.         return;
  23.     }
  24.  
  25.     s->ivq = virtio_add_queue(vdev, 128, virtio_balloon_handle_output);
  26.     s->dvq = virtio_add_queue(vdev, 128, virtio_balloon_handle_output);
  27.     s->svq = virtio_add_queue(vdev, 128, virtio_balloon_receive_stats);
  28.  
  29.     if (virtio_has_feature(s->host_features, VIRTIO_BALLOON_F_FREE_PAGE_HINT)) {
  30.         s->free_page_vq = virtio_add_queue(vdev, VIRTQUEUE_MAX_SIZE,
  31.                                            virtio_balloon_handle_free_page_vq);
  32.         precopy_add_notifier(&s->free_page_hint_notify);
  33.  
  34.         object_ref(OBJECT(s->iothread));
  35.         s->free_page_bh = aio_bh_new_guarded(iothread_get_aio_context(s->iothread),
  36.                                              virtio_ballloon_get_free_page_hints, s,
  37.                                              &dev->mem_reentrancy_guard);
  38.     }
  39.  
  40.     if (virtio_has_feature(s->host_features, VIRTIO_BALLOON_F_REPORTING)) {
  41.         s->reporting_vq = virtio_add_queue(vdev, 32,
  42.                                            virtio_balloon_handle_report);
  43.     }
  44.  
  45.     reset_stats(s);
  46. }

在同文件（hw/virtio/virtio-balloon.c）的virtio_balloon_class_init函数中，将virtio_balloon_device_realize函数（地址）赋给了vdc->realize。 

  1. static void virtio_balloon_class_init(ObjectClass *klass, void *data)
  2. {
  3.     DeviceClass *dc = DEVICE_CLASS(klass);
  4.     VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
  5.  
  6.     device_class_set_props(dc, virtio_balloon_properties);
  7.     dc->vmsd = &vmstate_virtio_balloon;
  8.     set_bit(DEVICE_CATEGORY_MISC, dc->categories);
  9.     vdc->realize = virtio_balloon_device_realize;
  10.     vdc->unrealize = virtio_balloon_device_unrealize;
  11.     vdc->reset = virtio_balloon_device_reset;
  12.     vdc->get_config = virtio_balloon_get_config;
  13.     vdc->set_config = virtio_balloon_set_config;
  14.     vdc->get_features = virtio_balloon_get_features;
  15.     vdc->set_status = virtio_balloon_set_status;
  16.     vdc->vmsd = &vmstate_virtio_balloon_device;
  17. }

virtio_balloon_device_realize()是virtio balloon设备的具现化函数，它用于实现TYPE_VIRTIO_BALLOON_DEVICE的具现化。

（1）virtio_balloon_device_realize函数首先调用virtio_init函数初始化virtio设备的公共部分。代码片段如下： 

    virtio_init(vdev, VIRTIO_ID_BALLOON, virtio_balloon_config_size(s));

virtio_init函数在hw/virtio/virtio.c中，代码如下： 

  1. void virtio_init(VirtIODevice *vdev, uint16_t device_id, size_t config_size)
  2. {
  3.     BusState *qbus = qdev_get_parent_bus(DEVICE(vdev));
  4.     VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
  5.     int i;
  6.     int nvectors = k->query_nvectors ? k->query_nvectors(qbus->parent) : 0;
  7.  
  8.     if (nvectors) {
  9.         vdev->vector_queues =
  10.             g_malloc0(sizeof(*vdev->vector_queues) * nvectors);
  11.     }
  12.  
  13.     vdev->start_on_kick = false;
  14.     vdev->started = false;
  15.     vdev->vhost_started = false;
  16.     vdev->device_id = device_id;
  17.     vdev->status = 0;
  18.     qatomic_set(&vdev->isr, 0);
  19.     vdev->queue_sel = 0;
  20.     vdev->config_vector = VIRTIO_NO_VECTOR;
  21.     vdev->vq = g_new0(VirtQueue, VIRTIO_QUEUE_MAX);
  22.     vdev->vm_running = runstate_is_running();
  23.     vdev->broken = false;
  24.     for (i = 0; i < VIRTIO_QUEUE_MAX; i++) {
  25.         vdev->vq[i].vector = VIRTIO_NO_VECTOR;
  26.         vdev->vq[i].vdev = vdev;
  27.         vdev->vq[i].queue_index = i;
  28.         vdev->vq[i].host_notifier_enabled = false;
  29.     }
  30.  
  31.     vdev->name = virtio_id_to_name(device_id);
  32.     vdev->config_len = config_size;
  33.     if (vdev->config_len) {
  34.         vdev->config = g_malloc0(config_size);
  35.     } else {
  36.         vdev->config = NULL;
  37.     }
  38.     vdev->vmstate = qdev_add_vm_change_state_handler(DEVICE(vdev),
  39.             virtio_vmstate_change, vdev);
  40.     vdev->device_endian = virtio_default_endian();
  41.     vdev->use_guest_notifier_mask = true;
  42. }

virtio_init函数的工作是初始化所有virtio设备的基类TYPE_VIRTIO_DEVICE的实例VirtIODevice结构体，其对VirtIODevice的成员进行初始化。

VirtIODevice的vector_queues成员和config_vector成员与MSI中断相关；device_id、status、name成员分别表示设备的id、状态和名字；isr成员用来表示中断请求；queue_sel成员用来在进行配置队列的时候选择队列；vq成员表示的是该设备的virtio queue，这里分配了VIRTIO_QUEUE_MAX个queue，并且进行了初始化；config_len和config分别表示该virtio设备配置空间的长度和数据存放区域；use_guest_notifier_mask成员与irqfd有关。

回到virtio_balloon_device_realize函数。

（2）在virtio_init函数初始化了VirtIODevice之后，调用virtio_add_queue函数创建了3个virtqueue。代码片段如下： 

  1.     s->ivq = virtio_add_queue(vdev, 128, virtio_balloon_handle_output);
  2.     s->dvq = virtio_add_queue(vdev, 128, virtio_balloon_handle_output);
  3.     s->svq = virtio_add_queue(vdev, 128, virtio_balloon_receive_stats);

virtqueue是virtio设备的重要组成部分，用来与 虚拟机 中的操作系统进行数据传输。virtio_add_queue函数在hw/virtio/virtio.c中，代码如下： 

  1. VirtQueue *virtio_add_queue(VirtIODevice *vdev, int queue_size,
  2.                             VirtIOHandleOutput handle_output)
  3. {
  4.     int i;
  5.  
  6.     for (i = 0; i < VIRTIO_QUEUE_MAX; i++) {
  7.         if (vdev->vq[i].vring.num == 0)
  8.             break;
  9.     }
  10.  
  11.     if (i == VIRTIO_QUEUE_MAX || queue_size > VIRTQUEUE_MAX_SIZE)
  12.         abort();
  13.  
  14.     vdev->vq[i].vring.num = queue_size;
  15.     vdev->vq[i].vring.num_default = queue_size;
  16.     vdev->vq[i].vring.align = VIRTIO_PCI_VRING_ALIGN;
  17.     vdev->vq[i].handle_output = handle_output;
  18.     vdev->vq[i].used_elems = g_new0(VirtQueueElement, queue_size);
  19.  
  20.     return &vdev->vq[i];
  21. }

virtio_add_queue函数是virtio框架中用来添加virtqueue的接口，其3个参数分别表示要添加的设备（VirtIODevice *vdev）、virtqueue的大小（int queue_size）以及处理函数（VirtIOHandleOutput handle_output）。

virtio_add_queue函数从VirtIODevice的vq数组成员中找到还未被使用的一个queue。一个virtqueue使用VirtQueue结构表示，这里对VirtQueue的成员进行初始化，包括这个queue的大小以及对齐等信息。最重要的是设置VirtQueue的handle_output成员，其是一个函数指针，在收到虚拟机发过来的IO请求时，会调用存放在handle_output中的回调函数。

VirtQueue结构的定义在hw/virtio/virtio.c中，如下： 

  1. struct VirtQueue
  2. {
  3.     VRing vring;
  4.     VirtQueueElement *used_elems;
  5.  
  6.     /* Next head to pop */
  7.     uint16_t last_avail_idx;
  8.     bool last_avail_wrap_counter;
  9.  
  10.     /* Last avail_idx read from VQ. */
  11.     uint16_t shadow_avail_idx;
  12.     bool shadow_avail_wrap_counter;
  13.  
  14.     uint16_t used_idx;
  15.     bool used_wrap_counter;
  16.  
  17.     /* Last used index value we have signalled on */
  18.     uint16_t signalled_used;
  19.  
  20.     /* Last used index value we have signalled on */
  21.     bool signalled_used_valid;
  22.  
  23.     /* Notification enabled? */
  24.     bool notification;
  25.  
  26.     uint16_t queue_index;
  27.  
  28.     unsigned int inuse;
  29.  
  30.     uint16_t vector;
  31.     VirtIOHandleOutput handle_output;
  32.     VirtIODevice *vdev;
  33.     EventNotifier guest_notifier;
  34.     EventNotifier host_notifier;
  35.     bool host_notifier_enabled;
  36.     QLIST_ENTRY(VirtQueue) node;
  37. };

欲知后事如何，且看下回分解。

举报

选择你想要举报的内容（必选）
  • 内容涉黄
  • 政治相关
  • 内容抄袭
  • 涉嫌广告
  • 内容侵权
  • 侮辱谩骂
  • 样式问题
  • 其他

取消

确定