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

于 2024-02-27 08:28:29 发布
阅读量1.1k 收藏 17
点赞数 31
分类专栏： KVM QEMU/KVM 文章标签： QEMU KVM virtio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接： https://blog.csdn.net/phmatthaus/article/details/136288603
版权
QEMU/KVM 同时被 2 个专栏收录
123 篇文章 36 订阅 ¥49.90 ¥99.00
已订阅 8折续费
KVM
88 篇文章 19 订阅
订阅专栏
您已是超级会员，正在免费阅读会员专享内容
查看更多超级会员权益
本文详细解析了QEMU virtio中vp_request_msix_vectors函数的工作原理，对比了新老版本的区别，并介绍了在分配MSI-X中断向量及处理中断方面的逻辑。文章还提及了vp_find_vqs_msix函数的部分流程，以及如何根据virtio设备的特征启用中断处理。
摘要由CSDN通过智能技术生成

接前一篇文章：

上回书由init_vq s函数 中调用的virtio_find_vqs函数，跟进到virtio_find_vqs函数中调用的vdev->config->find_vqs(vdev, nvqs, vqs, callbacks, names, NULL, desc)（即virtio_config_ops的find_vqs回调），再到此回调所指向的函数vp_modern_find_vqs()，跟到其所调用的vp_find_vqs函数。调用流程如下：

init_vqs()

--->  virtio_find_vqs()

--->  vdev->config->find_vqs() ---> vp_modern_find_vqs()

--->  vp_find_vqs()

再次贴出vp_find_vqs函数代码，在 Linux 内核源码/drivers/ virtio /virtio_pci_common.c中，代码如下： 

  1. /* the config->find_vqs() implementation */
  2. int vp_find_vqs(struct virtio_device *vdev, unsigned int nvqs,
  3. 		struct virtqueue *vqs[], vq_callback_t *callbacks[],
  4. 		const char * const names[], const bool *ctx,
  5. 		struct irq_affinity *desc)
  6. {
  7. 	int err;
  8.  
  9. 	/* Try MSI-X with one vector per queue. */
  10. 	err = vp_find_vqs_msix(vdev, nvqs, vqs, callbacks, names, true, ctx, desc);
  11. 	if (!err)
  12. 		return 0;
  13. 	/* Fallback: MSI-X with one vector for config, one shared for queues. */
  14. 	err = vp_find_vqs_msix(vdev, nvqs, vqs, callbacks, names, false, ctx, desc);
  15. 	if (!err)
  16. 		return 0;
  17. 	/* Is there an interrupt? If not give up. */
  18. 	if (!(to_vp_device(vdev)->pci_dev->irq))
  19. 		return err;
  20. 	/* Finally fall back to regular interrupts. */
  21. 	return vp_find_vqs_intx(vdev, nvqs, vqs, callbacks, names, ctx);
  22. }

