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

已于 2024-10-15 21:44:08 修改
阅读量1.2k 收藏 20
点赞数 30
分类专栏： KVM QEMU/KVM 文章标签： QEMU KVM virtio
于 2023-12-20 16:14:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接： https://blog.csdn.net/phmatthaus/article/details/135098916
版权
QEMU/KVM 同时被 2 个专栏收录
123 篇文章 36 订阅 ¥49.90 ¥99.00
已订阅 8折续费
KVM
88 篇文章 19 订阅
订阅专栏
您已是超级会员，正在免费阅读会员专享内容
查看更多超级会员权益
本文详细解析了Linux内核中virtio_pci_modern_probe和virtio_pci_legacy_probe函数，重点讨论了virtio_pci_modern_probe的执行流程，包括设置virtio设备的vendor ID和device ID，发现PCI capability，映射BAR到内核地址空间等关键步骤。同时，简要介绍了virtio_pci_legacy_probe。通过对这两个函数的解析，加深了对QEMU中virtio设备初始化的理解。
摘要由CSDN通过智能技术生成

接前一篇文章：

上回书继续讲解virtio_pci_driver的 probe 回调函数virtio_pci_probe()，在讲到第5段代码的时候， 

  1.     if (force_legacy) {
  2. 		rc = virtio_pci_legacy_probe(vp_dev);
  3. 		/* Also try modern mode if we can't map BAR0 (no IO space). */
  4. 		if (rc == -ENODEV || rc == -ENOMEM)
  5. 			rc = virtio_pci_modern_probe(vp_dev);
  6. 		if (rc)
  7. 			goto err_probe;
  8. 	} else {
  9. 		rc = virtio_pci_modern_probe(vp_dev);
  10. 		if (rc == -ENODEV)
  11. 			rc = virtio_pci_legacy_probe(vp_dev);
  12. 		if (rc)
  13. 			goto err_probe;
  14. 	}

引出来两个函数：virtio_pci_legacy_probe和virtio_pci_modern_probe。本回就来对它们进行解析。当然，由于legacy已是“过去时”（针对传统设备的），因此重点围绕virtio_pci_modern_probe函数进行解析，捎带手地也讲一下virtio_pci_legacy_probe函数。为了便于理解和回顾，再次贴出两个函数的源码：

  • virtio_pci_legacy_probe

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

  1. /* the PCI probing function */
  2. int virtio_pci_legacy_probe(struct virtio_pci_device *vp_dev)
  3. {
  4. 	struct virtio_pci_legacy_device *ldev = &vp_dev->ldev;
  5. 	struct pci_dev *pci_dev = vp_dev->pci_dev;
  6. 	int rc;
  7.  
  8. 	ldev->pci_dev = pci_dev;
  9.  
  10. 	rc = vp_legacy_probe(ldev);
  11. 	if (rc)
  12. 		return rc;
  13.  
  14. 	vp_dev->isr = ldev->isr;
  15. 	vp_dev->vdev.id = ldev->id;
  16.  
  17. 	vp_dev->vdev.config = &virtio_pci_config_ops;
  18.  
  19. 	vp_dev->config_vector = vp_config_vector;
  20. 	vp_dev->setup_vq = setup_vq;
  21. 	vp_dev->del_vq = del_vq;
  22.  
  23. 	return 0;
  24. }
  • virtio_pci_modern_probe

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

  1. /* the PCI probing function */
  2. int virtio_pci_modern_probe(struct virtio_pci_device *vp_dev)
  3. {
  4. 	struct virtio_pci_modern_device *mdev = &vp_dev->mdev;
  5. 	struct pci_dev *pci_dev = vp_dev->pci_dev;
  6. 	int err;
  7.  
  8. 	mdev->pci_dev = pci_dev;
  9.  
  10. 	err = vp_modern_probe(mdev);
  11. 	if (err)
  12. 		return err;
  13.  
  14. 	if (mdev->device)
  15. 		vp_dev->vdev.config = &virtio_pci_config_ops;
  16. 	else
  17. 		vp_dev->vdev.config = &virtio_pci_config_nodev_ops;
  18.  
  19. 	vp_dev->config_vector = vp_config_vector;
  20. 	vp_dev->setup_vq = setup_vq;
  21. 	vp_dev->del_vq = del_vq;
  22. 	vp_dev->isr = mdev->isr;
  23. 	vp_dev->vdev.id = mdev->id;
  24.  
  25. 	return 0;
  26. }

