devbox
寸_铁
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

vhost源码分析

作者：寸_铁 | 2024-08-18 20:15:17

赞

踩

vhost源码分析

1、概述

       vhost的大致原理就是qemu在Guest、Host之间创建一些共享buffer，Guest作为生产者往buffer填充可用描述符信息，Host作为消费者从可用描述符里消费buffer。Host消费完buffer后再通知Guest回收描述符；

       本文主要基于3.10版本kernel，分析了vhost的报文收发过程。

2、vring

Guest、Host之间通过通过共享vring buffer的方式完成数据报文传递，相关数据结构如下，其中vring_virtqueue为Guest侧数据结构，vhost_virtqueue为Host侧数据结构；

  1. struct vring_virtqueue
  2. {
  3. 	struct virtqueue vq;
  4.  
  5. 	/* Actual memory layout for this queue */
  6.     /*
  7.     包含desc、avail、used三个vring，其中desc用于存放描述符信息，avail用于表示当前可用的desc 的
  8.     head id，used用于描述当前已经使用的desc的head id
  9.     */
  10. 	struct vring vring;
  11.  
  12. 	/* Can we use weak barriers? */
  13. 	bool weak_barriers;
  14.  
  15. 	/* Other side has made a mess, don't try any more. */
  16. 	bool broken;
  17.  
  18. 	/* Host supports indirect buffers */
  19. 	bool indirect;
  20.  
  21. 	/* Host publishes avail event idx */
  22. 	bool event;
  23.  
  24. 	/* Head of free buffer list. */
  25. 	unsigned int free_head;
  26. 	/* Number we've added since last sync. */
  27. 	unsigned int num_added;
  28.  
  29. 	/* Last used index we've seen. */
  30.     /*
  31.     用于描述Guest当前已回收的最后一个desc id值
  32.     */
  33. 	u16 last_used_idx;
  34.  
  35. 	/* How to notify other side. FIXME: commonalize hcalls! */
  36. 	void (*notify)(struct virtqueue *vq);
  37.  
  38. #ifdef DEBUG
  39. 	/* They're supposed to lock for us. */
  40. 	unsigned int in_use;
  41.  
  42. 	/* Figure out if their kicks are too delayed. */
  43. 	bool last_add_time_valid;
  44. 	ktime_t last_add_time;
  45. #endif
  46.  
  47. 	/* Tokens for callbacks. */
  48. 	void *data[];
  49. };
  1. struct vhost_virtqueue {
  2. 	struct vhost_dev *dev;
  3.  
  4. 	/* The actual ring of buffers. */
  5. 	struct mutex mutex;
  6. 	unsigned int num;
  7.     /*
  8.       Qemu通过VHOST_SET_VRING_ADDR将Guest的三个vring地址通知给vhost，vhost填充到
  9.       vhost_virtqueue对应字段
  10.     */
  11. 	struct vring_desc __user *desc;
  12. 	struct vring_avail __user *avail;
  13. 	struct vring_used __user *used;
  14. 	struct file *kick;
  15. 	struct file *call;
  16. 	struct file *error;
  17. 	struct eventfd_ctx *call_ctx;
  18. 	struct eventfd_ctx *error_ctx;
  19. 	struct eventfd_ctx *log_ctx;
  20.  
  21. 	struct vhost_poll poll;
  22.  
  23. 	/* The routine to call when the Guest pings us, or timeout. */
  24. 	vhost_work_fn_t handle_kick;
  25.  
  26. 	/* Last available index we saw. */
  27.     /*
  28.       Host可用的第一个desc id
  29.     */
  30. 	u16 last_avail_idx;
  31.  
  32. 	/* Caches available index value from user. */
  33. 	u16 avail_idx;
  34.  
  35. 	/* Last index we used. */
  36. 	u16 last_used_idx;
  37.  
  38. 	/* Used flags */
  39. 	u16 used_flags;
  40.  
  41. 	/* Last used index value we have signalled on */
  42. 	u16 signalled_used;
  43.  
  44. 	/* Last used index value we have signalled on */
  45. 	bool signalled_used_valid;
  46.  
  47. 	/* Log writes to used structure. */
  48. 	bool log_used;
  49. 	u64 log_addr;
  50.  
  51. 	struct iovec iov[UIO_MAXIOV];
  52. 	struct iovec *indirect;
  53. 	struct vring_used_elem *heads;
  54. 	/* We use a kind of RCU to access private pointer.
  55. 	 * All readers access it from worker, which makes it possible to
  56. 	 * flush the vhost_work instead of synchronize_rcu. Therefore readers do
  57. 	 * not need to call rcu_read_lock/rcu_read_unlock: the beginning of
  58. 	 * vhost_work execution acts instead of rcu_read_lock() and the end of
  59. 	 * vhost_work execution acts instead of rcu_read_unlock().
  60. 	 * Writers use virtqueue mutex. */
  61. 	void __rcu *private_data;
  62. 	/* Log write descriptors */
  63. 	void __user *log_base;
  64. 	struct vhost_log *log;
  65. };

