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

已于 2024-02-21 10:24:40 修改
阅读量1.2k 收藏 15
点赞数 31
分类专栏： KVM QEMU/KVM 文章标签： QEMU KVM
于 2024-02-20 08:35:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接： https://blog.csdn.net/phmatthaus/article/details/135121566
版权
QEMU/KVM 同时被 2 个专栏收录
123 篇文章 36 订阅 ¥49.90 ¥99.00
已订阅 8折续费
KVM
88 篇文章 19 订阅
订阅专栏
您已是超级会员，正在免费阅读会员专享内容
查看更多超级会员权益
本文详细解析了QEMU源码中virtio设备的注册过程，包括virtio_pci_probe函数的执行、register_virtio_device函数的作用，以及在Linux内核中涉及的设备初始化、设置名称、重置设备、设备添加到系统等步骤。同时，介绍了device_register函数和device_add函数在设备注册中的角色，以及如何触发用户空间的udev加载对应驱动。
摘要由CSDN通过智能技术生成

接前一篇文章：

上回书重点解析了virtio_pci_modern_probe函数。再来回顾一下其中相关的数据结构：

  • struct virtio_pci_device

struct virtio_pci_device的定义在 Linux 内核源码/drivers/ virtio /virtio_pci_common.h中，如下： 

  1. /* Our device structure */
  2. struct virtio_pci_device {
  3. 	struct virtio_device vdev;
  4. 	struct pci_dev *pci_dev;
  5. 	union {
  6. 		struct virtio_pci_legacy_device ldev;
  7. 		struct virtio_pci_modern_device mdev;
  8. 	};
  9. 	bool is_legacy;
  10.  
  11. 	/* Where to read and clear interrupt */
  12. 	u8 __iomem *isr;
  13.  
  14. 	/* a list of queues so we can dispatch IRQs */
  15. 	spinlock_t lock;
  16. 	struct list_head virtqueues;
  17.  
  18. 	/* array of all queues for house-keeping */
  19. 	struct virtio_pci_vq_info **vqs;
  20.  
  21. 	/* MSI-X support */
  22. 	int msix_enabled;
  23. 	int intx_enabled;
  24. 	cpumask_var_t *msix_affinity_masks;
  25. 	/* Name strings for interrupts. This size should be enough,
  26. 	 * and I'm too lazy to allocate each name separately. */
  27. 	char (*msix_names)[256];
  28. 	/* Number of available vectors */
  29. 	unsigned int msix_vectors;
  30. 	/* Vectors allocated, excluding per-vq vectors if any */
  31. 	unsigned int msix_used_vectors;
  32.  
  33. 	/* Whether we have vector per vq */
  34. 	bool per_vq_vectors;
  35.  
  36. 	struct virtqueue *(*setup_vq)(struct virtio_pci_device *vp_dev,
  37. 				      struct virtio_pci_vq_info *info,
  38. 				      unsigned int idx,
  39. 				      void (*callback)(struct virtqueue *vq),
  40. 				      const char *name,
  41. 				      bool ctx,
  42. 				      u16 msix_vec);
  43. 	void (*del_vq)(struct virtio_pci_vq_info *info);
  44.  
  45. 	u16 (*config_vector)(struct virtio_pci_device *vp_dev, u16 vector);
  46. };

