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

于 2024-02-25 08:24:16 发布
阅读量907 收藏 19
点赞数 28
分类专栏： KVM QEMU/KVM 文章标签： QEMU KVM virtio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接： https://blog.csdn.net/phmatthaus/article/details/136268301
版权
QEMU/KVM 同时被 2 个专栏收录
123 篇文章 36 订阅 ¥49.90 ¥99.00
已订阅 8折续费
KVM
88 篇文章 19 订阅
订阅专栏
您已是超级会员，正在免费阅读会员专享内容
查看更多超级会员权益
本文深入解析QEMU中的virtio balloon设备初始化过程，通过virtio_balloon_probe函数，详细介绍如何分配和初始化virtio_balloon结构，以及如何通过init_vqs函数设置virtqueue和vring，实现virtio驱动与设备的数据通信。文章还涉及virtio_device_ready和virtio_has_feature等关键函数的作用。
摘要由CSDN通过智能技术生成

接前一篇文章：

本回开始以 virtio balloon设备的初始化过程为例，分析virtio设备的初始化过程，即前文书（ QEMU源码全解析 —— virtio（21） ）所讲到的virtio驱动初始化设备的过程中的“（9）执行设备相关的 初始化操作 ”一步。

下边就以virtio balloon设备的初始化过程为例，分析virtio设备的初始化过程。再次贴出virtioballoon_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. }

virtio balloon设备用virtio_balloon结构表示，该结构在Linux内核源码/drivers/virtio/virtio_balloon.c中，定义如下： 

  1. struct virtio_balloon {
  2. 	struct virtio_device *vdev;
  3. 	struct virtqueue *inflate_vq, *deflate_vq, *stats_vq, *free_page_vq;
  4.  
  5. 	/* Balloon's own wq for cpu-intensive work items */
  6. 	struct workqueue_struct *balloon_wq;
  7. 	/* The free page reporting work item submitted to the balloon wq */
  8. 	struct work_struct report_free_page_work;
  9.  
  10. 	/* The balloon servicing is delegated to a freezable workqueue. */
  11. 	struct work_struct update_balloon_stats_work;
  12. 	struct work_struct update_balloon_size_work;
  13.  
  14. 	/* Prevent updating balloon when it is being canceled. */
  15. 	spinlock_t stop_update_lock;
  16. 	bool stop_update;
  17. 	/* Bitmap to indicate if reading the related config fields are needed */
  18. 	unsigned long config_read_bitmap;
  19.  
  20. 	/* The list of allocated free pages, waiting to be given back to mm */
  21. 	struct list_head free_page_list;
  22. 	spinlock_t free_page_list_lock;
  23. 	/* The number of free page blocks on the above list */
  24. 	unsigned long num_free_page_blocks;
  25. 	/*
  26. 	 * The cmd id received from host.
  27. 	 * Read it via virtio_balloon_cmd_id_received to get the latest value
  28. 	 * sent from host.
  29. 	 */
  30. 	u32 cmd_id_received_cache;
  31. 	/* The cmd id that is actively in use */
  32. 	__virtio32 cmd_id_active;
  33. 	/* Buffer to store the stop sign */
  34. 	__virtio32 cmd_id_stop;
  35.  
  36. 	/* Waiting for host to ack the pages we released. */
  37. 	wait_queue_head_t acked;
  38.  
  39. 	/* Number of balloon pages we've told the Host we're not using. */
  40. 	unsigned int num_pages;
  41. 	/*
  42. 	 * The pages we've told the Host we're not using are enqueued
  43. 	 * at vb_dev_info->pages list.
  44. 	 * Each page on this list adds VIRTIO_BALLOON_PAGES_PER_PAGE
  45. 	 * to num_pages above.
  46. 	 */
  47. 	struct balloon_dev_info vb_dev_info;
  48.  
  49. 	/* Synchronize access/update to this struct virtio_balloon elements */
  50. 	struct mutex balloon_lock;
  51.  
  52. 	/* The array of pfns we tell the Host about. */
  53. 	unsigned int num_pfns;
  54. 	__virtio32 pfns[VIRTIO_BALLOON_ARRAY_PFNS_MAX];
  55.  
  56. 	/* Memory statistics */
  57. 	struct virtio_balloon_stat stats[VIRTIO_BALLOON_S_NR];
  58.  
  59. 	/* Shrinker to return free pages - VIRTIO_BALLOON_F_FREE_PAGE_HINT */
  60. 	struct shrinker *shrinker;
  61.  
  62. 	/* OOM notifier to deflate on OOM - VIRTIO_BALLOON_F_DEFLATE_ON_OOM */
  63. 	struct notifier_block oom_nb;
  64.  
  65. 	/* Free page reporting device */
  66. 	struct virtqueue *reporting_vq;
  67. 	struct page_reporting_dev_info pr_dev_info;
  68. };

