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

已于 2024-02-21 09:34:58 修改
阅读量1k 收藏 26
点赞数 26
分类专栏： KVM QEMU/KVM 文章标签： QEMU KVM virtio
于 2024-02-21 09:09:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接： https://blog.csdn.net/phmatthaus/article/details/136196211
版权
QEMU/KVM 同时被 2 个专栏收录
123 篇文章 36 订阅 ¥49.90 ¥99.00
已订阅 8折续费
KVM
88 篇文章 19 订阅
订阅专栏
您已是超级会员，正在免费阅读会员专享内容
查看更多超级会员权益
本文详细回顾和总结了virtio驱动在QEMU中的初始化过程，包括设备重置、状态位设置、特性协商等关键步骤，涉及Linux内核源码的相关函数和流程。
摘要由CSDN通过智能技术生成

接前一篇文章： QEMU源码全解析 —— virtio（20）

从开始 QEMU源码全解析 —— virtio（17） 到 QEMU源码全解析 —— virtio（20） ，用4篇文章讲解了 virtio 驱动的加载过程，本回来回顾和复习一下。

一般来讲，virtio驱动初始化一个设备的过程如下：

（1）重置设备

这是在上一回所讲的register_virtio_device函数中通过dev->config->reset调用完成的。这里要注意，老版本中调用的是dev->config->reset()，而新版本中直接使用virtio_reset_device函数。该函数在 Linux 内核源码/drivers/virtio/virtio.c中，代码如下： 

  1. /**
  2.  * virtio_reset_device - quiesce device for removal
  3.  * @dev: the device to reset
  4.  *
  5.  * Prevents device from sending interrupts and accessing memory.
  6.  *
  7.  * Generally used for cleanup during driver / device removal.
  8.  *
  9.  * Once this has been invoked, caller must ensure that
  10.  * virtqueue_notify / virtqueue_kick are not in progress.
  11.  *
  12.  * Note: this guarantees that vq callbacks are not in progress, however caller
  13.  * is responsible for preventing access from other contexts, such as a system
  14.  * call/workqueue/bh.  Invoking virtio_break_device then flushing any such
  15.  * contexts is one way to handle that.
  16.  * */
  17. void virtio_reset_device(struct virtio_device *dev)
  18. {
  19. #ifdef CONFIG_VIRTIO_HARDEN_NOTIFICATION
  20. 	/*
  21. 	 * The below virtio_synchronize_cbs() guarantees that any
  22. 	 * interrupt for this line arriving after
  23. 	 * virtio_synchronize_vqs() has completed is guaranteed to see
  24. 	 * vq->broken as true.
  25. 	 */
  26. 	virtio_break_device(dev);
  27. 	virtio_synchronize_cbs(dev);
  28. #endif
  29.  
  30. 	dev->config->reset(dev);
  31. }
  32. EXPORT_SYMBOL_GPL(virtio_reset_device);

可以看到，实际上virtio_reset_device函数可以说是了dev->config->reset()的简单封装，只是多了一些额外的配置选项及该选项下的相关处理。

（2）设置ACKNOWLEDGE状态位

设置ACKNOWLEDGE状态位，表示virtio驱动已经知道了该设备。这同样是在register_virtio_device函数中由virtio_add_status()函数完成的，代码片段如下： 

  1.     /* We always start by resetting the device, in case a previous
  2. 	 * driver messed it up.  This also tests that code path a little. */
  3. 	virtio_reset_device(dev);
  4.  
  5. 	/* Acknowledge that we've seen the device. */
  6. 	virtio_add_status(dev, VIRTIO_CONFIG_S_ACKNOWLEDGE);

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

  1. void virtio_add_status(struct virtio_device *dev, unsigned int status)
  2. {
  3. 	might_sleep();
  4. 	dev->config->set_status(dev, dev->config->get_status(dev) | status);
  5. }
  6. EXPORT_SYMBOL_GPL(virtio_add_status);

（3）设置DRIVER状态位

