Commit a49c26f7 authored by Wenyu Huang's avatar Wenyu Huang Committed by Michael S. Tsirkin
Browse files

virtio: Make vring_new_virtqueue support packed vring 



It is used for testing in tools/virtio/vringh_test.c.
If vring_new_virtqueue supports packed vring, we can add support for
packed vring to vringh and test it.

Signed-off-by: default avatarWenyu Huang <huangwenyu1998@gmail.com>
Message-Id: <20241013033233.65026-1-huangwenyu1998@gmail.com>
Signed-off-by: default avatarMichael S. Tsirkin <mst@redhat.com>
Reviewed-by: default avatarStefano Garzarella <sgarzare@redhat.com>
Acked-by: default avatarJason Wang <jasowang@redhat.com>
parent 76f0d870

drivers/virtio/virtio_ring.c

+121 −106
Original line number Diff line number Diff line
@@ -223,15 +223,6 @@ struct vring_virtqueue { 
#endif

};



static struct virtqueue *__vring_new_virtqueue(unsigned int index,

					       struct vring_virtqueue_split *vring_split,

					       struct virtio_device *vdev,

					       bool weak_barriers,

					       bool context,

					       bool (*notify)(struct virtqueue *),

					       void (*callback)(struct virtqueue *),

					       const char *name,

					       struct device *dma_dev);

static struct vring_desc_extra *vring_alloc_desc_extra(unsigned int num);

static void vring_free(struct virtqueue *_vq);
@@ -1138,6 +1129,66 @@ static int vring_alloc_queue_split(struct vring_virtqueue_split *vring_split, 
	return 0;

}



static struct virtqueue *__vring_new_virtqueue_split(unsigned int index,

					       struct vring_virtqueue_split *vring_split,

					       struct virtio_device *vdev,

					       bool weak_barriers,

					       bool context,

					       bool (*notify)(struct virtqueue *),

					       void (*callback)(struct virtqueue *),

					       const char *name,

					       struct device *dma_dev)

{

	struct vring_virtqueue *vq;

	int err;



	vq = kmalloc(sizeof(*vq), GFP_KERNEL);

	if (!vq)

		return NULL;



	vq->packed_ring = false;

	vq->vq.callback = callback;

	vq->vq.vdev = vdev;

	vq->vq.name = name;

	vq->vq.index = index;

	vq->vq.reset = false;

	vq->we_own_ring = false;

	vq->notify = notify;

	vq->weak_barriers = weak_barriers;

#ifdef CONFIG_VIRTIO_HARDEN_NOTIFICATION

	vq->broken = true;

#else

	vq->broken = false;

#endif

	vq->dma_dev = dma_dev;

	vq->use_dma_api = vring_use_dma_api(vdev);

	vq->premapped = false;

	vq->do_unmap = vq->use_dma_api;



	vq->indirect = virtio_has_feature(vdev, VIRTIO_RING_F_INDIRECT_DESC) &&

		!context;

	vq->event = virtio_has_feature(vdev, VIRTIO_RING_F_EVENT_IDX);



	if (virtio_has_feature(vdev, VIRTIO_F_ORDER_PLATFORM))

		vq->weak_barriers = false;



	err = vring_alloc_state_extra_split(vring_split);

	if (err) {

		kfree(vq);

		return NULL;

	}



	virtqueue_vring_init_split(vring_split, vq);



	virtqueue_init(vq, vring_split->vring.num);

	virtqueue_vring_attach_split(vq, vring_split);



	spin_lock(&vdev->vqs_list_lock);

	list_add_tail(&vq->vq.list, &vdev->vqs);

	spin_unlock(&vdev->vqs_list_lock);

	return &vq->vq;

}