virtio_balloon结构（struct virtio_balloon）中存放了与该virtio balloon设备密切相关的数据成员。

（1）virtioballoon_probe函数首先分配了一个virtio_balloon结构对象，并赋值给vb，并且virio_device的priv也会保存该结构对象的地址 。代码片段如下： 

  1.     struct virtio_balloon *vb;
  2.     ……
  3.     vdev->priv = vb = kzalloc(sizeof(*vb), GFP_KERNEL);
  4. 	if (!vb) {
  5. 		err = -ENOMEM;
  6. 		goto out;
  7. 	}

（2）接着对分配的virtio_balloon对象的成员进行初始化 。这基本上就是该函数余下的代码了。其中有两个重要函数：init_vqs()和virtio_device_ready()。

virtio_device_ready函数同样在 QEMU源码全解析 —— virtio（21） 中已经讲过了，如下所示：

前一个函数init_vqs用于初始化virtqueue和vring，virtio驱动与virtio设备通过virtqueue进行数据通信。下边详细解析init_vqs函数。

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

  1. static int init_vqs(struct virtio_balloon *vb)
  2. {
  3. 	struct virtqueue *vqs[VIRTIO_BALLOON_VQ_MAX];
  4. 	vq_callback_t *callbacks[VIRTIO_BALLOON_VQ_MAX];
  5. 	const char *names[VIRTIO_BALLOON_VQ_MAX];
  6. 	int err;
  7.  
  8. 	/*
  9. 	 * Inflateq and deflateq are used unconditionally. The names[]
  10. 	 * will be NULL if the related feature is not enabled, which will
  11. 	 * cause no allocation for the corresponding virtqueue in find_vqs.
  12. 	 */
  13. 	callbacks[VIRTIO_BALLOON_VQ_INFLATE] = balloon_ack;
  14. 	names[VIRTIO_BALLOON_VQ_INFLATE] = "inflate";
  15. 	callbacks[VIRTIO_BALLOON_VQ_DEFLATE] = balloon_ack;
  16. 	names[VIRTIO_BALLOON_VQ_DEFLATE] = "deflate";
  17. 	callbacks[VIRTIO_BALLOON_VQ_STATS] = NULL;
  18. 	names[VIRTIO_BALLOON_VQ_STATS] = NULL;
  19. 	callbacks[VIRTIO_BALLOON_VQ_FREE_PAGE] = NULL;
  20. 	names[VIRTIO_BALLOON_VQ_FREE_PAGE] = NULL;
  21. 	names[VIRTIO_BALLOON_VQ_REPORTING] = NULL;
  22.  
  23. 	if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_STATS_VQ)) {
  24. 		names[VIRTIO_BALLOON_VQ_STATS] = "stats";
  25. 		callbacks[VIRTIO_BALLOON_VQ_STATS] = stats_request;
  26. 	}
  27.  
  28. 	if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_FREE_PAGE_HINT)) {
  29. 		names[VIRTIO_BALLOON_VQ_FREE_PAGE] = "free_page_vq";
  30. 		callbacks[VIRTIO_BALLOON_VQ_FREE_PAGE] = NULL;
  31. 	}
  32.  
  33. 	if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_REPORTING)) {
  34. 		names[VIRTIO_BALLOON_VQ_REPORTING] = "reporting_vq";
  35. 		callbacks[VIRTIO_BALLOON_VQ_REPORTING] = balloon_ack;
  36. 	}
  37.  
  38. 	err = virtio_find_vqs(vb->vdev, VIRTIO_BALLOON_VQ_MAX, vqs,
  39. 			      callbacks, names, NULL);
  40. 	if (err)
  41. 		return err;
  42.  
  43. 	vb->inflate_vq = vqs[VIRTIO_BALLOON_VQ_INFLATE];
  44. 	vb->deflate_vq = vqs[VIRTIO_BALLOON_VQ_DEFLATE];
  45. 	if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_STATS_VQ)) {
  46. 		struct scatterlist sg;
  47. 		unsigned int num_stats;
  48. 		vb->stats_vq = vqs[VIRTIO_BALLOON_VQ_STATS];
  49.  
  50. 		/*
  51. 		 * Prime this virtqueue with one buffer so the hypervisor can
  52. 		 * use it to signal us later (it can't be broken yet!).
  53. 		 */
  54. 		num_stats = update_balloon_stats(vb);
  55.  
  56. 		sg_init_one(&sg, vb->stats, sizeof(vb->stats[0]) * num_stats);
  57. 		err = virtqueue_add_outbuf(vb->stats_vq, &sg, 1, vb,
  58. 					   GFP_KERNEL);
  59. 		if (err) {
  60. 			dev_warn(&vb->vdev->dev, "%s: add stat_vq failed\n",
  61. 				 __func__);
  62. 			return err;
  63. 		}
  64. 		virtqueue_kick(vb->stats_vq);
  65. 	}
  66.  
  67. 	if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_FREE_PAGE_HINT))
  68. 		vb->free_page_vq = vqs[VIRTIO_BALLOON_VQ_FREE_PAGE];
  69.  
  70. 	if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_REPORTING))
  71. 		vb->reporting_vq = vqs[VIRTIO_BALLOON_VQ_REPORTING];
  72.  
  73. 	return 0;
  74. }