virtio_pci_modern_probe执行完成后，相关数据结构如下图所示：

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

  1. static int virtio_pci_probe(struct pci_dev *pci_dev,
  2. 			    const struct pci_device_id *id)
  3. {
  4. 	struct virtio_pci_device *vp_dev, *reg_dev = NULL;
  5. 	int rc;
  6.  
  7. 	/* allocate our structure and fill it out */
  8. 	vp_dev = kzalloc(sizeof(struct virtio_pci_device), GFP_KERNEL);
  9. 	if (!vp_dev)
  10. 		return -ENOMEM;
  11.  
  12. 	pci_set_drvdata(pci_dev, vp_dev);
  13. 	vp_dev->vdev.dev.parent = &pci_dev->dev;
  14. 	vp_dev->vdev.dev.release = virtio_pci_release_dev;
  15. 	vp_dev->pci_dev = pci_dev;
  16. 	INIT_LIST_HEAD(&vp_dev->virtqueues);
  17. 	spin_lock_init(&vp_dev->lock);
  18.  
  19. 	/* enable the device */
  20. 	rc = pci_enable_device(pci_dev);
  21. 	if (rc)
  22. 		goto err_enable_device;
  23.  
  24. 	if (force_legacy) {
  25. 		rc = virtio_pci_legacy_probe(vp_dev);
  26. 		/* Also try modern mode if we can't map BAR0 (no IO space). */
  27. 		if (rc == -ENODEV || rc == -ENOMEM)
  28. 			rc = virtio_pci_modern_probe(vp_dev);
  29. 		if (rc)
  30. 			goto err_probe;
  31. 	} else {
  32. 		rc = virtio_pci_modern_probe(vp_dev);
  33. 		if (rc == -ENODEV)
  34. 			rc = virtio_pci_legacy_probe(vp_dev);
  35. 		if (rc)
  36. 			goto err_probe;
  37. 	}
  38.  
  39. 	pci_set_master(pci_dev);
  40.  
  41. 	rc = register_virtio_device(&vp_dev->vdev);
  42. 	reg_dev = vp_dev;
  43. 	if (rc)
  44. 		goto err_register;
  45.  
  46. 	return 0;
  47.  
  48. err_register:
  49. 	if (vp_dev->is_legacy)
  50. 		virtio_pci_legacy_remove(vp_dev);
  51. 	else
  52. 		virtio_pci_modern_remove(vp_dev);
  53. err_probe:
  54. 	pci_disable_device(pci_dev);
  55. err_enable_device:
  56. 	if (reg_dev)
  57. 		put_device(&vp_dev->vdev.dev);
  58. 	else
  59. 		kfree(vp_dev);
  60. 	return rc;
  61. }

接 QEMU源码全解析 —— virtio（18） 中的内容，前文书讲到了virtio_pci_probe函数的第5步，

“（5）调用virtio_pci_legacy_probe或者virtio_pci_modern_probe函数来初始化该 PCI 设备对应的 virtio 设备。”，继续往下进行。

（6）virtio_pci_probe函数在调用virtio_pci_modern_probe函数之后，接下来会调用register_virtio_device。代码片段如下： 

  1. 	rc = register_virtio_device(&vp_dev->vdev);
  2. 	reg_dev = vp_dev;
  3. 	if (rc)
  4. 		goto err_register;

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

  1. /**
  2.  * register_virtio_device - register virtio device
  3.  * @dev        : virtio device to be registered
  4.  *
  5.  * On error, the caller must call put_device on &@dev->dev (and not kfree),
  6.  * as another code path may have obtained a reference to @dev.
  7.  *
  8.  * Returns: 0 on suceess, -error on failure
  9.  */
  10. int register_virtio_device(struct virtio_device *dev)
  11. {
  12. 	int err;
  13.  
  14. 	dev->dev.bus = &virtio_bus;
  15. 	device_initialize(&dev->dev);
  16.  
  17. 	/* Assign a unique device index and hence name. */
  18. 	err = ida_alloc(&virtio_index_ida, GFP_KERNEL);
  19. 	if (err < 0)
  20. 		goto out;
  21.  
  22. 	dev->index = err;
  23. 	err = dev_set_name(&dev->dev, "virtio%u", dev->index);
  24. 	if (err)
  25. 		goto out_ida_remove;
  26.  
  27. 	err = virtio_device_of_init(dev);
  28. 	if (err)
  29. 		goto out_ida_remove;
  30.  
  31. 	spin_lock_init(&dev->config_lock);
  32. 	dev->config_enabled = false;
  33. 	dev->config_change_pending = false;
  34.  
  35. 	INIT_LIST_HEAD(&dev->vqs);
  36. 	spin_lock_init(&dev->vqs_list_lock);
  37.  
  38. 	/* We always start by resetting the device, in case a previous
  39. 	 * driver messed it up.  This also tests that code path a little. */
  40. 	virtio_reset_device(dev);
  41.  
  42. 	/* Acknowledge that we've seen the device. */
  43. 	virtio_add_status(dev, VIRTIO_CONFIG_S_ACKNOWLEDGE);
  44.  
  45. 	/*
  46. 	 * device_add() causes the bus infrastructure to look for a matching
  47. 	 * driver.
  48. 	 */
  49. 	err = device_add(&dev->dev);
  50. 	if (err)
  51. 		goto out_of_node_put;
  52.  
  53. 	return 0;
  54.  
  55. out_of_node_put:
  56. 	of_node_put(dev->dev.of_node);
  57. out_ida_remove:
  58. 	ida_free(&virtio_index_ida, dev->index);
  59. out:
  60. 	virtio_add_status(dev, VIRTIO_CONFIG_S_FAILED);
  61. 	return err;
  62. }
  63. EXPORT_SYMBOL_GPL(register_virtio_device);