设置DRIVER状态位，表示virtio驱动知道怎样驱动该设备。这是在virtio总线的probe函数virtio_dev_probe中，通过virtio_add_status函数完成的。virtio_dev_probe函数在Linux内核源码/drivers/virtio/virtio.c中，代码如下： 

  1. static struct bus_type virtio_bus = {
  2. 	.name  = "virtio",
  3. 	.match = virtio_dev_match,
  4. 	.dev_groups = virtio_dev_groups,
  5. 	.uevent = virtio_uevent,
  6. 	.probe = virtio_dev_probe,
  7. 	.remove = virtio_dev_remove,
  8. };
  9.  
  10. int register_virtio_driver(struct virtio_driver *driver)
  11. {
  12. 	/* Catch this early. */
  13. 	BUG_ON(driver->feature_table_size && !driver->feature_table);
  14. 	driver->driver.bus = &virtio_bus;
  15. 	return driver_register(&driver->driver);
  16. }
  17. EXPORT_SYMBOL_GPL(register_virtio_driver);
  1. static int virtio_dev_probe(struct device *_d)
  2. {
  3. 	int err, i;
  4. 	struct virtio_device *dev = dev_to_virtio(_d);
  5. 	struct virtio_driver *drv = drv_to_virtio(dev->dev.driver);
  6. 	u64 device_features;
  7. 	u64 driver_features;
  8. 	u64 driver_features_legacy;
  9.  
  10. 	/* We have a driver! */
  11. 	virtio_add_status(dev, VIRTIO_CONFIG_S_DRIVER);
  12.  
  13. 	/* Figure out what features the device supports. */
  14. 	device_features = dev->config->get_features(dev);
  15.  
  16. 	/* Figure out what features the driver supports. */
  17. 	driver_features = 0;
  18. 	for (i = 0; i < drv->feature_table_size; i++) {
  19. 		unsigned int f = drv->feature_table[i];
  20. 		BUG_ON(f >= 64);
  21. 		driver_features |= (1ULL << f);
  22. 	}
  23.  
  24. 	/* Some drivers have a separate feature table for virtio v1.0 */
  25. 	if (drv->feature_table_legacy) {
  26. 		driver_features_legacy = 0;
  27. 		for (i = 0; i < drv->feature_table_size_legacy; i++) {
  28. 			unsigned int f = drv->feature_table_legacy[i];
  29. 			BUG_ON(f >= 64);
  30. 			driver_features_legacy |= (1ULL << f);
  31. 		}
  32. 	} else {
  33. 		driver_features_legacy = driver_features;
  34. 	}
  35.  
  36. 	if (device_features & (1ULL << VIRTIO_F_VERSION_1))
  37. 		dev->features = driver_features & device_features;
  38. 	else
  39. 		dev->features = driver_features_legacy & device_features;
  40.  
  41. 	/* Transport features always preserved to pass to finalize_features. */
  42. 	for (i = VIRTIO_TRANSPORT_F_START; i < VIRTIO_TRANSPORT_F_END; i++)
  43. 		if (device_features & (1ULL << i))
  44. 			__virtio_set_bit(dev, i);
  45.  
  46. 	err = dev->config->finalize_features(dev);
  47. 	if (err)
  48. 		goto err;
  49.  
  50. 	if (drv->validate) {
  51. 		u64 features = dev->features;
  52.  
  53. 		err = drv->validate(dev);
  54. 		if (err)
  55. 			goto err;
  56.  
  57. 		/* Did validation change any features? Then write them again. */
  58. 		if (features != dev->features) {
  59. 			err = dev->config->finalize_features(dev);
  60. 			if (err)
  61. 				goto err;
  62. 		}
  63. 	}
  64.  
  65. 	err = virtio_features_ok(dev);
  66. 	if (err)
  67. 		goto err;
  68.  
  69. 	err = drv->probe(dev);
  70. 	if (err)
  71. 		goto err;
  72.  
  73. 	/* If probe didn't do it, mark device DRIVER_OK ourselves. */
  74. 	if (!(dev->config->get_status(dev) & VIRTIO_CONFIG_S_DRIVER_OK))
  75. 		virtio_device_ready(dev);
  76.  
  77. 	if (drv->scan)
  78. 		drv->scan(dev);
  79.  
  80. 	virtio_config_enable(dev);
  81.  
  82. 	return 0;
  83. err:
  84. 	virtio_add_status(dev, VIRTIO_CONFIG_S_FAILED);
  85. 	return err;
  86.  
  87. }