3、发包流程

3.1 Guest侧

  1. static struct virtqueue *setup_vq(struct virtio_device *vdev, unsigned index,
  2. 				  void (*callback)(struct virtqueue *vq),
  3. 				  const char *name,
  4. 				  u16 msix_vec)
  5. {
  6. 	struct virtio_pci_device *vp_dev = to_vp_device(vdev);
  7. 	struct virtio_pci_vq_info *info;
  8. 	struct virtqueue *vq;
  9. 	unsigned long flags, size;
  10. 	u16 num;
  11. 	int err;
  12.  
  13. 	/* Select the queue we're interested in */
  14. 	iowrite16(index, vp_dev->ioaddr + VIRTIO_PCI_QUEUE_SEL);
  15.  
  16. 	/* Check if queue is either not available or already active. */
  17.     /*获取当前配置的vring buffer个数*/
  18. 	num = ioread16(vp_dev->ioaddr + VIRTIO_PCI_QUEUE_NUM);
  19. 	if (!num || ioread32(vp_dev->ioaddr + VIRTIO_PCI_QUEUE_PFN))
  20. 		return ERR_PTR(-ENOENT);
  21.  
  22. 	/* allocate and fill out our structure the represents an active
  23. 	 * queue */
  24. 	info = kmalloc(sizeof(struct virtio_pci_vq_info), GFP_KERNEL);
  25. 	if (!info)
  26. 		return ERR_PTR(-ENOMEM);
  27.  
  28. 	info->num = num;
  29. 	info->msix_vector = msix_vec;
  30.  
  31. 	size = PAGE_ALIGN(vring_size(num, VIRTIO_PCI_VRING_ALIGN));
  32.     /*分配desc页信息*/
  33. 	info->queue = alloc_pages_exact(size, GFP_KERNEL|__GFP_ZERO);
  34. 	if (info->queue == NULL) {
  35. 		err = -ENOMEM;
  36. 		goto out_info;
  37. 	}
  38.  
  39. 	/* activate the queue */
  40. 	iowrite32(virt_to_phys(info->queue) >> VIRTIO_PCI_QUEUE_ADDR_SHIFT,
  41. 		  vp_dev->ioaddr + VIRTIO_PCI_QUEUE_PFN);
  42.  
  43. 	/* create the vring */
  44. 	vq = vring_new_virtqueue(index, info->num, VIRTIO_PCI_VRING_ALIGN, vdev,
  45. 				 true, info->queue, vp_notify, callback, name);
  46. 	if (!vq) {
  47. 		err = -ENOMEM;
  48. 		goto out_activate_queue;
  49. 	}
  50.  
  51. 	vq->priv = info;
  52. 	info->vq = vq;
  53.  
  54. 	if (msix_vec != VIRTIO_MSI_NO_VECTOR) {
  55. 		iowrite16(msix_vec, vp_dev->ioaddr + VIRTIO_MSI_QUEUE_VECTOR);
  56. 		msix_vec = ioread16(vp_dev->ioaddr + VIRTIO_MSI_QUEUE_VECTOR);
  57. 		if (msix_vec == VIRTIO_MSI_NO_VECTOR) {
  58. 			err = -EBUSY;
  59. 			goto out_assign;
  60. 		}
  61. 	}
  62.  
  63. 	if (callback) {
  64. 		spin_lock_irqsave(&vp_dev->lock, flags);
  65. 		list_add(&info->node, &vp_dev->virtqueues);
  66. 		spin_unlock_irqrestore(&vp_dev->lock, flags);
  67. 	} else {
  68. 		INIT_LIST_HEAD(&info->node);
  69. 	}
  70.  
  71. 	return vq;
  72.  
  73. out_assign:
  74. 	vring_del_virtqueue(vq);
  75. out_activate_queue:
  76. 	iowrite32(0, vp_dev->ioaddr + VIRTIO_PCI_QUEUE_PFN);
  77. 	free_pages_exact(info->queue, size);
  78. out_info:
  79. 	kfree(info);
  80. 	return ERR_PTR(err);
  81. }