上回书讲到vp_find_vqs_msix函数，讲了其中的前两步。到第三步调用vp_request_msix_vectors函数的时候，又往下跟进了一层。为了便于理解和加深印象，再次贴出vp_find_vqs_msix函数的代码，在Linux内核源码/drivers/virtio/virtio_pci_common.c中，如下： 

  1. static int vp_find_vqs_msix(struct virtio_device *vdev, unsigned int nvqs,
  2. 		struct virtqueue *vqs[], vq_callback_t *callbacks[],
  3. 		const char * const names[], bool per_vq_vectors,
  4. 		const bool *ctx,
  5. 		struct irq_affinity *desc)
  6. {
  7. 	struct virtio_pci_device *vp_dev = to_vp_device(vdev);
  8. 	u16 msix_vec;
  9. 	int i, err, nvectors, allocated_vectors, queue_idx = 0;
  10.  
  11. 	vp_dev->vqs = kcalloc(nvqs, sizeof(*vp_dev->vqs), GFP_KERNEL);
  12. 	if (!vp_dev->vqs)
  13. 		return -ENOMEM;
  14.  
  15. 	if (per_vq_vectors) {
  16. 		/* Best option: one for change interrupt, one per vq. */
  17. 		nvectors = 1;
  18. 		for (i = 0; i < nvqs; ++i)
  19. 			if (names[i] && callbacks[i])
  20. 				++nvectors;
  21. 	} else {
  22. 		/* Second best: one for change, shared for all vqs. */
  23. 		nvectors = 2;
  24. 	}
  25.  
  26. 	err = vp_request_msix_vectors(vdev, nvectors, per_vq_vectors,
  27. 				      per_vq_vectors ? desc : NULL);
  28. 	if (err)
  29. 		goto error_find;
  30.  
  31. 	vp_dev->per_vq_vectors = per_vq_vectors;
  32. 	allocated_vectors = vp_dev->msix_used_vectors;
  33. 	for (i = 0; i < nvqs; ++i) {
  34. 		if (!names[i]) {
  35. 			vqs[i] = NULL;
  36. 			continue;
  37. 		}
  38.  
  39. 		if (!callbacks[i])
  40. 			msix_vec = VIRTIO_MSI_NO_VECTOR;
  41. 		else if (vp_dev->per_vq_vectors)
  42. 			msix_vec = allocated_vectors++;
  43. 		else
  44. 			msix_vec = VP_MSIX_VQ_VECTOR;
  45. 		vqs[i] = vp_setup_vq(vdev, queue_idx++, callbacks[i], names[i],
  46. 				     ctx ? ctx[i] : false,
  47. 				     msix_vec);
  48. 		if (IS_ERR(vqs[i])) {
  49. 			err = PTR_ERR(vqs[i]);
  50. 			goto error_find;
  51. 		}
  52.  
  53. 		if (!vp_dev->per_vq_vectors || msix_vec == VIRTIO_MSI_NO_VECTOR)
  54. 			continue;
  55.  
  56. 		/* allocate per-vq irq if available and necessary */
  57. 		snprintf(vp_dev->msix_names[msix_vec],
  58. 			 sizeof *vp_dev->msix_names,
  59. 			 "%s-%s",
  60. 			 dev_name(&vp_dev->vdev.dev), names[i]);
  61. 		err = request_irq(pci_irq_vector(vp_dev->pci_dev, msix_vec),
  62. 				  vring_interrupt, 0,
  63. 				  vp_dev->msix_names[msix_vec],
  64. 				  vqs[i]);
  65. 		if (err)
  66. 			goto error_find;
  67. 	}
  68. 	return 0;
  69.  
  70. error_find:
  71. 	vp_del_vqs(vdev);
  72. 	return err;
  73. }

vp_request_msix_vectors函数在Linux内核源码/drivers/virtio/virtio_pci_common.c中，代码如下： 

  1. static int vp_request_msix_vectors(struct virtio_device *vdev, int nvectors,
  2. 				   bool per_vq_vectors, struct irq_affinity *desc)
  3. {
  4. 	struct virtio_pci_device *vp_dev = to_vp_device(vdev);
  5. 	const char *name = dev_name(&vp_dev->vdev.dev);
  6. 	unsigned int flags = PCI_IRQ_MSIX;
  7. 	unsigned int i, v;
  8. 	int err = -ENOMEM;
  9.  
  10. 	vp_dev->msix_vectors = nvectors;
  11.  
  12. 	vp_dev->msix_names = kmalloc_array(nvectors,
  13. 					   sizeof(*vp_dev->msix_names),
  14. 					   GFP_KERNEL);
  15. 	if (!vp_dev->msix_names)
  16. 		goto error;
  17. 	vp_dev->msix_affinity_masks
  18. 		= kcalloc(nvectors, sizeof(*vp_dev->msix_affinity_masks),
  19. 			  GFP_KERNEL);
  20. 	if (!vp_dev->msix_affinity_masks)
  21. 		goto error;
  22. 	for (i = 0; i < nvectors; ++i)
  23. 		if (!alloc_cpumask_var(&vp_dev->msix_affinity_masks[i],
  24. 					GFP_KERNEL))
  25. 			goto error;
  26.  
  27. 	if (desc) {
  28. 		flags |= PCI_IRQ_AFFINITY;
  29. 		desc->pre_vectors++; /* virtio config vector */
  30. 	}
  31.  
  32. 	err = pci_alloc_irq_vectors_affinity(vp_dev->pci_dev, nvectors,
  33. 					     nvectors, flags, desc);
  34. 	if (err < 0)
  35. 		goto error;
  36. 	vp_dev->msix_enabled = 1;
  37.  
  38. 	/* Set the vector used for configuration */
  39. 	v = vp_dev->msix_used_vectors;
  40. 	snprintf(vp_dev->msix_names[v], sizeof *vp_dev->msix_names,
  41. 		 "%s-config", name);
  42. 	err = request_irq(pci_irq_vector(vp_dev->pci_dev, v),
  43. 			  vp_config_changed, 0, vp_dev->msix_names[v],
  44. 			  vp_dev);
  45. 	if (err)
  46. 		goto error;
  47. 	++vp_dev->msix_used_vectors;
  48.  
  49. 	v = vp_dev->config_vector(vp_dev, v);
  50. 	/* Verify we had enough resources to assign the vector */
  51. 	if (v == VIRTIO_MSI_NO_VECTOR) {
  52. 		err = -EBUSY;
  53. 		goto error;
  54. 	}
  55.  
  56. 	if (!per_vq_vectors) {
  57. 		/* Shared vector for all VQs */
  58. 		v = vp_dev->msix_used_vectors;
  59. 		snprintf(vp_dev->msix_names[v], sizeof *vp_dev->msix_names,
  60. 			 "%s-virtqueues", name);
  61. 		err = request_irq(pci_irq_vector(vp_dev->pci_dev, v),
  62. 				  vp_vring_interrupt, 0, vp_dev->msix_names[v],
  63. 				  vp_dev);
  64. 		if (err)
  65. 			goto error;
  66. 		++vp_dev->msix_used_vectors;
  67. 	}
  68. 	return 0;
  69. error:
  70. 	return err;
  71. }