关键代码片段为： 

  1. 	/* We have a driver! */
  2. 	virtio_add_status(dev, VIRTIO_CONFIG_S_DRIVER);

（4）读取virtio设备的feature位，求出驱动设置的feature

读取virtio设备的feature位，求出驱动设置的feature。这也是在上边的virtio_dev_probe函数中完成的，代码片段如下： 

  1. 	/* Figure out what features the device supports. */
  2. 	device_features = dev->config->get_features(dev);
  3.  
  4. 	/* Figure out what features the driver supports. */
  5. 	driver_features = 0;
  6. 	for (i = 0; i < drv->feature_table_size; i++) {
  7. 		unsigned int f = drv->feature_table[i];
  8. 		BUG_ON(f >= 64);
  9. 		driver_features |= (1ULL << f);
  10. 	}
  11.  
  12. 	/* Some drivers have a separate feature table for virtio v1.0 */
  13. 	if (drv->feature_table_legacy) {
  14. 		driver_features_legacy = 0;
  15. 		for (i = 0; i < drv->feature_table_size_legacy; i++) {
  16. 			unsigned int f = drv->feature_table_legacy[i];
  17. 			BUG_ON(f >= 64);
  18. 			driver_features_legacy |= (1ULL << f);
  19. 		}
  20. 	} else {
  21. 		driver_features_legacy = driver_features;
  22. 	}

（5）将两者（virtio设备的feature和驱动设置的feature）计算子集

将两者（virtio设备的feature和驱动设置的feature）计算子集。这也是在上边的virtio_dev_probe函数中完成的，代码片段如下： 

  1. 	if (device_features & (1ULL << VIRTIO_F_VERSION_1))
  2. 		dev->features = driver_features & device_features;
  3. 	else
  4. 		dev->features = driver_features_legacy & device_features;

（6）向设备写入此子集特性

计算virtio设备的feature和驱动设置的feature的子集后，向设备写入这个子集特性。这也是在上边的virtio_dev_probe函数中完成的，代码片段如下： 

  1.     /* Transport features always preserved to pass to finalize_features. */
  2. 	for (i = VIRTIO_TRANSPORT_F_START; i < VIRTIO_TRANSPORT_F_END; i++)
  3. 		if (device_features & (1ULL << i))
  4. 			__virtio_set_bit(dev, i);
  5.  
  6. 	err = dev->config->finalize_features(dev);
  7. 	if (err)
  8. 		goto err;

计算driver_features和device_features，然后调用virtio_finalize_features。

（7）设置FEATURES_OK特性位

设置FEATURES_OK特性位，在此之后，virtio驱动就不会再接收新的特性了。这也是在上边的virtio_dev_probe函数中完成的，代码片段如下： 

  1. 	err = virtio_features_ok(dev);
  2. 	if (err)
  3. 		goto err;