Guest在初始化virtio设备时，在setup_vq函数里，先获取配置的vring buffer个数信息，然后分配实际的desc内存，调用vring_new_virtqueue创建vq，完成vring信息的初始化；

  1. struct virtqueue *vring_new_virtqueue(unsigned int index,
  2. 				      unsigned int num,
  3. 				      unsigned int vring_align,
  4. 				      struct virtio_device *vdev,
  5. 				      bool weak_barriers,
  6. 				      void *pages,
  7. 				      void (*notify)(struct virtqueue *),
  8. 				      void (*callback)(struct virtqueue *),
  9. 				      const char *name)
  10. {
  11. 	struct vring_virtqueue *vq;
  12. 	unsigned int i;
  13.  
  14. 	/* We assume num is a power of 2. */
  15. 	if (num & (num - 1)) {
  16. 		dev_warn(&vdev->dev, "Bad virtqueue length %u\n", num);
  17. 		return NULL;
  18. 	}
  19.  
  20. 	vq = kmalloc(sizeof(*vq) + sizeof(void *)*num, GFP_KERNEL);
  21. 	if (!vq)
  22. 		return NULL;
  23.  
  24. 	vring_init(&vq->vring, num, pages, vring_align);
  25. 	vq->vq.callback = callback;
  26. 	vq->vq.vdev = vdev;
  27. 	vq->vq.name = name;
  28. 	vq->vq.num_free = num;
  29. 	vq->vq.index = index;
  30. 	vq->notify = notify;
  31. 	vq->weak_barriers = weak_barriers;
  32. 	vq->broken = false;
  33. 	vq->last_used_idx = 0;
  34. 	vq->num_added = 0;
  35. 	list_add_tail(&vq->vq.list, &vdev->vqs);
  36. #ifdef DEBUG
  37. 	vq->in_use = false;
  38. 	vq->last_add_time_valid = false;
  39. #endif
  40.  
  41. 	vq->indirect = virtio_has_feature(vdev, VIRTIO_RING_F_INDIRECT_DESC);
  42. 	vq->event = virtio_has_feature(vdev, VIRTIO_RING_F_EVENT_IDX);
  43.  
  44. 	/* No callback?  Tell other side not to bother us. */
  45. 	if (!callback)
  46. 		vq->vring.avail->flags |= VRING_AVAIL_F_NO_INTERRUPT;
  47.  
  48. 	/* Put everything in free lists. */
  49. 	vq->free_head = 0;
  50.     /*初始化desc描述符vring*/
  51. 	for (i = 0; i < num-1; i++) {
  52. 		vq->vring.desc[i].next = i+1;
  53. 		vq->data[i] = NULL;
  54. 	}
  55.     /*初始化data数据结构，Host接收报文时，就是将相应的报文数据填充到data里*/
  56. 	vq->data[i] = NULL;
  57.  
  58. 	return &vq->vq;
  59. }