本回就对vp_request_msix_vectors函数进行详细解析。

在这里必须也提一下老版本中该函数的代码，如下所示： 

  1. static int vp_request_msix_vectors(struct virtio_device *vdev, int nvectors,
  2. 				   bool per_vq_vectors)
  3. {
  4. 	struct virtio_pci_device *vp_dev = to_vp_device(vdev);
  5. 	const char *name = dev_name(&vp_dev->vdev.dev);
  6. 	unsigned i, v;
  7. 	int err = -ENOMEM;
  8.  
  9. 	vp_dev->msix_vectors = nvectors;
  10.  
  11. 	vp_dev->msix_entries = kmalloc(nvectors * sizeof *vp_dev->msix_entries,
  12. 				       GFP_KERNEL);
  13. 	if (!vp_dev->msix_entries)
  14. 		goto error;
  15. 	vp_dev->msix_names = kmalloc(nvectors * sizeof *vp_dev->msix_names,
  16. 				     GFP_KERNEL);
  17. 	if (!vp_dev->msix_names)
  18. 		goto error;
  19. 	vp_dev->msix_affinity_masks
  20. 		= kzalloc(nvectors * sizeof *vp_dev->msix_affinity_masks,
  21. 			  GFP_KERNEL);
  22. 	if (!vp_dev->msix_affinity_masks)
  23. 		goto error;
  24. 	for (i = 0; i < nvectors; ++i)
  25. 		if (!alloc_cpumask_var(&vp_dev->msix_affinity_masks[i],
  26. 					GFP_KERNEL))
  27. 			goto error;
  28.  
  29. 	for (i = 0; i < nvectors; ++i)
  30. 		vp_dev->msix_entries[i].entry = i;
  31.  
  32. 	err = pci_enable_msix_exact(vp_dev->pci_dev,
  33. 				    vp_dev->msix_entries, nvectors);
  34. 	if (err)
  35. 		goto error;
  36. 	vp_dev->msix_enabled = 1;
  37.  
  38. 	/* Set the vector used for configuration */
  39. 	v = vp_dev->msix_used_vectors;
  40. 	snprintf(vp_dev->msix_names[v], sizeof *vp_dev->msix_names,
  41. 		 "%s-config", name);
  42. 	err = request_irq(vp_dev->msix_entries[v].vector,
  43. 			  vp_config_changed, 0, vp_dev->msix_names[v],
  44. 			  vp_dev);
  45. 	if (err)
  46. 		goto error;
  47. 	++vp_dev->msix_used_vectors;
  48.  
  49. 	v = vp_dev->config_vector(vp_dev, v);
  50. 	/* Verify we had enough resources to assign the vector */
  51. 	if (v == VIRTIO_MSI_NO_VECTOR) {
  52. 		err = -EBUSY;
  53. 		goto error;
  54. 	}
  55.  
  56. 	if (!per_vq_vectors) {
  57. 		/* Shared vector for all VQs */
  58. 		v = vp_dev->msix_used_vectors;
  59. 		snprintf(vp_dev->msix_names[v], sizeof *vp_dev->msix_names,
  60. 			 "%s-virtqueues", name);
  61. 		err = request_irq(vp_dev->msix_entries[v].vector,
  62. 				  vp_vring_interrupt, 0, vp_dev->msix_names[v],
  63. 				  vp_dev);
  64. 		if (err)
  65. 			goto error;
  66. 		++vp_dev->msix_used_vectors;
  67. 	}
  68. 	return 0;
  69. error:
  70. 	vp_free_vectors(vdev);
  71. 	return err;
  72. }