这一步是在virtio_features_ok函数中通过调用virtio_add_status函数完成的。virtio_features_ok函数也在Linux内核源码/drivers/virtio/virtio.c中，代码如下： 

  1. /* Do some validation, then set FEATURES_OK */
  2. static int virtio_features_ok(struct virtio_device *dev)
  3. {
  4. 	unsigned int status;
  5.  
  6. 	might_sleep();
  7.  
  8. 	if (virtio_check_mem_acc_cb(dev)) {
  9. 		if (!virtio_has_feature(dev, VIRTIO_F_VERSION_1)) {
  10. 			dev_warn(&dev->dev,
  11. 				 "device must provide VIRTIO_F_VERSION_1\n");
  12. 			return -ENODEV;
  13. 		}
  14.  
  15. 		if (!virtio_has_feature(dev, VIRTIO_F_ACCESS_PLATFORM)) {
  16. 			dev_warn(&dev->dev,
  17. 				 "device must provide VIRTIO_F_ACCESS_PLATFORM\n");
  18. 			return -ENODEV;
  19. 		}
  20. 	}
  21.  
  22. 	if (!virtio_has_feature(dev, VIRTIO_F_VERSION_1))
  23. 		return 0;
  24.  
  25. 	virtio_add_status(dev, VIRTIO_CONFIG_S_FEATURES_OK);
  26. 	status = dev->config->get_status(dev);
  27. 	if (!(status & VIRTIO_CONFIG_S_FEATURES_OK)) {
  28. 		dev_err(&dev->dev, "virtio: device refuses features: %x\n",
  29. 			status);
  30. 		return -ENODEV;
  31. 	}
  32. 	return 0;
  33. }

上边提到的关键代码片段为： 

    virtio_add_status(dev, VIRTIO_CONFIG_S_FEATURES_OK);

（8）重新读取设备的feature位

重新读取设备的feature位，确保设置了VIRTIO_CONFIG_S_FEATURES_OK。代码片段如下： 

  1. 	status = dev->config->get_status(dev);
  2. 	if (!(status & VIRTIO_CONFIG_S_FEATURES_OK)) {
  3. 		dev_err(&dev->dev, "virtio: device refuses features: %x\n",
  4. 			status);
  5. 		return -ENODEV;
  6. 	}

如果并没有设置成功，则设备不支持virtio驱动设置的一些状态，表示设备不可用。这同样是在virtio_features_ok函数中完成的。

（9）执行设备相关的初始化操作

执行设备相关的 初始化操作 ，包括发现设备的virtqueue、读写virtio设备的配置空间等。这些都是在virtio_dev_probe函数中通过调用驱动的probe函数（即drv->probe(dev)）完成的。代码片段如下： 

  1. 	err = drv->probe(dev);
  2. 	if (err)
  3. 		goto err;