当Guest需要向外发送报文时，会调用到start_xmit（virtio_net.c），该函数最终会调用virtqueue_add将skb_buffer填充到vq->data里；

  1. static inline int virtqueue_add(struct virtqueue *_vq,
  2. 				struct scatterlist *sgs[],
  3. 				struct scatterlist *(*next)
  4. 				  (struct scatterlist *, unsigned int *),
  5. 				unsigned int total_out,
  6. 				unsigned int total_in,
  7. 				unsigned int out_sgs,
  8. 				unsigned int in_sgs,
  9. 				void *data,
  10. 				gfp_t gfp)
  11. {
  12. 	struct vring_virtqueue *vq = to_vvq(_vq);
  13. 	struct scatterlist *sg;
  14. 	unsigned int i, n, avail, uninitialized_var(prev), total_sg;
  15. 	int head;
  16.  
  17. 	START_USE(vq);
  18.  
  19. 	BUG_ON(data == NULL);
  20.  
  21. #ifdef DEBUG
  22. 	{
  23. 		ktime_t now = ktime_get();
  24.  
  25. 		/* No kick or get, with .1 second between?  Warn. */
  26. 		if (vq->last_add_time_valid)
  27. 			WARN_ON(ktime_to_ms(ktime_sub(now, vq->last_add_time))
  28. 					    > 100);
  29. 		vq->last_add_time = now;
  30. 		vq->last_add_time_valid = true;
  31. 	}
  32. #endif
  33.  
  34. 	total_sg = total_in + total_out;
  35.  
  36. 	/* If the host supports indirect descriptor tables, and we have multiple
  37. 	 * buffers, then go indirect. FIXME: tune this threshold */
  38. 	if (vq->indirect && total_sg > 1 && vq->vq.num_free) {
  39. 		head = vring_add_indirect(vq, sgs, next, total_sg, total_out,
  40. 					  total_in,
  41. 					  out_sgs, in_sgs, gfp);
  42. 		if (likely(head >= 0))
  43. 			goto add_head;
  44. 	}
  45.  
  46. 	BUG_ON(total_sg > vq->vring.num);
  47. 	BUG_ON(total_sg == 0);
  48.  
  49. 	if (vq->vq.num_free < total_sg) {
  50. 		pr_debug("Can't add buf len %i - avail = %i\n",
  51. 			 total_sg, vq->vq.num_free);
  52. 		/* FIXME: for historical reasons, we force a notify here if
  53. 		 * there are outgoing parts to the buffer.  Presumably the
  54. 		 * host should service the ring ASAP. */
  55. 		if (out_sgs)
  56. 			vq->notify(&vq->vq);
  57. 		END_USE(vq);
  58. 		return -ENOSPC;
  59. 	}
  60.  
  61. 	/* We're about to use some buffers from the free list. */
  62. 	vq->vq.num_free -= total_sg;
  63.     /*获取当前首个可用描述符id*/
  64. 	head = i = vq->free_head;
  65.     /*填充描述符信息*/
  66. 	for (n = 0; n < out_sgs; n++) {
  67. 		for (sg = sgs[n]; sg; sg = next(sg, &total_out)) {
  68. 			vq->vring.desc[i].flags = VRING_DESC_F_NEXT;
  69. 			vq->vring.desc[i].addr = sg_phys(sg);
  70. 			vq->vring.desc[i].len = sg->length;
  71. 			prev = i;
  72. 			i = vq->vring.desc[i].next;
  73. 		}
  74. 	}
  75. 	for (; n < (out_sgs + in_sgs); n++) {
  76. 		for (sg = sgs[n]; sg; sg = next(sg, &total_in)) {
  77. 			vq->vring.desc[i].flags = VRING_DESC_F_NEXT|VRING_DESC_F_WRITE;
  78. 			vq->vring.desc[i].addr = sg_phys(sg);
  79. 			vq->vring.desc[i].len = sg->length;
  80. 			prev = i;
  81. 			i = vq->vring.desc[i].next;
  82. 		}
  83. 	}
  84. 	/* Last one doesn't continue. */
  85. 	vq->vring.desc[prev].flags &= ~VRING_DESC_F_NEXT;
  86.  
  87. 	/* Update free pointer */
  88. 	vq->free_head = i;
  89.  
  90. add_head:
  91. 	/* Set token. */
  92. 	vq->data[head] = data;
  93.  
  94. 	/* Put entry in available array (but don't update avail->idx until they
  95. 	 * do sync). */
  96. 	avail = (vq->vring.avail->idx & (vq->vring.num-1));
  97. 	vq->vring.avail->ring[avail] = head;
  99. 	/* Descriptors and available array need to be set before we expose the
  100. 	 * new available array entries. */
  101. 	virtio_wmb(vq->weak_barriers);
  102.     /*更新avail idx，Host在收包get可用描述符时，会获取该值*/
  103. 	vq->vring.avail->idx++;
  104. 	vq->num_added++;
  106. 	/* This is very unlikely, but theoretically possible.  Kick
  107. 	 * just in case. */
  108. 	if (unlikely(vq->num_added == (1 << 16) - 1))
  109. 		virtqueue_kick(_vq);
  111. 	pr_debug("Added buffer head %i to %p\n", head, vq);
  112. 	END_USE(vq);
  114. 	return 0;
  115. }

start_xmit添加完outbuffer后，调用virtqueue_kick通知host；

  1. void virtqueue_kick(struct virtqueue *vq)
  2. {
  3. 	if (virtqueue_kick_prepare(vq))
  4. 		virtqueue_notify(vq);
  5. }

在virtqueue_kick，virtqueue_kick_prepare会根据vring_need_event的返回值判断是否需要通知host，下面重点看一下vring_need_event：

  1. static inline int vring_need_event(__u16 event_idx, __u16 new_idx, __u16 old)
  2. {
  3. 	/* Note: Xen has similar logic for notification hold-off
  4. 	 * in include/xen/interface/io/ring.h with req_event and req_prod
  5. 	 * corresponding to event_idx + 1 and new_idx respectively.
  6. 	 * Note also that req_event and req_prod in Xen start at 1,
  7. 	 * event indexes in virtio start at 0. */
  8. 	return (__u16)(new_idx - event_idx - 1) < (__u16)(new_idx - old);
  9. }

看一下这个event_idx的定义：

#define vring_avail_event(vr) (*(__u16 *)&(vr)->used->ring[(vr)->num])

那这个值是在哪里更新的呢？回到vhost代码；会发现vhost在使用完ring buffer后会调用vhost_update_avail_event，在这里会调用__put_user(vq->avail_idx, vhost_avail_event(vq))，会将avail_idx写到vhost_avail_event(vq)里，看下vhost_avail_event(vq)的定义：