（1）init_vqs函数首先初始化callbacks指针数组和names指针数组 。代码片段如下： 

  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;

先来看一下VIRTIO_BALLOON_VQ_STATS的定义，同样Linux内核源码/drivers/virtio/virtio_balloon.c中，如下： 

  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. };

从定义中就能看出，VIRTIO_BALLOON_VQ_INFLATE的值为0，VIRTIO_BALLOON_VQ_DEFLATE的值为1，VIRTIO_BALLOON_VQ_STATS的值为2，VIRTIO_BALLOON_VQ_FREE_PAGE的值为3，VIRTIO_BALLOON_VQ_REPORTING的值为4，VIRTIO_BALLOON_VQ_MAX的值为5。

根据代码注释，indlateq和deflateq是无条件使用的。而如果相关feature未被使能，则相应的names[i]将为NULL，这将导致在find_vqs函数中不分配相应的virtqueue。

由注释就能够理解后边的代码了。由于indlateq和deflateq是无条件使用的，因此它们所对应的names[VIRTIO_BALLOON_VQ_INFLATE]（即names[0]）和names[VIRTIO_BALLOON_VQ_DEFLATE]（即names[1]）在一开始时就不是NULL，而分别是"inflate"和"deflate"。同时，各自的callback也均被设置为balloon_ack。

（2）接下来就是判断余下的VIRTIO_BALLOON_F_STATS_VQ、VIRTIO_BALLOON_VQ_FREE_PAGE、VIRTIO_BALLOON_VQ_REPORTING 特性是否存在 。代码片段如下： 

  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]和callbacks[i]都设置为了NULL。然后在这里对于相应特性是否使能进行判断，哪项使能了，就设置其names[i]为相应值，当然callbacks[i]也一样。

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

  1. /**
  2.  * virtio_has_feature - helper to determine if this device has this feature.
  3.  * @vdev: the device
  4.  * @fbit: the feature bit
  5.  */
  6. static inline bool virtio_has_feature(const struct virtio_device *vdev,
  7. 				      unsigned int fbit)
  8. {
  9. 	if (fbit < VIRTIO_TRANSPORT_F_START)
  10. 		virtio_check_driver_offered_feature(vdev, fbit);
  11.  
  12. 	return __virtio_test_bit(vdev, fbit);
  13. }