对于virtio balloon来说是virtballoon_probe函数。该函数在Linux内核源码/drivers/virtio/virtio_balloon.c中，代码如下： 

  1. static int virtballoon_probe(struct virtio_device *vdev)
  2. {
  3. 	struct virtio_balloon *vb;
  4. 	int err;
  5.  
  6. 	if (!vdev->config->get) {
  7. 		dev_err(&vdev->dev, "%s failure: config access disabled\n",
  8. 			__func__);
  9. 		return -EINVAL;
  10. 	}
  11.  
  12. 	vdev->priv = vb = kzalloc(sizeof(*vb), GFP_KERNEL);
  13. 	if (!vb) {
  14. 		err = -ENOMEM;
  15. 		goto out;
  16. 	}
  17.  
  18. 	INIT_WORK(&vb->update_balloon_stats_work, update_balloon_stats_func);
  19. 	INIT_WORK(&vb->update_balloon_size_work, update_balloon_size_func);
  20. 	spin_lock_init(&vb->stop_update_lock);
  21. 	mutex_init(&vb->balloon_lock);
  22. 	init_waitqueue_head(&vb->acked);
  23. 	vb->vdev = vdev;
  24.  
  25. 	balloon_devinfo_init(&vb->vb_dev_info);
  26.  
  27. 	err = init_vqs(vb);
  28. 	if (err)
  29. 		goto out_free_vb;
  30.  
  31. #ifdef CONFIG_BALLOON_COMPACTION
  32. 	vb->vb_dev_info.migratepage = virtballoon_migratepage;
  33. #endif
  34. 	if (virtio_has_feature(vdev, VIRTIO_BALLOON_F_FREE_PAGE_HINT)) {
  35. 		/*
  36. 		 * There is always one entry reserved for cmd id, so the ring
  37. 		 * size needs to be at least two to report free page hints.
  38. 		 */
  39. 		if (virtqueue_get_vring_size(vb->free_page_vq) < 2) {
  40. 			err = -ENOSPC;
  41. 			goto out_del_vqs;
  42. 		}
  43. 		vb->balloon_wq = alloc_workqueue("balloon-wq",
  44. 					WQ_FREEZABLE | WQ_CPU_INTENSIVE, 0);
  45. 		if (!vb->balloon_wq) {
  46. 			err = -ENOMEM;
  47. 			goto out_del_vqs;
  48. 		}
  49. 		INIT_WORK(&vb->report_free_page_work, report_free_page_func);
  50. 		vb->cmd_id_received_cache = VIRTIO_BALLOON_CMD_ID_STOP;
  51. 		vb->cmd_id_active = cpu_to_virtio32(vb->vdev,
  52. 						  VIRTIO_BALLOON_CMD_ID_STOP);
  53. 		vb->cmd_id_stop = cpu_to_virtio32(vb->vdev,
  54. 						  VIRTIO_BALLOON_CMD_ID_STOP);
  55. 		spin_lock_init(&vb->free_page_list_lock);
  56. 		INIT_LIST_HEAD(&vb->free_page_list);
  57. 		/*
  58. 		 * We're allowed to reuse any free pages, even if they are
  59. 		 * still to be processed by the host.
  60. 		 */
  61. 		err = virtio_balloon_register_shrinker(vb);
  62. 		if (err)
  63. 			goto out_del_balloon_wq;
  64. 	}
  65.  
  66. 	if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_DEFLATE_ON_OOM)) {
  67. 		vb->oom_nb.notifier_call = virtio_balloon_oom_notify;
  68. 		vb->oom_nb.priority = VIRTIO_BALLOON_OOM_NOTIFY_PRIORITY;
  69. 		err = register_oom_notifier(&vb->oom_nb);
  70. 		if (err < 0)
  71. 			goto out_unregister_shrinker;
  72. 	}
  73.  
  74. 	if (virtio_has_feature(vdev, VIRTIO_BALLOON_F_PAGE_POISON)) {
  75. 		/* Start with poison val of 0 representing general init */
  76. 		__u32 poison_val = 0;
  77.  
  78. 		/*
  79. 		 * Let the hypervisor know that we are expecting a
  80. 		 * specific value to be written back in balloon pages.
  81. 		 *
  82. 		 * If the PAGE_POISON value was larger than a byte we would
  83. 		 * need to byte swap poison_val here to guarantee it is
  84. 		 * little-endian. However for now it is a single byte so we
  85. 		 * can pass it as-is.
  86. 		 */
  87. 		if (!want_init_on_free())
  88. 			memset(&poison_val, PAGE_POISON, sizeof(poison_val));
  89.  
  90. 		virtio_cwrite_le(vb->vdev, struct virtio_balloon_config,
  91. 				 poison_val, &poison_val);
  92. 	}
  93.  
  94. 	vb->pr_dev_info.report = virtballoon_free_page_report;
  95. 	if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_REPORTING)) {
  96. 		unsigned int capacity;
  97.  
  98. 		capacity = virtqueue_get_vring_size(vb->reporting_vq);
  99. 		if (capacity < PAGE_REPORTING_CAPACITY) {
  100. 			err = -ENOSPC;
  101. 			goto out_unregister_oom;
  102. 		}
  103.  
  104. 		/*
  105. 		 * The default page reporting order is @pageblock_order, which
  106. 		 * corresponds to 512MB in size on ARM64 when 64KB base page
  107. 		 * size is used. The page reporting won't be triggered if the
  108. 		 * freeing page can't come up with a free area like that huge.
  109. 		 * So we specify the page reporting order to 5, corresponding
  110. 		 * to 2MB. It helps to avoid THP splitting if 4KB base page
  111. 		 * size is used by host.
  112. 		 *
  113. 		 * Ideally, the page reporting order is selected based on the
  114. 		 * host's base page size. However, it needs more work to report
  115. 		 * that value. The hard-coded order would be fine currently.
  116. 		 */
  117. #if defined(CONFIG_ARM64) && defined(CONFIG_ARM64_64K_PAGES)
  118. 		vb->pr_dev_info.order = 5;
  119. #endif
  120.  
  121. 		err = page_reporting_register(&vb->pr_dev_info);
  122. 		if (err)
  123. 			goto out_unregister_oom;
  124. 	}
  125.  
  126. 	virtio_device_ready(vdev);
  127.  
  128. 	if (towards_target(vb))
  129. 		virtballoon_changed(vdev);
  130. 	return 0;
  131.  
  132. out_unregister_oom:
  133. 	if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_DEFLATE_ON_OOM))
  134. 		unregister_oom_notifier(&vb->oom_nb);
  135. out_unregister_shrinker:
  136. 	if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_FREE_PAGE_HINT))
  137. 		virtio_balloon_unregister_shrinker(vb);
  138. out_del_balloon_wq:
  139. 	if (virtio_has_feature(vdev, VIRTIO_BALLOON_F_FREE_PAGE_HINT))
  140. 		destroy_workqueue(vb->balloon_wq);
  141. out_del_vqs:
  142. 	vdev->config->del_vqs(vdev);
  143. out_free_vb:
  144. 	kfree(vb);
  145. out:
  146. 	return err;
  147. }