#define vhost_avail_event(vq) ((u16 __user *)&vq->used->ring[vq->num])

可以发现这个vhost_avail_event其实就是vring_avail_event；至于avail_idx，vhost在handle_rx阶段获取可用描述符（vhost_get_vq_desc）时会通过__get_user(vq->avail_idx, &vq->avail->idx)获取，表示当前而Guest已添加的可用buffer id，Guest每添加一个buffer（virtqueue_add），就会更新一次vq->avail->idx，总结一下就是：

Guest在添加buffer的时候会更新vq->avail->idx，host在获取可用buffer时会获取这个值，然后将其写到vhost_avail_event里，Guest在添加完新的buffer后，就会判断当前host填进去的vhost_avail_enevt是不是Guest最新的值，如果是，则通过virtqueue_notify通知host，如果不是，表明host当前消息处理不过来，等下次再通知。

3.2 Host侧

Guest调用vrtrqueue_notify后，触发mmio异常陷出到host，然后通过eventfd机制唤醒vhost线程（vhost线程唤醒机制后续再单独做分析）；当vhost需要发包被唤醒时，会调用handle_tx（drivers/vhost/net.c），在handle_tx里会调用vhost_get_vq_desc获取Guest填充的buffer信息；

  1. int vhost_get_vq_desc(struct vhost_dev *dev, struct vhost_virtqueue *vq,
  2. 		      struct iovec iov[], unsigned int iov_size,
  3. 		      unsigned int *out_num, unsigned int *in_num,
  4. 		      struct vhost_log *log, unsigned int *log_num)
  5. {
  6. 	struct vring_desc desc;
  7. 	unsigned int i, head, found = 0;
  8. 	u16 last_avail_idx;
  9. 	int ret;
  10.  
  11. 	/* Check it isn't doing very strange things with descriptor numbers. */
  12. 	last_avail_idx = vq->last_avail_idx;
  13. 	/*
  14. 		获取Guest填充的最新的可用id值
  15. 	*/
  16. 	if (unlikely(__get_user(vq->avail_idx, &vq->avail->idx))) {
  17. 		vq_err(vq, "Failed to access avail idx at %p\n",
  18. 		       &vq->avail->idx);
  19. 		return -EFAULT;
  20. 	}
  21.  
  22. 	if (unlikely((u16)(vq->avail_idx - last_avail_idx) > vq->num)) {
  23. 		vq_err(vq, "Guest moved used index from %u to %u",
  24. 		       last_avail_idx, vq->avail_idx);
  25. 		return -EFAULT;
  26. 	}
  27.  
  28. 	/* If there's nothing new since last we looked, return invalid. */
  29.     /*
  30.     Last_avail_idx表示vhost当前可用的id值，vhost每使用一个描述符，last_avail_idx就会加1；如果
  31.      vq->avail_idx与last_avail_idx相等，则表明Guest没有填充新的buffer，也即当前没有需要发送的
  32.     数据
  33.     */
  34. 	if (vq->avail_idx == last_avail_idx)
  35. 		return vq->num;
  36.  
  37. 	/* Only get avail ring entries after they have been exposed by guest. */
  38. 	smp_rmb();
  39.  
  40. 	/* Grab the next descriptor number they're advertising, and increment
  41. 	 * the index we've seen. */
  42. 	if (unlikely(__get_user(head,
  43. 				&vq->avail->ring[last_avail_idx % vq->num]))) {
  44. 		vq_err(vq, "Failed to read head: idx %d address %p\n",
  45. 		       last_avail_idx,
  46. 		       &vq->avail->ring[last_avail_idx % vq->num]);
  47. 		return -EFAULT;
  48. 	}
  49.  
  50. 	/* If their number is silly, that's an error. */
  51. 	if (unlikely(head >= vq->num)) {
  52. 		vq_err(vq, "Guest says index %u > %u is available",
  53. 		       head, vq->num);
  54. 		return -EINVAL;
  55. 	}
  56.  
  57. 	/* When we start there are none of either input nor output. */
  58. 	*out_num = *in_num = 0;
  59. 	if (unlikely(log))
  60. 		*log_num = 0;
  61.  
  62. 	i = head;
  63. 	do {
  64. 		unsigned iov_count = *in_num + *out_num;
  65. 		if (unlikely(i >= vq->num)) {
  66. 			vq_err(vq, "Desc index is %u > %u, head = %u",
  67. 			       i, vq->num, head);
  68. 			return -EINVAL;
  69. 		}
  70. 		if (unlikely(++found > vq->num)) {
  71. 			vq_err(vq, "Loop detected: last one at %u "
  72. 			       "vq size %u head %u\n",
  73. 			       i, vq->num, head);
  74. 			return -EINVAL;
  75. 		}
  76. 		ret = __copy_from_user(&desc, vq->desc + i, sizeof desc);
  77. 		if (unlikely(ret)) {
  78. 			vq_err(vq, "Failed to get descriptor: idx %d addr %p\n",
  79. 			       i, vq->desc + i);
  80. 			return -EFAULT;
  81. 		}
  82. 		if (desc.flags & VRING_DESC_F_INDIRECT) {
  83. 			ret = get_indirect(dev, vq, iov, iov_size,
  84. 					   out_num, in_num,
  85. 					   log, log_num, &desc);
  86. 			if (unlikely(ret < 0)) {
  87. 				vq_err(vq, "Failure detected "
  88. 				       "in indirect descriptor at idx %d\n", i);
  89. 				return ret;
  90. 			}
  91. 			continue;
  92. 		}
  93.  
  94. 		ret = translate_desc(dev, desc.addr, desc.len, iov + iov_count,
  95. 				     iov_size - iov_count);
  96. 		if (unlikely(ret < 0)) {
  97. 			vq_err(vq, "Translation failure %d descriptor idx %d\n",
  98. 			       ret, i);
  99. 			return ret;
  100. 		}
  101. 		if (desc.flags & VRING_DESC_F_WRITE) {
  102. 			/* If this is an input descriptor,
  103. 			 * increment that count. */
  104. 			*in_num += ret;
  105. 			if (unlikely(log)) {
  106. 				log[*log_num].addr = desc.addr;
  107. 				log[*log_num].len = desc.len;
  108. 				++*log_num;
  109. 			}
  110. 		} else {
  111. 			/* If it's an output descriptor, they're all supposed
  112. 			 * to come before any input descriptors. */
  113. 			if (unlikely(*in_num)) {
  114. 				vq_err(vq, "Descriptor has out after in: "
  115. 				       "idx %d\n", i);
  116. 				return -EINVAL;
  117. 			}
  118. 			*out_num += ret;
  119. 		}
  120. 	} while ((i = next_desc(&desc)) != -1);
  121.  
  122. 	/* On success, increment avail index. */
  123.     /*
  124.     成功获取一个buffer后，last_avail_idx加1
  125.     */
  126. 	vq->last_avail_idx++;
  127.  
  128. 	/* Assume notifications from guest are disabled at this point,
  129. 	 * if they aren't we would need to update avail_event index. */
  130. 	BUG_ON(!(vq->used_flags & VRING_USED_F_NO_NOTIFY));
  131. 	return head;
  132. }