virtio_pci_modern_probe函数中最主要地是调用了vp_modern_probe函数，其在Linux内核源码/drivers/virtio/virtio_pci_modern_dev.c中，代码如下： 

  1. /*
  2.  * vp_modern_probe: probe the modern virtio pci device, note that the
  3.  * caller is required to enable PCI device before calling this function.
  4.  * @mdev: the modern virtio-pci device
  5.  *
  6.  * Return 0 on succeed otherwise fail
  7.  */
  8. int vp_modern_probe(struct virtio_pci_modern_device *mdev)
  9. {
  10. 	struct pci_dev *pci_dev = mdev->pci_dev;
  11. 	int err, common, isr, notify, device;
  12. 	u32 notify_length;
  13. 	u32 notify_offset;
  14.  
  15. 	check_offsets();
  16.  
  17. 	/* We only own devices >= 0x1000 and <= 0x107f: leave the rest. */
  18. 	if (pci_dev->device < 0x1000 || pci_dev->device > 0x107f)
  19. 		return -ENODEV;
  20.  
  21. 	if (pci_dev->device < 0x1040) {
  22. 		/* Transitional devices: use the PCI subsystem device id as
  23. 		 * virtio device id, same as legacy driver always did.
  24. 		 */
  25. 		mdev->id.device = pci_dev->subsystem_device;
  26. 	} else {
  27. 		/* Modern devices: simply use PCI device id, but start from 0x1040. */
  28. 		mdev->id.device = pci_dev->device - 0x1040;
  29. 	}
  30. 	mdev->id.vendor = pci_dev->subsystem_vendor;
  31.  
  32. 	/* check for a common config: if not, use legacy mode (bar 0). */
  33. 	common = virtio_pci_find_capability(pci_dev, VIRTIO_PCI_CAP_COMMON_CFG,
  34. 					    IORESOURCE_IO | IORESOURCE_MEM,
  35. 					    &mdev->modern_bars);
  36. 	if (!common) {
  37. 		dev_info(&pci_dev->dev,
  38. 			 "virtio_pci: leaving for legacy driver\n");
  39. 		return -ENODEV;
  40. 	}
  41.  
  42. 	/* If common is there, these should be too... */
  43. 	isr = virtio_pci_find_capability(pci_dev, VIRTIO_PCI_CAP_ISR_CFG,
  44. 					 IORESOURCE_IO | IORESOURCE_MEM,
  45. 					 &mdev->modern_bars);
  46. 	notify = virtio_pci_find_capability(pci_dev, VIRTIO_PCI_CAP_NOTIFY_CFG,
  47. 					    IORESOURCE_IO | IORESOURCE_MEM,
  48. 					    &mdev->modern_bars);
  49. 	if (!isr || !notify) {
  50. 		dev_err(&pci_dev->dev,
  51. 			"virtio_pci: missing capabilities %i/%i/%i\n",
  52. 			common, isr, notify);
  53. 		return -EINVAL;
  54. 	}
  55.  
  56. 	err = dma_set_mask_and_coherent(&pci_dev->dev, DMA_BIT_MASK(64));
  57. 	if (err)
  58. 		err = dma_set_mask_and_coherent(&pci_dev->dev,
  59. 						DMA_BIT_MASK(32));
  60. 	if (err)
  61. 		dev_warn(&pci_dev->dev, "Failed to enable 64-bit or 32-bit DMA.  Trying to continue, but this might not work.\n");
  62.  
  63. 	/* Device capability is only mandatory for devices that have
  64. 	 * device-specific configuration.
  65. 	 */
  66. 	device = virtio_pci_find_capability(pci_dev, VIRTIO_PCI_CAP_DEVICE_CFG,
  67. 					    IORESOURCE_IO | IORESOURCE_MEM,
  68. 					    &mdev->modern_bars);
  69.  
  70. 	err = pci_request_selected_regions(pci_dev, mdev->modern_bars,
  71. 					   "virtio-pci-modern");
  72. 	if (err)
  73. 		return err;
  74.  
  75. 	err = -EINVAL;
  76. 	mdev->common = vp_modern_map_capability(mdev, common,
  77. 				      sizeof(struct virtio_pci_common_cfg), 4,
  78. 				      0, sizeof(struct virtio_pci_common_cfg),
  79. 				      NULL, NULL);
  80. 	if (!mdev->common)
  81. 		goto err_map_common;
  82. 	mdev->isr = vp_modern_map_capability(mdev, isr, sizeof(u8), 1,
  83. 					     0, 1,
  84. 					     NULL, NULL);
  85. 	if (!mdev->isr)
  86. 		goto err_map_isr;
  87.  
  88. 	/* Read notify_off_multiplier from config space. */
  89. 	pci_read_config_dword(pci_dev,
  90. 			      notify + offsetof(struct virtio_pci_notify_cap,
  91. 						notify_off_multiplier),
  92. 			      &mdev->notify_offset_multiplier);
  93. 	/* Read notify length and offset from config space. */
  94. 	pci_read_config_dword(pci_dev,
  95. 			      notify + offsetof(struct virtio_pci_notify_cap,
  96. 						cap.length),
  97. 			      &notify_length);
  98.  
  99. 	pci_read_config_dword(pci_dev,
  100. 			      notify + offsetof(struct virtio_pci_notify_cap,
  101. 						cap.offset),
  102. 			      &notify_offset);
  103.  
  104. 	/* We don't know how many VQs we'll map, ahead of the time.
  105. 	 * If notify length is small, map it all now.
  106. 	 * Otherwise, map each VQ individually later.
  107. 	 */
  108. 	if ((u64)notify_length + (notify_offset % PAGE_SIZE) <= PAGE_SIZE) {
  109. 		mdev->notify_base = vp_modern_map_capability(mdev, notify,
  110. 							     2, 2,
  111. 							     0, notify_length,
  112. 							     &mdev->notify_len,
  113. 							     &mdev->notify_pa);
  114. 		if (!mdev->notify_base)
  115. 			goto err_map_notify;
  116. 	} else {
  117. 		mdev->notify_map_cap = notify;
  118. 	}
  119.  
  120. 	/* Again, we don't know how much we should map, but PAGE_SIZE
  121. 	 * is more than enough for all existing devices.
  122. 	 */
  123. 	if (device) {
  124. 		mdev->device = vp_modern_map_capability(mdev, device, 0, 4,
  125. 							0, PAGE_SIZE,
  126. 							&mdev->device_len,
  127. 							NULL);
  128. 		if (!mdev->device)
  129. 			goto err_map_device;
  130. 	}
  131.  
  132. 	return 0;
  133.  
  134. err_map_device:
  135. 	if (mdev->notify_base)
  136. 		pci_iounmap(pci_dev, mdev->notify_base);
  137. err_map_notify:
  138. 	pci_iounmap(pci_dev, mdev->isr);
  139. err_map_isr:
  140. 	pci_iounmap(pci_dev, mdev->common);
  141. err_map_common:
  142. 	pci_release_selected_regions(pci_dev, mdev->modern_bars);
  143. 	return err;
  144. }
  145. EXPORT_SYMBOL_GPL(vp_modern_probe);