static struct virtqueue *vring_create_virtqueue_split(

	unsigned int index,

	unsigned int num,
@@ -1160,7 +1211,7 @@ static struct virtqueue *vring_create_virtqueue_split( 
	if (err)

		return NULL;



	vq = __vring_new_virtqueue(index, &vring_split, vdev, weak_barriers,

	vq = __vring_new_virtqueue_split(index, &vring_split, vdev, weak_barriers,

				   context, notify, callback, name, dma_dev);

	if (!vq) {

		vring_free_split(&vring_split, vdev, dma_dev);
@@ -2050,36 +2101,29 @@ static void virtqueue_reinit_packed(struct vring_virtqueue *vq) 
	virtqueue_vring_init_packed(&vq->packed, !!vq->vq.callback);

}



static struct virtqueue *vring_create_virtqueue_packed(

	unsigned int index,

	unsigned int num,

	unsigned int vring_align,

static struct virtqueue *__vring_new_virtqueue_packed(unsigned int index,

					       struct vring_virtqueue_packed *vring_packed,

					       struct virtio_device *vdev,

					       bool weak_barriers,

	bool may_reduce_num,

					       bool context,

					       bool (*notify)(struct virtqueue *),

					       void (*callback)(struct virtqueue *),

					       const char *name,

					       struct device *dma_dev)

{

	struct vring_virtqueue_packed vring_packed = {};

	struct vring_virtqueue *vq;

	int err;



	if (vring_alloc_queue_packed(&vring_packed, vdev, num, dma_dev))

		goto err_ring;



	vq = kmalloc(sizeof(*vq), GFP_KERNEL);

	if (!vq)

		goto err_vq;

		return NULL;



	vq->vq.callback = callback;

	vq->vq.vdev = vdev;

	vq->vq.name = name;

	vq->vq.index = index;

	vq->vq.reset = false;

	vq->we_own_ring = true;

	vq->we_own_ring = false;

	vq->notify = notify;

	vq->weak_barriers = weak_barriers;

#ifdef CONFIG_VIRTIO_HARDEN_NOTIFICATION
@@ -2100,28 +2144,54 @@ static struct virtqueue *vring_create_virtqueue_packed( 
	if (virtio_has_feature(vdev, VIRTIO_F_ORDER_PLATFORM))

		vq->weak_barriers = false;



	err = vring_alloc_state_extra_packed(&vring_packed);

	if (err)

		goto err_state_extra;

	err = vring_alloc_state_extra_packed(vring_packed);

	if (err) {

		kfree(vq);

		return NULL;

	}



	virtqueue_vring_init_packed(&vring_packed, !!callback);

	virtqueue_vring_init_packed(vring_packed, !!callback);



	virtqueue_init(vq, num);

	virtqueue_vring_attach_packed(vq, &vring_packed);

	virtqueue_init(vq, vring_packed->vring.num);

	virtqueue_vring_attach_packed(vq, vring_packed);



	spin_lock(&vdev->vqs_list_lock);

	list_add_tail(&vq->vq.list, &vdev->vqs);

	spin_unlock(&vdev->vqs_list_lock);

	return &vq->vq;

}



err_state_extra:

	kfree(vq);

err_vq:

static struct virtqueue *vring_create_virtqueue_packed(

	unsigned int index,

	unsigned int num,

	unsigned int vring_align,

	struct virtio_device *vdev,

	bool weak_barriers,

	bool may_reduce_num,

	bool context,

	bool (*notify)(struct virtqueue *),

	void (*callback)(struct virtqueue *),

	const char *name,

	struct device *dma_dev)

{

	struct vring_virtqueue_packed vring_packed = {};

	struct virtqueue *vq;



	if (vring_alloc_queue_packed(&vring_packed, vdev, num, dma_dev))

		return NULL;



	vq = __vring_new_virtqueue_packed(index, &vring_packed, vdev, weak_barriers,

					context, notify, callback, name, dma_dev);

	if (!vq) {

		vring_free_packed(&vring_packed, vdev, dma_dev);

err_ring:

		return NULL;

	}



	to_vvq(vq)->we_own_ring = true;



	return vq;

}



static int virtqueue_resize_packed(struct virtqueue *_vq, u32 num)

{

	struct vring_virtqueue_packed vring_packed = {};
@@ -2598,69 +2668,7 @@ irqreturn_t vring_interrupt(int irq, void *_vq) 
}

EXPORT_SYMBOL_GPL(vring_interrupt);



/* Only available for split ring */

static struct virtqueue *__vring_new_virtqueue(unsigned int index,

					       struct vring_virtqueue_split *vring_split,

					       struct virtio_device *vdev,

					       bool weak_barriers,

					       bool context,

					       bool (*notify)(struct virtqueue *),

					       void (*callback)(struct virtqueue *),

					       const char *name,

					       struct device *dma_dev)

{

	struct vring_virtqueue *vq;

	int err;



	if (virtio_has_feature(vdev, VIRTIO_F_RING_PACKED))

		return NULL;



	vq = kmalloc(sizeof(*vq), GFP_KERNEL);

	if (!vq)

		return NULL;



	vq->packed_ring = false;

	vq->vq.callback = callback;

	vq->vq.vdev = vdev;

	vq->vq.name = name;

	vq->vq.index = index;

	vq->vq.reset = false;

	vq->we_own_ring = false;

	vq->notify = notify;

	vq->weak_barriers = weak_barriers;

#ifdef CONFIG_VIRTIO_HARDEN_NOTIFICATION

	vq->broken = true;

#else

	vq->broken = false;

#endif

	vq->dma_dev = dma_dev;

	vq->use_dma_api = vring_use_dma_api(vdev);

	vq->premapped = false;

	vq->do_unmap = vq->use_dma_api;



	vq->indirect = virtio_has_feature(vdev, VIRTIO_RING_F_INDIRECT_DESC) &&

		!context;

	vq->event = virtio_has_feature(vdev, VIRTIO_RING_F_EVENT_IDX);



	if (virtio_has_feature(vdev, VIRTIO_F_ORDER_PLATFORM))

		vq->weak_barriers = false;



	err = vring_alloc_state_extra_split(vring_split);

	if (err) {

		kfree(vq);

		return NULL;

	}



	virtqueue_vring_init_split(vring_split, vq);



	virtqueue_init(vq, vring_split->vring.num);

	virtqueue_vring_attach_split(vq, vring_split);



	spin_lock(&vdev->vqs_list_lock);

	list_add_tail(&vq->vq.list, &vdev->vqs);

	spin_unlock(&vdev->vqs_list_lock);

	return &vq->vq;

}



struct virtqueue *vring_create_virtqueue(

	unsigned int index,
@@ -2840,7 +2848,6 @@ int virtqueue_reset(struct virtqueue *_vq, 
}

EXPORT_SYMBOL_GPL(virtqueue_reset);



/* Only available for split ring */

struct virtqueue *vring_new_virtqueue(unsigned int index,

				      unsigned int num,

				      unsigned int vring_align,
@@ -2854,11 +2861,19 @@ struct virtqueue *vring_new_virtqueue(unsigned int index, 
{

	struct vring_virtqueue_split vring_split = {};



	if (virtio_has_feature(vdev, VIRTIO_F_RING_PACKED))

		return NULL;

	if (virtio_has_feature(vdev, VIRTIO_F_RING_PACKED)) {

		struct vring_virtqueue_packed vring_packed = {};



		vring_packed.vring.num = num;

		vring_packed.vring.desc = pages;

		return __vring_new_virtqueue_packed(index, &vring_packed,

						    vdev, weak_barriers,

						    context, notify, callback,

						    name, vdev->dev.parent);

	}



	vring_init(&vring_split.vring, num, pages, vring_align);

	return __vring_new_virtqueue(index, &vring_split, vdev, weak_barriers,

	return __vring_new_virtqueue_split(index, &vring_split, vdev, weak_barriers,

				     context, notify, callback, name,

				     vdev->dev.parent);

}