Vhost获取可用buffer后，通过sock->ops->sendmsg完成报文的发送；然后调用vhost_add_used将已使用的buffer信息回填给Guest；

  1. int vhost_add_used(struct vhost_virtqueue *vq, unsigned int head, int len)
  2. {
  3. 	struct vring_used_elem __user *used;
  4.  
  5. 	/* The virtqueue contains a ring of used buffers.  Get a pointer to the
  6. 	 * next entry in that used ring. */
  7. 	used = &vq->used->ring[vq->last_used_idx % vq->num];
  8. 	if (__put_user(head, &used->id)) {
  9. 		vq_err(vq, "Failed to write used id");
  10. 		return -EFAULT;
  11. 	}
  12. 	if (__put_user(len, &used->len)) {
  13. 		vq_err(vq, "Failed to write used len");
  14. 		return -EFAULT;
  15. 	}
  16. 	/* Make sure buffer is written before we update index. */
  17. 	smp_wmb();
  18.     /*
  19.     将last_used_idx+1写到vq->used->idx里
  20.     */
  21. 	if (__put_user(vq->last_used_idx + 1, &vq->used->idx)) {
  22. 		vq_err(vq, "Failed to increment used idx");
  23. 		return -EFAULT;
  24. 	}
  25. 	if (unlikely(vq->log_used)) {
  26. 		/* Make sure data is seen before log. */
  27. 		smp_wmb();
  28. 		/* Log used ring entry write. */
  29. 		log_write(vq->log_base,
  30. 			  vq->log_addr +
  31. 			   ((void __user *)used - (void __user *)vq->used),
  32. 			  sizeof *used);
  33. 		/* Log used index update. */
  34. 		log_write(vq->log_base,
  35. 			  vq->log_addr + offsetof(struct vring_used, idx),
  36. 			  sizeof vq->used->idx);
  37. 		if (vq->log_ctx)
  38. 			eventfd_signal(vq->log_ctx, 1);
  39. 	}
  40.     /*
  41.     Vhost已使用的id加1
  42.     */
  43. 	vq->last_used_idx++;
  44. 	/* If the driver never bothers to signal in a very long while,
  45. 	 * used index might wrap around. If that happens, invalidate
  46. 	 * signalled_used index we stored. TODO: make sure driver
  47. 	 * signals at least once in 2^16 and remove this. */
  48. 	if (unlikely(vq->last_used_idx == vq->signalled_used))
  49. 		vq->signalled_used_valid = false;
  50. 	return 0;
  51. }

 在vhost_add_used里会调用__put_user(vq->last_used_idx + 1, &vq->used->idx)将vhost当前已使用的used id写到vq->used->idx里，这里的作用是让Guest知道当前vhost已经使用的id值，这样当Guest需要回收buffer或者接收vhost转给它的报文时才知道需要从哪里获取。