实际上在老版本KVM即Linux内核代码中，vp_modern_probe函数中的内容绝大多数是直接放在virtio_pci_modern_probe函数中的，后来才单独封了这样一个函数。

（1）vp_modern_probe首先设置了virtio设备的verdor ID和device ID。代码片段如下： 

  1.     /* We only own devices >= 0x1000 and <= 0x107f: leave the rest. */
  2. 	if (pci_dev->device < 0x1000 || pci_dev->device > 0x107f)
  3. 		return -ENODEV;
  4.  
  5. 	if (pci_dev->device < 0x1040) {
  6. 		/* Transitional devices: use the PCI subsystem device id as
  7. 		 * virtio device id, same as legacy driver always did.
  8. 		 */
  9. 		mdev->id.device = pci_dev->subsystem_device;
  10. 	} else {
  11. 		/* Modern devices: simply use PCI device id, but start from 0x1040. */
  12. 		mdev->id.device = pci_dev->device - 0x1040;
  13. 	}
  14. 	mdev->id.vendor = pci_dev->subsystem_vendor;

值得注意的是，virtio PCI代理设备的device ID就是前文书（参见 QEMU源码全解析 —— virtio（14） ）在讲virtio_pci_device_plugged函数（QEMU源码中）时设置的PCI_DEVICE_ID_VIRTIO_10_BASE+VIRTIO_ID_BALLOON，即0x1040+5。