前文已提到，vp_dev->vdev的类型为struct virtio_device，而传给register_virtio_device函数的实参为vp_dev->vdev的地址，即&vp_dev->vdev。从函数名以及参数类型就能看出，register_virtio_device函数的作用是将一个virtio device注册到系统中。具体步骤如下：

（1）设置virtio设备的Bus为virtio_bus 。代码片段如下： 

    dev->dev.bus = &virtio_bus;

virtio_bus在系统初始化的时候会注册到系统中。

virtio_bus在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.  
  11. int register_virtio_driver(struct virtio_driver *driver)
  12. {
  13. 	/* Catch this early. */
  14. 	BUG_ON(driver->feature_table_size && !driver->feature_table);
  15. 	driver->driver.bus = &virtio_bus;
  16. 	return driver_register(&driver->driver);
  17. }
  18. EXPORT_SYMBOL_GPL(register_virtio_driver);

在系统初始化的时候，通过register_virtio_driver函数注册到系统中。

（2）设置virtio设备的名字为类似"virtio0"、"virtio1"的字符串 。代码片段如下： 

  1.     /* Assign a unique device index and hence name. */
  2. 	err = ida_alloc(&virtio_index_ida, GFP_KERNEL);
  3. 	if (err < 0)
  4. 		goto out;
  5.  
  6. 	dev->index = err;
  7. 	err = dev_set_name(&dev->dev, "virtio%u", dev->index);
  8. 	if (err)
  9. 		goto out_ida_remove;

dev_set_name函数在Linux内核源码/drivers/base/core.c中，代码如下： 

  1. /**
  2.  * dev_set_name - set a device name
  3.  * @dev: device
  4.  * @fmt: format string for the device's name
  5.  */
  6. int dev_set_name(struct device *dev, const char *fmt, ...)
  7. {
  8. 	va_list vargs;
  9. 	int err;
  10.  
  11. 	va_start(vargs, fmt);
  12. 	err = kobject_set_name_vargs(&dev->kobj, fmt, vargs);
  13. 	va_end(vargs);
  14. 	return err;
  15. }
  16. EXPORT_SYMBOL_GPL(dev_set_name);

（3）然后调用virtio_reset_device函数重置设备 。代码片段如下： 

  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）最后，调用device_add函数 ，将设备注册到系统中 。代码片段如下： 

  1.     /*
  2. 	 * device_add() causes the bus infrastructure to look for a matching
  3. 	 * driver.
  4. 	 */
  5. 	err = device_add(&dev->dev);
  6. 	if (err)
  7. 		goto out_of_node_put;