4、收包流程

4.1 Host侧

Vhost在接受网卡上送的报文时，会调用handle_rx，在handle_rx里首先通过get_rx_bufs获取当前可用描述符信息，然后通过sock->ops->recvmsg完成报文接收；报文接收完成后调用vhost_add_used_and_signal_n添加已使用id信息；

  1. int vhost_add_used_n(struct vhost_virtqueue *vq, struct vring_used_elem *heads,
  2. 		     unsigned count)
  3. {
  4. 	int start, n, r;
  5.  
  6. 	start = vq->last_used_idx % vq->num;
  7. 	n = vq->num - start;
  8. 	if (n < count) {
  9. 		r = __vhost_add_used_n(vq, heads, n);
  10. 		if (r < 0)
  11. 			return r;
  12. 		heads += n;
  13. 		count -= n;
  14. 	}
  15. 	r = __vhost_add_used_n(vq, heads, count);
  16.  
  17. 	/* Make sure buffer is written before we update index. */
  18. 	smp_wmb();
  19.     /*
  20.     将当前已经的id值写到vq->used->idx里，供Guest接收报文时使用
  21.     */	
  22. 	if (put_user(vq->last_used_idx, &vq->used->idx)) {
  23. 		vq_err(vq, "Failed to increment used idx");
  24. 		return -EFAULT;
  25. 	}
  26. 	if (unlikely(vq->log_used)) {
  27. 		/* Log used index update. */
  28. 		log_write(vq->log_base,
  29. 			  vq->log_addr + offsetof(struct vring_used, idx),
  30. 			  sizeof vq->used->idx);
  31. 		if (vq->log_ctx)
  32. 			eventfd_signal(vq->log_ctx, 1);
  33. 	}
  34. 	return r;
  35. }