老版本和新版本vp_request_msix_vectors函数最大的区别是新版本中没有了vp_dev->msix_entries相关的代码，这是因为在新版本的virtio_pci_device结构中，不再有msix_entries这个成员所导致的。

老版本中的vp_request_msix_vectors函数完成了以下工作（仍然参考 virtio设备中断分析 ）：

1）分配nvectors个msix中断用 vector ，并使用1个vector来指定vp_config_changed为change中断处理函数。
2）如果per_vq_vectors为false，则nvectors就是2，再用掉另一个vector来指定n个队列共用的vq中断处理函数vp_vring_interrupt。
3）如果per_vq_vectors为true，则在下面代码中为每个队列指定一个vector，vq中断处理函数为vring_interrupt。

由于新老版本中的代码差异与功能并没有太大联系，因此新版本vp_request_msix_vectors函数的功能与上面所述基本一致。

（4） vp_find_vqs_msix函数 接下来是两个赋值语句 。代码片段如下： 

  1.     vp_dev->per_vq_vectors = per_vq_vectors;
  2. 	allocated_vectors = vp_dev->msix_used_vectors;

第一句代码的意思是将vp_find_vqs_msix函数的参数bool per_vq_vectors赋值给vp_dev（virtio PCI设备）的per_vq_vectors成员。

第二句代码是将vp_dev->msix_used_vectors即使用的中断向量个数赋给allocated_vectors。vp_dev->msix_used_vectors在上边的vp_request_msix_vectors函数中生成，代码片段如下： 

  1.     /* Set the vector used for configuration */
  2. 	v = vp_dev->msix_used_vectors;
  3. 	snprintf(vp_dev->msix_names[v], sizeof *vp_dev->msix_names,
  4. 		 "%s-config", name);
  5. 	err = request_irq(pci_irq_vector(vp_dev->pci_dev, v),
  6. 			  vp_config_changed, 0, vp_dev->msix_names[v],
  7. 			  vp_dev);
  8. 	if (err)
  9. 		goto error;
  10. 	++vp_dev->msix_used_vectors;
  11.  
  12. 	v = vp_dev->config_vector(vp_dev, v);
  13. 	/* Verify we had enough resources to assign the vector */
  14. 	if (v == VIRTIO_MSI_NO_VECTOR) {
  15. 		err = -EBUSY;
  16. 		goto error;
  17. 	}
  18.  
  19. 	if (!per_vq_vectors) {
  20. 		/* Shared vector for all VQs */
  21. 		v = vp_dev->msix_used_vectors;
  22. 		snprintf(vp_dev->msix_names[v], sizeof *vp_dev->msix_names,
  23. 			 "%s-virtqueues", name);
  24. 		err = request_irq(pci_irq_vector(vp_dev->pci_dev, v),
  25. 				  vp_vring_interrupt, 0, vp_dev->msix_names[v],
  26. 				  vp_dev);
  27. 		if (err)
  28. 			goto error;
  29. 		++vp_dev->msix_used_vectors;
  30. 	}

（5） 接下来，vp_find_vqs_msix函数进入循环， 设置每个使能的vq并申请中断 。 

  1. enum virtio_balloon_vq {
  2. 	VIRTIO_BALLOON_VQ_INFLATE,
  3. 	VIRTIO_BALLOON_VQ_DEFLATE,
  4. 	VIRTIO_BALLOON_VQ_STATS,
  5. 	VIRTIO_BALLOON_VQ_FREE_PAGE,
  6. 	VIRTIO_BALLOON_VQ_REPORTING,
  7. 	VIRTIO_BALLOON_VQ_MAX
  8. };

代码片段如下： 

  1.     for (i = 0; i < nvqs; ++i) {
  2. 		if (!names[i]) {
  3. 			vqs[i] = NULL;
  4. 			continue;
  5. 		}
  6.  
  7. 		if (!callbacks[i])
  8. 			msix_vec = VIRTIO_MSI_NO_VECTOR;
  9. 		else if (vp_dev->per_vq_vectors)
  10. 			msix_vec = allocated_vectors++;
  11. 		else
  12. 			msix_vec = VP_MSIX_VQ_VECTOR;
  13. 		vqs[i] = vp_setup_vq(vdev, queue_idx++, callbacks[i], names[i],
  14. 				     ctx ? ctx[i] : false,
  15. 				     msix_vec);
  16. 		if (IS_ERR(vqs[i])) {
  17. 			err = PTR_ERR(vqs[i]);
  18. 			goto error_find;
  19. 		}
  20.  
  21. 		if (!vp_dev->per_vq_vectors || msix_vec == VIRTIO_MSI_NO_VECTOR)
  22. 			continue;
  23.  
  24. 		/* allocate per-vq irq if available and necessary */
  25. 		snprintf(vp_dev->msix_names[msix_vec],
  26. 			 sizeof *vp_dev->msix_names,
  27. 			 "%s-%s",
  28. 			 dev_name(&vp_dev->vdev.dev), names[i]);
  29. 		err = request_irq(pci_irq_vector(vp_dev->pci_dev, msix_vec),
  30. 				  vring_interrupt, 0,
  31. 				  vp_dev->msix_names[msix_vec],
  32. 				  vqs[i]);
  33. 		if (err)
  34. 			goto error_find;
  35. 	}