这里，老版本代码中是调用的是device_register函数。device_register函数跟设备驱动相关性较大，在此简单介绍一下其作用。

device_register函数在Linux内核源码/drivers/base/core.c中，代码如下： 

  1. /**
  2.  * device_register - register a device with the system.
  3.  * @dev: pointer to the device structure
  4.  *
  5.  * This happens in two clean steps - initialize the device
  6.  * and add it to the system. The two steps can be called
  7.  * separately, but this is the easiest and most common.
  8.  * I.e. you should only call the two helpers separately if
  9.  * have a clearly defined need to use and refcount the device
  10.  * before it is added to the hierarchy.
  11.  *
  12.  * For more information, see the kerneldoc for device_initialize()
  13.  * and device_add().
  14.  *
  15.  * NOTE: _Never_ directly free @dev after calling this function, even
  16.  * if it returned an error! Always use put_device() to give up the
  17.  * reference initialized in this function instead.
  18.  */
  19. int device_register(struct device *dev)
  20. {
  21. 	device_initialize(dev);
  22. 	return device_add(dev);
  23. }
  24. EXPORT_SYMBOL_GPL(device_register);

device_register函数向系统注册一个设备。其分为两个简单的步骤——初始化设备（device_initialize(dev)）并将其添加到系统中（device_add(dev)）。这两个步骤可以分别调用，但放在一起即使用device_register函数是最简单和最常见的。例如，如果有明确的需求在其添加到层级之前使用和重新计数设备，那么应该分别独立地调用这两个助手（函数）。

从此处的代码就可以知道，老版本的内核代码中确实是直接调用了device_register函数，而新版本内核代码在此处则是在register_virtio_device函数的前边先调用了device_initialize(&dev->dev)，而后在这里调用了device_add(&dev->dev)。即采用了分开调用的方式。

device_register函数会调用device_add函数，将设备加到系统中，并且会发送一个uevent消息到用户空间，这个uevent消息中包含了virtio设备的vendor id、device id。 udev接收到此消息之后，会加载virtio设备对应的驱动。然后，device_add函数会调用bus_probe_device函数，最终调用到Bus的 probe 函数和设备的probe函数，也就是virtio_dev_probe函数和virtballoon_probe函数。