163069cc9d1bd09f58e1a6bc6fa54b23.png

所以，这里virtio设备的device ID（mdev->id.device）就是0x1040+5-0x1040=5，也就代表了VIRTIO_ID_BALLOON。

Vendor ID和Device ID参考笔者的文章： 《PCI Express体系结构导读》随记 —— 第I篇 第2章 PCI总线的桥与配置（12）

3bb0af6357bff314fa193654da606928.png

（2）接下来，调用多次virtio_pci_find_capability函数来发现virtio PCI代理设备的pci capability。代码片段如下： 

  1. /* check for a common config: if not, use legacy mode (bar 0). */
  2. 	common = virtio_pci_find_capability(pci_dev, VIRTIO_PCI_CAP_COMMON_CFG,
  3. 					    IORESOURCE_IO | IORESOURCE_MEM,
  4. 					    &mdev->modern_bars);
  5. 	if (!common) {
  6. 		dev_info(&pci_dev->dev,
  7. 			 "virtio_pci: leaving for legacy driver\n");
  8. 		return -ENODEV;
  9. 	}
  10.  
  11. 	/* If common is there, these should be too... */
  12. 	isr = virtio_pci_find_capability(pci_dev, VIRTIO_PCI_CAP_ISR_CFG,
  13. 					 IORESOURCE_IO | IORESOURCE_MEM,
  14. 					 &mdev->modern_bars);
  15. 	notify = virtio_pci_find_capability(pci_dev, VIRTIO_PCI_CAP_NOTIFY_CFG,
  16. 					    IORESOURCE_IO | IORESOURCE_MEM,
  17. 					    &mdev->modern_bars);
  18. 	if (!isr || !notify) {
  19. 		dev_err(&pci_dev->dev,
  20. 			"virtio_pci: missing capabilities %i/%i/%i\n",
  21. 			common, isr, notify);
  22. 		return -EINVAL;
  23. 	}
  24.  
  25. 	err = dma_set_mask_and_coherent(&pci_dev->dev, DMA_BIT_MASK(64));
  26. 	if (err)
  27. 		err = dma_set_mask_and_coherent(&pci_dev->dev,
  28. 						DMA_BIT_MASK(32));
  29. 	if (err)
  30. 		dev_warn(&pci_dev->dev, "Failed to enable 64-bit or 32-bit DMA.  Trying to continue, but this might not work.\n");
  31.  
  32. 	/* Device capability is only mandatory for devices that have
  33. 	 * device-specific configuration.
  34. 	 */
  35. 	device = virtio_pci_find_capability(pci_dev, VIRTIO_PCI_CAP_DEVICE_CFG,
  36. 					    IORESOURCE_IO | IORESOURCE_MEM,
  37. 					    &mdev->modern_bars);

这也是在（QEMU源码）virtio_pci_device_plugged函数中写入到virtio PCI代理设备的配置空间中的，参见 QEMU源码全解析 —— virtio（14） 和 QEMU源码全解析 —— virtio（15） 。

dd30960444ce56406735129ce2aeb9a2.png

关于pci capability这一部分的PCI知识，参考：

VirtIO实现原理——PCI基础

2ceee9988f076577e66833f938e5f0e7.png

（3）virtio_pci_find_capability函数找到所属的PCI BAR，然后写入到virt_pci_device的modern_bars成员中。代码片段如下： 

  1.     /* Device capability is only mandatory for devices that have
  2. 	 * device-specific configuration.
  3. 	 */
  4. 	device = virtio_pci_find_capability(pci_dev, VIRTIO_PCI_CAP_DEVICE_CFG,
  5. 					    IORESOURCE_IO | IORESOURCE_MEM,
  6. 					    &mdev->modern_bars);

从（QEMU源码）virtio_pci_realize函数中可以知道这个modern_bars是1<<4，如下图所示：

12d4462772a8ce7ecaffdf9106e27af5.png

（4）接着，pci_request_selected_regions函数就将virtio PCI代理设备的BAR地址空间保留出来了。代码片段如下： 

  1.     err = pci_request_selected_regions(pci_dev, mdev->modern_bars,
  2. 					   "virtio-pci-modern");
  3. 	if (err)
  4. 		return err;