names[]前文已经讲过了，参见 QEMU源码全解析 —— virtio（23）

有2个无条件的feature，如下所示： 

  1.     struct virtqueue *vqs[VIRTIO_BALLOON_VQ_MAX];
  2.     vq_callback_t *callbacks[VIRTIO_BALLOON_VQ_MAX];
  3.     const char *names[VIRTIO_BALLOON_VQ_MAX];
  4.     int err;
  5.  
  6.     /*
  7.      * Inflateq and deflateq are used unconditionally. The names[]
  8.      * will be NULL if the related feature is not enabled, which will
  9.      * cause no allocation for the corresponding virtqueue in find_vqs.
  10.      */
  11.     callbacks[VIRTIO_BALLOON_VQ_INFLATE] = balloon_ack;
  12.     names[VIRTIO_BALLOON_VQ_INFLATE] = "inflate";
  13.     callbacks[VIRTIO_BALLOON_VQ_DEFLATE] = balloon_ack;
  14.     names[VIRTIO_BALLOON_VQ_DEFLATE] = "deflate";
  15.     callbacks[VIRTIO_BALLOON_VQ_STATS] = NULL;
  16.     names[VIRTIO_BALLOON_VQ_STATS] = NULL;
  17.     callbacks[VIRTIO_BALLOON_VQ_FREE_PAGE] = NULL;
  18.     names[VIRTIO_BALLOON_VQ_FREE_PAGE] = NULL;
  19.     names[VIRTIO_BALLOON_VQ_REPORTING] = NULL;

还有3个有条件的feature，如下所示： 

  1.     if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_STATS_VQ)) {
  2. 		names[VIRTIO_BALLOON_VQ_STATS] = "stats";
  3. 		callbacks[VIRTIO_BALLOON_VQ_STATS] = stats_request;
  4. 	}
  5.  
  6. 	if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_FREE_PAGE_HINT)) {
  7. 		names[VIRTIO_BALLOON_VQ_FREE_PAGE] = "free_page_vq";
  8. 		callbacks[VIRTIO_BALLOON_VQ_FREE_PAGE] = NULL;
  9. 	}
  10.  
  11. 	if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_REPORTING)) {
  12. 		names[VIRTIO_BALLOON_VQ_REPORTING] = "reporting_vq";
  13. 		callbacks[VIRTIO_BALLOON_VQ_REPORTING] = balloon_ack;
  14. 	}

如果某个feature未被使能，则其对应的names[i]就为NULL，就把其对应的vqs[i]也置为NULL，跳过该特性。代码片段如下： 

  1.         if (!names[i]) {
  2. 			vqs[i] = NULL;
  3. 			continue;
  4. 		}

能再往下走的都是使能的feature了。这里又分为两种情况：一种是其对应的 callbacks [i]不为NULL，这是对于大多数feature来说的；另一种是虽然names[i]不为空，但callbacks[i]为NULL，目前这种情况只是对于VIRTIO_BALLOON_VQ_FREE_PAGE才会出现。对于后一种情况，将msix_vec设置为VIRTIO_MSI_NO_VECTOR；对于前一种情况，又要看根据上一回所讲的virtio的中断处理方式进行区别对待。对于“使用msix中断，有n+1个vector”的情况，每循环至此一次，allocated_vectors自增1，同时赋给msix_vec；否则就将msix_vec设置为VP_MSIX_VQ_VECTOR。代码片段如下： 

  1. 		if (!callbacks[i])
  2. 			msix_vec = VIRTIO_MSI_NO_VECTOR;
  3. 		else if (vp_dev->per_vq_vectors)
  4. 			msix_vec = allocated_vectors++;
  5. 		else
  6. 			msix_vec = VP_MSIX_VQ_VECTOR;

接下来，循环中就来到了第一个核心函数：vp_setup_vq。对于它的详细解析，请看下回。

举报

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

取消

确定