device_add函数也在Linux内核源码/drivers/base/core.c中，就在device_register函数上边，代码如下： 

  1. /**
  2.  * device_add - add device to device hierarchy.
  3.  * @dev: device.
  4.  *
  5.  * This is part 2 of device_register(), though may be called
  6.  * separately _iff_ device_initialize() has been called separately.
  7.  *
  8.  * This adds @dev to the kobject hierarchy via kobject_add(), adds it
  9.  * to the global and sibling lists for the device, then
  10.  * adds it to the other relevant subsystems of the driver model.
  11.  *
  12.  * Do not call this routine or device_register() more than once for
  13.  * any device structure.  The driver model core is not designed to work
  14.  * with devices that get unregistered and then spring back to life.
  15.  * (Among other things, it's very hard to guarantee that all references
  16.  * to the previous incarnation of @dev have been dropped.)  Allocate
  17.  * and register a fresh new struct device instead.
  18.  *
  19.  * NOTE: _Never_ directly free @dev after calling this function, even
  20.  * if it returned an error! Always use put_device() to give up your
  21.  * reference instead.
  22.  *
  23.  * Rule of thumb is: if device_add() succeeds, you should call
  24.  * device_del() when you want to get rid of it. If device_add() has
  25.  * *not* succeeded, use *only* put_device() to drop the reference
  26.  * count.
  27.  */
  28. int device_add(struct device *dev)
  29. {
  30. 	struct subsys_private *sp;
  31. 	struct device *parent;
  32. 	struct kobject *kobj;
  33. 	struct class_interface *class_intf;
  34. 	int error = -EINVAL;
  35. 	struct kobject *glue_dir = NULL;
  36.  
  37. 	dev = get_device(dev);
  38. 	if (!dev)
  39. 		goto done;
  40.  
  41. 	if (!dev->p) {
  42. 		error = device_private_init(dev);
  43. 		if (error)
  44. 			goto done;
  45. 	}
  46.  
  47. 	/*
  48. 	 * for statically allocated devices, which should all be converted
  49. 	 * some day, we need to initialize the name. We prevent reading back
  50. 	 * the name, and force the use of dev_name()
  51. 	 */
  52. 	if (dev->init_name) {
  53. 		error = dev_set_name(dev, "%s", dev->init_name);
  54. 		dev->init_name = NULL;
  55. 	}
  56.  
  57. 	if (dev_name(dev))
  58. 		error = 0;
  59. 	/* subsystems can specify simple device enumeration */
  60. 	else if (dev->bus && dev->bus->dev_name)
  61. 		error = dev_set_name(dev, "%s%u", dev->bus->dev_name, dev->id);
  62. 	else
  63. 		error = -EINVAL;
  64. 	if (error)
  65. 		goto name_error;
  66.  
  67. 	pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
  68.  
  69. 	parent = get_device(dev->parent);
  70. 	kobj = get_device_parent(dev, parent);
  71. 	if (IS_ERR(kobj)) {
  72. 		error = PTR_ERR(kobj);
  73. 		goto parent_error;
  74. 	}
  75. 	if (kobj)
  76. 		dev->kobj.parent = kobj;
  77.  
  78. 	/* use parent numa_node */
  79. 	if (parent && (dev_to_node(dev) == NUMA_NO_NODE))
  80. 		set_dev_node(dev, dev_to_node(parent));
  81.  
  82. 	/* first, register with generic layer. */
  83. 	/* we require the name to be set before, and pass NULL */
  84. 	error = kobject_add(&dev->kobj, dev->kobj.parent, NULL);
  85. 	if (error) {
  86. 		glue_dir = kobj;
  87. 		goto Error;
  88. 	}
  89.  
  90. 	/* notify platform of device entry */
  91. 	device_platform_notify(dev);
  92.  
  93. 	error = device_create_file(dev, &dev_attr_uevent);
  94. 	if (error)
  95. 		goto attrError;
  96.  
  97. 	error = device_add_class_symlinks(dev);
  98. 	if (error)
  99. 		goto SymlinkError;
  100. 	error = device_add_attrs(dev);
  101. 	if (error)
  102. 		goto AttrsError;
  103. 	error = bus_add_device(dev);
  104. 	if (error)
  105. 		goto BusError;
  106. 	error = dpm_sysfs_add(dev);
  107. 	if (error)
  108. 		goto DPMError;
  109. 	device_pm_add(dev);
  110.  
  111. 	if (MAJOR(dev->devt)) {
  112. 		error = device_create_file(dev, &dev_attr_dev);
  113. 		if (error)
  114. 			goto DevAttrError;
  115.  
  116. 		error = device_create_sys_dev_entry(dev);
  117. 		if (error)
  118. 			goto SysEntryError;
  119.  
  120. 		devtmpfs_create_node(dev);
  121. 	}
  122.  
  123. 	/* Notify clients of device addition.  This call must come
  124. 	 * after dpm_sysfs_add() and before kobject_uevent().
  125. 	 */
  126. 	bus_notify(dev, BUS_NOTIFY_ADD_DEVICE);
  127. 	kobject_uevent(&dev->kobj, KOBJ_ADD);
  128.  
  129. 	/*
  130. 	 * Check if any of the other devices (consumers) have been waiting for
  131. 	 * this device (supplier) to be added so that they can create a device
  132. 	 * link to it.
  133. 	 *
  134. 	 * This needs to happen after device_pm_add() because device_link_add()
  135. 	 * requires the supplier be registered before it's called.
  136. 	 *
  137. 	 * But this also needs to happen before bus_probe_device() to make sure
  138. 	 * waiting consumers can link to it before the driver is bound to the
  139. 	 * device and the driver sync_state callback is called for this device.
  140. 	 */
  141. 	if (dev->fwnode && !dev->fwnode->dev) {
  142. 		dev->fwnode->dev = dev;
  143. 		fw_devlink_link_device(dev);
  144. 	}
  145.  
  146. 	bus_probe_device(dev);
  147.  
  148. 	/*
  149. 	 * If all driver registration is done and a newly added device doesn't
  150. 	 * match with any driver, don't block its consumers from probing in
  151. 	 * case the consumer device is able to operate without this supplier.
  152. 	 */
  153. 	if (dev->fwnode && fw_devlink_drv_reg_done && !dev->can_match)
  154. 		fw_devlink_unblock_consumers(dev);
  155.  
  156. 	if (parent)
  157. 		klist_add_tail(&dev->p->knode_parent,
  158. 			       &parent->p->klist_children);
  159.  
  160. 	sp = class_to_subsys(dev->class);
  161. 	if (sp) {
  162. 		mutex_lock(&sp->mutex);
  163. 		/* tie the class to the device */
  164. 		klist_add_tail(&dev->p->knode_class, &sp->klist_devices);
  165.  
  166. 		/* notify any interfaces that the device is here */
  167. 		list_for_each_entry(class_intf, &sp->interfaces, node)
  168. 			if (class_intf->add_dev)
  169. 				class_intf->add_dev(dev);
  170. 		mutex_unlock(&sp->mutex);
  171. 		subsys_put(sp);
  172. 	}
  173. done:
  174. 	put_device(dev);
  175. 	return error;
  176.  SysEntryError:
  177. 	if (MAJOR(dev->devt))
  178. 		device_remove_file(dev, &dev_attr_dev);
  179.  DevAttrError:
  180. 	device_pm_remove(dev);
  181. 	dpm_sysfs_remove(dev);
  182.  DPMError:
  183. 	dev->driver = NULL;
  184. 	bus_remove_device(dev);
  185.  BusError:
  186. 	device_remove_attrs(dev);
  187.  AttrsError:
  188. 	device_remove_class_symlinks(dev);
  189.  SymlinkError:
  190. 	device_remove_file(dev, &dev_attr_uevent);
  191.  attrError:
  192. 	device_platform_notify_remove(dev);
  193. 	kobject_uevent(&dev->kobj, KOBJ_REMOVE);
  194. 	glue_dir = get_glue_dir(dev);
  195. 	kobject_del(&dev->kobj);
  196.  Error:
  197. 	cleanup_glue_dir(dev, glue_dir);
  198. parent_error:
  199. 	put_device(parent);
  200. name_error:
  201. 	kfree(dev->p);
  202. 	dev->p = NULL;
  203. 	goto done;
  204. }
  205. EXPORT_SYMBOL_GPL(device_add);

其中的代码片段： 

  1.     /* Notify clients of device addition.  This call must come
  2. 	 * after dpm_sysfs_add() and before kobject_uevent().
  3. 	 */
  4. 	bus_notify(dev, BUS_NOTIFY_ADD_DEVICE);
  5. 	kobject_uevent(&dev->kobj, KOBJ_ADD);

和 

    bus_probe_device(dev);

就是上边所讲到的：

device_register函数会调用device_add函数，将设备加到系统中，并且会发送一个uevent消息到用户空间，这个uevent消息中包含了virtio设备的vendor id、device id。 udev接收到此消息之后，会加载virtio设备对应的驱动。

然后，device_add函数会调用bus_probe_device函数，最终调用到Bus的probe函数和设备的probe函数，也就是virtio_dev_probe函数和virtballoon_probe函数。

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

举报

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

取消

确定