（5）调用vp_modern_map_capability函数将对应的capability在PCI代理设备中的BAR空间映射到内核地址空间。代码片段如下： 

  1.     err = -EINVAL;
  2. 	mdev->common = vp_modern_map_capability(mdev, common,
  3. 				      sizeof(struct virtio_pci_common_cfg), 4,
  4. 				      0, sizeof(struct virtio_pci_common_cfg),
  5. 				      NULL, NULL);
  6. 	if (!mdev->common)
  7. 		goto err_map_common;
  8. 	mdev->isr = vp_modern_map_capability(mdev, isr, sizeof(u8), 1,
  9. 					     0, 1,
  10. 					     NULL, NULL);
  11. 	if (!mdev->isr)
  12. 		goto err_map_isr;
  13.  
  14. 	/* Read notify_off_multiplier from config space. */
  15. 	pci_read_config_dword(pci_dev,
  16. 			      notify + offsetof(struct virtio_pci_notify_cap,
  17. 						notify_off_multiplier),
  18. 			      &mdev->notify_offset_multiplier);
  19. 	/* Read notify length and offset from config space. */
  20. 	pci_read_config_dword(pci_dev,
  21. 			      notify + offsetof(struct virtio_pci_notify_cap,
  22. 						cap.length),
  23. 			      &notify_length);
  24.  
  25. 	pci_read_config_dword(pci_dev,
  26. 			      notify + offsetof(struct virtio_pci_notify_cap,
  27. 						cap.offset),
  28. 			      &notify_offset);
  29.  
  30. 	/* We don't know how many VQs we'll map, ahead of the time.
  31. 	 * If notify length is small, map it all now.
  32. 	 * Otherwise, map each VQ individually later.
  33. 	 */
  34. 	if ((u64)notify_length + (notify_offset % PAGE_SIZE) <= PAGE_SIZE) {
  35. 		mdev->notify_base = vp_modern_map_capability(mdev, notify,
  36. 							     2, 2,
  37. 							     0, notify_length,
  38. 							     &mdev->notify_len,
  39. 							     &mdev->notify_pa);
  40. 		if (!mdev->notify_base)
  41. 			goto err_map_notify;
  42. 	} else {
  43. 		mdev->notify_map_cap = notify;
  44. 	}
  45.  
  46. 	/* Again, we don't know how much we should map, but PAGE_SIZE
  47. 	 * is more than enough for all existing devices.
  48. 	 */
  49. 	if (device) {
  50. 		mdev->device = vp_modern_map_capability(mdev, device, 0, 4,
  51. 							0, PAGE_SIZE,
  52. 							&mdev->device_len,
  53. 							NULL);
  54. 		if (!mdev->device)
  55. 			goto err_map_device;
  56. 	}