在__vhost_add_used_n里vhost会更新last_used_idx（new = （vq->last_used_idx += count）），更新完成后，将最新的last_used_idx通过(put_user(vq->last_used_idx, &vq->used->idx)通知给Guest；vhost更新完id信息后，调用vhost_signal通知Guest接收报文，在vhost_signal里，同样会先判断是否需要通知，判断的原理跟Guest决定是否通知Host时的类似，这里通过vring_need_event判断是否需要通知Guest，其中event_idx为Guest当前已回收的描述符id信息，如果Guest描述符回收过慢，说明当前Guest还有很多接收报文待处理，暂不通知Guest。

  1. static inline int vring_need_event(__u16 event_idx, __u16 new_idx, __u16 old)
  2. {
  3. 	/* Note: Xen has similar logic for notification hold-off
  4. 	 * in include/xen/interface/io/ring.h with req_event and req_prod
  5. 	 * corresponding to event_idx + 1 and new_idx respectively.
  6. 	 * Note also that req_event and req_prod in Xen start at 1,
  7. 	 * event indexes in virtio start at 0. */
  8. 	return (__u16)(new_idx - event_idx - 1) < (__u16)(new_idx - old);
  9. }

4.2 Guest侧

当vhost判断当前需要通知Guest时，会通过irqfd往Guest注入一个虚拟中断（详细流程到时会单独分析）；Guest接收到中断时，进入中断处理函数skb_recv_done，然后触发NET_RX_SOFTIRQ软中断，然后进入virtnet_poll处理报文接收（详细看init_vqs drivers/net/virtio_net.c）；

  1. static int virtnet_poll(struct napi_struct *napi, int budget)
  2.  
  3. {
  4.  
  5.        struct receive_queue *rq =
  6.  
  7.               container_of(napi, struct receive_queue, napi);
  8.  
  9.        struct virtnet_info *vi = rq->vq->vdev->priv;
  10.  
  11.        void *buf;
  12.  
  13.        unsigned int r, len, received = 0;
  14.  
  15.  
  16.  
  17. again:
  18.  
  19.        while (received < budget &&
  20.  
  21.               /* 获取Host填充的报文信息*/
  22.  
  23.               (buf = virtqueue_get_buf(rq->vq, &len)) != NULL) {
  24.  
  25.               receive_buf(rq, buf, len);
  26.  
  27.               --rq->num;
  28.  
  29.               received++;
  30.  
  31.        }
  32.  
  33.        if (rq->num < rq->max / 2) {
  34.  
  35.               /*回收描述符*/
  36.  
  37.               if (!try_fill_recv(rq, GFP_ATOMIC))
  38.  
  39.                      schedule_delayed_work(&vi->refill, 0);
  40.  
  41.        }
  42.  
  43.  
  44.        /* Out of packets? */
  45.  
  46.        if (received < budget) {
  47.  
  48.               r = virtqueue_enable_cb_prepare(rq->vq);
  49.  
  50.               napi_complete(napi);
  51.  
  52.               if (unlikely(virtqueue_poll(rq->vq, r)) &&
  53.  
  54.                   napi_schedule_prep(napi)) {
  55.  
  56.                      virtqueue_disable_cb(rq->vq);
  57.  
  58.                      __napi_schedule(napi);
  59.  
  60.                      goto again;
  61.  
  62.               }
  63.  
  64.        }
  65.  
  66.  
  67.        return received;
  68.  
  69. }

   在virtqueue_get_buf里会获取Host填充的报文数据信息，然后再将报文发给协议栈处理；

  1. void *virtqueue_get_buf(struct virtqueue *_vq, unsigned int *len)
  3. {
  4.  
  5.        struct vring_virtqueue *vq = to_vvq(_vq);
  6.  
  7.        void *ret;
  8.  
  9.        unsigned int i;
  10.  
  11.        u16 last_used;
  12.  
  13.  
  14.  
  15.        START_USE(vq);
  16.  
  17.  
  18.  
  19.        if (unlikely(vq->broken)) {
  20.  
  21.               END_USE(vq);
  22.  
  23.               return NULL;
  24.  
  25.        }
  26.  
  27.        /*
  28.  
  29.        这里判断vq-> last_used_idx与vq->vring.used->idx是否相等，其中vq->last_used_idx表示
  30.        Guest上一次已处理的已使用的描述符id值，vq->vring.used->id是vhost填写的，表示vhost当 前
  31.        已使用的描述符id值，如果这两个值相等，说明Guest没有需要处理的报文了
  32.  
  33.        */
  34.  
  35.        if (!more_used(vq)) {
  36.  
  37.               pr_debug("No more buffers in queue\n");
  38.  
  39.               END_USE(vq);
  40.  
  41.               return NULL;
  42.  
  43.        }
  44.  
  45.  
  46.  
  47.        /* Only get used array entries after they have been exposed by host. */
  48.  
  49.        virtio_rmb(vq->weak_barriers);
  50.  
  51.  
  52.  
  53.        last_used = (vq->last_used_idx & (vq->vring.num - 1));
  54.  
  55.        i = vq->vring.used->ring[last_used].id;
  56.  
  57.        *len = vq->vring.used->ring[last_used].len;
  58.  
  59.  
  60.  
  61.        if (unlikely(i >= vq->vring.num)) {
  62.  
  63.               BAD_RING(vq, "id %u out of range\n", i);
  64.  
  65.               return NULL;
  66.  
  67.        }
  68.  
  69.        if (unlikely(!vq->data[i])) {
  70.  
  71.               BAD_RING(vq, "id %u is not a head!\n", i);
  72.  
  73.               return NULL;
  74.  
  75.        }
  76.  
  77.  
  78.  
  79.        /* detach_buf clears data, so grab it now. */
  80.  
  81.        /*Vq->data[i]为具体的报文buffer*/   
  82.  
  83.        ret = vq->data[i];
  84.  
  85.        detach_buf(vq, i);
  86.  
  87.        /*每处理完一个报文，last_used_idx加1*/
  88.  
  89.        vq->last_used_idx++;
  90.  
  91.        /* If we expect an interrupt for the next entry, tell host
  92.  
  93.         * by writing event index and flush out the write before
  94.  
  95.         * the read in the next get_buf call. */
  96.  
  97.        if (!(vq->vring.avail->flags & VRING_AVAIL_F_NO_INTERRUPT)) {
  98.  
  99.               vring_used_event(&vq->vring) = vq->last_used_idx;
  100.  
  101.               virtio_mb(vq->weak_barriers);
  102.  
  103.        }
  104.  
  105.  
  106.  
  107. #ifdef DEBUG
  108.  
  109.        vq->last_add_time_valid = false;
  110.  
  111. #endif
  112.  
  113.  
  114.  
  115.        END_USE(vq);
  116.  
  117.        return ret;
  118.  
  119. }
  120.  
  121. EXPORT_SYMBOL_GPL(virtqueue_get_buf);

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/寸_铁/article/detail/999072
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号