VIRTIO_TRANSPORT_F_START宏的定义在Linux内核源码/include/uapi/linux/virtio_config.h中，如下： 

  1. /*
  2.  * Virtio feature bits VIRTIO_TRANSPORT_F_START through
  3.  * VIRTIO_TRANSPORT_F_END are reserved for the transport
  4.  * being used (e.g. virtio_ring, virtio_pci etc.), the
  5.  * rest are per-device feature bits.
  6.  */
  7. #define VIRTIO_TRANSPORT_F_START	28
  8. #define VIRTIO_TRANSPORT_F_END		41

在这里，传给virtio_has_feature函数的参数fbit所对应的实参分别是VIRTIO_BALLOON_VQ_STATS（2）、VIRTIO_BALLOON_VQ_FREE_PAGE（3）、VIRTIO_BALLOON_VQ_REPORTING（4），都小于VIRTIO_TRANSPORT_F_START（28）。所以，都要经过virtio_check_driver_offered_feature函数。virtio_check_driver_offered_feature函数在Linux内核源码/drivers/virtio/virtio.c中，代码如下： 

  1. void virtio_check_driver_offered_feature(const struct virtio_device *vdev,
  2. 					 unsigned int fbit)
  3. {
  4. 	unsigned int i;
  5. 	struct virtio_driver *drv = drv_to_virtio(vdev->dev.driver);
  6.  
  7. 	for (i = 0; i < drv->feature_table_size; i++)
  8. 		if (drv->feature_table[i] == fbit)
  9. 			return;
  10.  
  11. 	if (drv->feature_table_legacy) {
  12. 		for (i = 0; i < drv->feature_table_size_legacy; i++)
  13. 			if (drv->feature_table_legacy[i] == fbit)
  14. 				return;
  15. 	}
  16.  
  17. 	BUG();
  18. }
  19. EXPORT_SYMBOL_GPL(virtio_check_driver_offered_feature);

virtio_check_driver_offered_feature函数检查vdev（struct virtio_device类型）所对应的drv（struct virtio_driver类型）的feature_table[]中是否有对应项，如果有，相安无事；如果没有，则报BUG()。

经过virtio_check_driver_offered_feature函数的检查后，virtio_has_feature函数调用__virtio_test_bit函数并返回了。__virtio_test_bit函数也在Linux内核源码/include/linux/virtio_config.h中，代码如下： 

  1. /**
  2.  * __virtio_test_bit - helper to test feature bits. For use by transports.
  3.  *                     Devices should normally use virtio_has_feature,
  4.  *                     which includes more checks.
  5.  * @vdev: the device
  6.  * @fbit: the feature bit
  7.  */
  8. static inline bool __virtio_test_bit(const struct virtio_device *vdev,
  9. 				     unsigned int fbit)
  10. {
  11. 	/* Did you forget to fix assumptions on max features? */
  12. 	if (__builtin_constant_p(fbit))
  13. 		BUILD_BUG_ON(fbit >= 64);
  14. 	else
  15. 		BUG_ON(fbit >= 64);
  16.  
  17. 	return vdev->features & BIT_ULL(fbit);
  18. }

这个函数比较好理解，就是检查vdev->feature中相应的bit位是否置1，如果置为了1，则说明该feature已经使能，返回真（True）；否则说明该feature未使能，返回假（False）。

回到init_vqs函数。在经过了对于各feature的初始化、检查和设置后，接下来init_vqs函数调用了virtio_find_vqs函数，对于该函数的解析，请看下回。

举报

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

取消

确定