如mp_dev（struct virtio_pci_modern_device *mdev = &vp_dev->mdev;）的common成员映射了virtio_pci_common_cfg的数据到内核中。这样，后续就可以直接通过这个内存地址空间来访问common这一capability了，其它的capability（isr、notify、device）也与此类似。

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

  1. /*
  2.  * vp_modern_map_capability - map a part of virtio pci capability
  3.  * @mdev: the modern virtio-pci device
  4.  * @off: offset of the capability
  5.  * @minlen: minimal length of the capability
  6.  * @align: align requirement
  7.  * @start: start from the capability
  8.  * @size: map size
  9.  * @len: the length that is actually mapped
  10.  * @pa: physical address of the capability
  11.  *
  12.  * Returns the io address of for the part of the capability
  13.  */
  14. static void __iomem *
  15. vp_modern_map_capability(struct virtio_pci_modern_device *mdev, int off,
  16. 			 size_t minlen, u32 align, u32 start, u32 size,
  17. 			 size_t *len, resource_size_t *pa)
  18. {
  19. 	struct pci_dev *dev = mdev->pci_dev;
  20. 	u8 bar;
  21. 	u32 offset, length;
  22. 	void __iomem *p;
  23.  
  24. 	pci_read_config_byte(dev, off + offsetof(struct virtio_pci_cap,
  25. 						 bar),
  26. 			     &bar);
  27. 	pci_read_config_dword(dev, off + offsetof(struct virtio_pci_cap, offset),
  28. 			     &offset);
  29. 	pci_read_config_dword(dev, off + offsetof(struct virtio_pci_cap, length),
  30. 			      &length);
  31.  
  32. 	/* Check if the BAR may have changed since we requested the region. */
  33. 	if (bar >= PCI_STD_NUM_BARS || !(mdev->modern_bars & (1 << bar))) {
  34. 		dev_err(&dev->dev,
  35. 			"virtio_pci: bar unexpectedly changed to %u\n", bar);
  36. 		return NULL;
  37. 	}
  38.  
  39. 	if (length <= start) {
  40. 		dev_err(&dev->dev,
  41. 			"virtio_pci: bad capability len %u (>%u expected)\n",
  42. 			length, start);
  43. 		return NULL;
  44. 	}
  45.  
  46. 	if (length - start < minlen) {
  47. 		dev_err(&dev->dev,
  48. 			"virtio_pci: bad capability len %u (>=%zu expected)\n",
  49. 			length, minlen);
  50. 		return NULL;
  51. 	}
  52.  
  53. 	length -= start;
  54.  
  55. 	if (start + offset < offset) {
  56. 		dev_err(&dev->dev,
  57. 			"virtio_pci: map wrap-around %u+%u\n",
  58. 			start, offset);
  59. 		return NULL;
  60. 	}
  61.  
  62. 	offset += start;
  63.  
  64. 	if (offset & (align - 1)) {
  65. 		dev_err(&dev->dev,
  66. 			"virtio_pci: offset %u not aligned to %u\n",
  67. 			offset, align);
  68. 		return NULL;
  69. 	}
  70.  
  71. 	if (length > size)
  72. 		length = size;
  73.  
  74. 	if (len)
  75. 		*len = length;
  76.  
  77. 	if (minlen + offset < minlen ||
  78. 	    minlen + offset > pci_resource_len(dev, bar)) {
  79. 		dev_err(&dev->dev,
  80. 			"virtio_pci: map virtio %zu@%u "
  81. 			"out of range on bar %i length %lu\n",
  82. 			minlen, offset,
  83. 			bar, (unsigned long)pci_resource_len(dev, bar));
  84. 		return NULL;
  85. 	}
  86.  
  87. 	p = pci_iomap_range(dev, bar, offset, length);
  88. 	if (!p)
  89. 		dev_err(&dev->dev,
  90. 			"virtio_pci: unable to map virtio %u@%u on bar %i\n",
  91. 			length, offset, bar);
  92. 	else if (pa)
  93. 		*pa = pci_resource_start(dev, bar) + offset;
  94.  
  95. 	return p;
  96. }

这样实际上就将virtio PCI代理设备的BAR映射到 虚拟机 内核地址空间了，后续直接访问这些地址即可实现对virtio PCI代理设备的配置和控制。

回到virtio_pci_modern_probe函数。 

  1. /* the PCI probing function */
  2. int virtio_pci_modern_probe(struct virtio_pci_device *vp_dev)
  3. {
  4. 	struct virtio_pci_modern_device *mdev = &vp_dev->mdev;
  5. 	struct pci_dev *pci_dev = vp_dev->pci_dev;
  6. 	int err;
  7.  
  8. 	mdev->pci_dev = pci_dev;
  9.  
  10. 	err = vp_modern_probe(mdev);
  11. 	if (err)
  12. 		return err;
  13.  
  14. 	if (mdev->device)
  15. 		vp_dev->vdev.config = &virtio_pci_config_ops;
  16. 	else
  17. 		vp_dev->vdev.config = &virtio_pci_config_nodev_ops;
  18.  
  19. 	vp_dev->config_vector = vp_config_vector;
  20. 	vp_dev->setup_vq = setup_vq;
  21. 	vp_dev->del_vq = del_vq;
  22. 	vp_dev->isr = mdev->isr;
  23. 	vp_dev->vdev.id = mdev->id;
  24.  
  25. 	return 0;
  26. }

在调用完vp_modern_probe函数之后，virtio_pci_modern_probe函数接着设置virtio_pci_device中virtio_device的成员vdev的config成员。如果有device这一capability，则设置为virtio_pci_config_ops，否则设置为virtio_pci_config_nodev_ops。

之后设置vpdev即struct virtio_pci_device的几个回调函数：config_vector与MSI中断有关，设置为vp_config_vector；setup_vq用来配置virtio设备virt queue，设置为setup_vq；del_vq用来删除virt queue，设置为del_vq。

至此，virtio_pci_modern_probe函数就解析完了。

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

举报

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

取消

确定