（10）设置DRIVER_OK状态位

设置DRIVER_OK状态位，这通常是在具体设备驱动的probe函数中，通过调用virtio_device_ready函数完成的。对于virtio ballon设备来说，就是上边的virtballoon_probe函数。代码片段如下： 

    virtio_device_ready(vdev);

virtio_device_ready函数在Linux内核源码/include/linux/virtio_config.h中，代码如下： 

  1. /**
  2.  * virtio_device_ready - enable vq use in probe function
  3.  * @dev: the virtio device
  4.  *
  5.  * Driver must call this to use vqs in the probe function.
  6.  *
  7.  * Note: vqs are enabled automatically after probe returns.
  8.  */
  9. static inline
  10. void virtio_device_ready(struct virtio_device *dev)
  11. {
  12. 	unsigned status = dev->config->get_status(dev);
  13.  
  14. 	WARN_ON(status & VIRTIO_CONFIG_S_DRIVER_OK);
  15.  
  16. #ifdef CONFIG_VIRTIO_HARDEN_NOTIFICATION
  17. 	/*
  18. 	 * The virtio_synchronize_cbs() makes sure vring_interrupt()
  19. 	 * will see the driver specific setup if it sees vq->broken
  20. 	 * as false (even if the notifications come before DRIVER_OK).
  21. 	 */
  22. 	virtio_synchronize_cbs(dev);
  23. 	__virtio_unbreak_device(dev);
  24. #endif
  25. 	/*
  26. 	 * The transport should ensure the visibility of vq->broken
  27. 	 * before setting DRIVER_OK. See the comments for the transport
  28. 	 * specific set_status() method.
  29. 	 *
  30. 	 * A well behaved device will only notify a virtqueue after
  31. 	 * DRIVER_OK, this means the device should "see" the coherenct
  32. 	 * memory write that set vq->broken as false which is done by
  33. 	 * the driver when it sees DRIVER_OK, then the following
  34. 	 * driver's vring_interrupt() will see vq->broken as false so
  35. 	 * we won't lose any notification.
  36. 	 */
  37. 	dev->config->set_status(dev, status | VIRTIO_CONFIG_S_DRIVER_OK);
  38. }

如果设备驱动没有设置DRIVER_OK状态位，则会由总线的probe函数virtio_dev_probe函数来设置。这也是在上边的virtio_dev_probe函数中完成的，代码片段如下： 

  1. 	/* If probe didn't do it, mark device DRIVER_OK ourselves. */
  2. 	if (!(dev->config->get_status(dev) & VIRTIO_CONFIG_S_DRIVER_OK))
  3. 		virtio_device_ready(dev);

至此，virtio驱动的加载就基本讲解完了。下一回开始讲解virtio驱动的初始化。

举报

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

取消

确定