github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-07-27 17:47:41 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

virtio: introduce virtio_map container union

Browse Source 
Following patch will introduce the mapping operations for virtio
device. In order to achieve this, besides the dma device, virtio core
needs to support a transport or device specific mapping metadata as well.
So this patch introduces a union container of a dma device. The idea
is the allow the transport layer to pass device specific mapping
metadata which will be used as a parameter for the virtio mapping
operations. For the transport or device that is using DMA, dma device
is still being used.

Signed-off-by: Jason Wang <jasowang@redhat.com>
Message-Id: <20250821064641.5025-5-jasowang@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
Tested-by: Lei Yang <leiyang@redhat.com>
Reviewed-by: Eugenio Pérez <eperezma@redhat.com>
This commit is contained in:
Jason Wang 2025-08-21 14:46:36 +08:00 committed by Michael S. Tsirkin
parent b41cb3bcf6
commit b16060c5c7
4 changed files with 66 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

104
drivers/virtio/virtio_ring.c
View File

@ -210,8 +210,7 @@ struct vring_virtqueue {
/* DMA, allocation, and size information */ /* DMA, allocation, and size information */
bool we_own_ring; bool we_own_ring;
/* Device used for doing DMA */ union virtio_map map;
struct device *dma_dev;
#ifdef DEBUG #ifdef DEBUG
/* They're supposed to lock for us. */ /* They're supposed to lock for us. */
@ -307,10 +306,10 @@ EXPORT_SYMBOL_GPL(virtio_max_dma_size);
static void *vring_alloc_queue(struct virtio_device *vdev, size_t size, static void *vring_alloc_queue(struct virtio_device *vdev, size_t size,
dma_addr_t *dma_handle, gfp_t flag, dma_addr_t *dma_handle, gfp_t flag,
struct device *dma_dev) union virtio_map map)
{ {
if (vring_use_map_api(vdev)) { if (vring_use_map_api(vdev)) {
return dma_alloc_coherent(dma_dev, size, return dma_alloc_coherent(map.dma_dev, size,
dma_handle, flag); dma_handle, flag);
} else { } else {
void *queue = alloc_pages_exact(PAGE_ALIGN(size), flag); void *queue = alloc_pages_exact(PAGE_ALIGN(size), flag);
@ -341,10 +340,10 @@ static void *vring_alloc_queue(struct virtio_device *vdev, size_t size,
static void vring_free_queue(struct virtio_device *vdev, size_t size, static void vring_free_queue(struct virtio_device *vdev, size_t size,
void *queue, dma_addr_t dma_handle, void *queue, dma_addr_t dma_handle,
struct device *dma_dev) union virtio_map map)
{ {
if (vring_use_map_api(vdev)) if (vring_use_map_api(vdev))
dma_free_coherent(dma_dev, size, queue, dma_handle); dma_free_coherent(map.dma_dev, size, queue, dma_handle);
else else
free_pages_exact(queue, PAGE_ALIGN(size)); free_pages_exact(queue, PAGE_ALIGN(size));
} }
@ -356,7 +355,7 @@ static void vring_free_queue(struct virtio_device *vdev, size_t size,
*/ */
static struct device *vring_dma_dev(const struct vring_virtqueue *vq) static struct device *vring_dma_dev(const struct vring_virtqueue *vq)
{ {
return vq->dma_dev; return vq->map.dma_dev;
} }
/* Map one sg entry. */ /* Map one sg entry. */
@ -1056,12 +1055,13 @@ static int vring_alloc_state_extra_split(struct vring_virtqueue_split *vring_spl
} }
static void vring_free_split(struct vring_virtqueue_split *vring_split, static void vring_free_split(struct vring_virtqueue_split *vring_split,
struct virtio_device *vdev, struct device *dma_dev) struct virtio_device *vdev,
union virtio_map map)
{ {
vring_free_queue(vdev, vring_split->queue_size_in_bytes, vring_free_queue(vdev, vring_split->queue_size_in_bytes,
vring_split->vring.desc, vring_split->vring.desc,
vring_split->queue_dma_addr, vring_split->queue_dma_addr,
dma_dev); map);
kfree(vring_split->desc_state); kfree(vring_split->desc_state);
kfree(vring_split->desc_extra); kfree(vring_split->desc_extra);
@ -1072,7 +1072,7 @@ static int vring_alloc_queue_split(struct vring_virtqueue_split *vring_split,
u32 num, u32 num,
unsigned int vring_align, unsigned int vring_align,
bool may_reduce_num, bool may_reduce_num,
struct device *dma_dev) union virtio_map map)
{ {
void *queue = NULL; void *queue = NULL;
dma_addr_t dma_addr; dma_addr_t dma_addr;
@ -1088,7 +1088,7 @@ static int vring_alloc_queue_split(struct vring_virtqueue_split *vring_split,
queue = vring_alloc_queue(vdev, vring_size(num, vring_align), queue = vring_alloc_queue(vdev, vring_size(num, vring_align),
&dma_addr, &dma_addr,
GFP_KERNEL | __GFP_NOWARN | __GFP_ZERO, GFP_KERNEL | __GFP_NOWARN | __GFP_ZERO,
dma_dev); map);
if (queue) if (queue)
break; break;
if (!may_reduce_num) if (!may_reduce_num)
@ -1102,7 +1102,7 @@ static int vring_alloc_queue_split(struct vring_virtqueue_split *vring_split,
/* Try to get a single page. You are my only hope! */ /* Try to get a single page. You are my only hope! */
queue = vring_alloc_queue(vdev, vring_size(num, vring_align), queue = vring_alloc_queue(vdev, vring_size(num, vring_align),
&dma_addr, GFP_KERNEL | __GFP_ZERO, &dma_addr, GFP_KERNEL | __GFP_ZERO,
dma_dev); map);
} }
if (!queue) if (!queue)
return -ENOMEM; return -ENOMEM;
@ -1126,7 +1126,7 @@ static struct virtqueue *__vring_new_virtqueue_split(unsigned int index,
bool (*notify)(struct virtqueue *), bool (*notify)(struct virtqueue *),
void (*callback)(struct virtqueue *), void (*callback)(struct virtqueue *),
const char *name, const char *name,
struct device *dma_dev) union virtio_map map)
{ {
struct vring_virtqueue *vq; struct vring_virtqueue *vq;
int err; int err;
@ -1149,7 +1149,7 @@ static struct virtqueue *__vring_new_virtqueue_split(unsigned int index,
#else #else
vq->broken = false; vq->broken = false;
#endif #endif
vq->dma_dev = dma_dev; vq->map = map;
vq->use_map_api = vring_use_map_api(vdev); vq->use_map_api = vring_use_map_api(vdev);
vq->indirect = virtio_has_feature(vdev, VIRTIO_RING_F_INDIRECT_DESC) && vq->indirect = virtio_has_feature(vdev, VIRTIO_RING_F_INDIRECT_DESC) &&
@ -1187,21 +1187,21 @@ static struct virtqueue *vring_create_virtqueue_split(
bool (*notify)(struct virtqueue *), bool (*notify)(struct virtqueue *),
void (*callback)(struct virtqueue *), void (*callback)(struct virtqueue *),
const char *name, const char *name,
struct device *dma_dev) union virtio_map map)
{ {
struct vring_virtqueue_split vring_split = {}; struct vring_virtqueue_split vring_split = {};
struct virtqueue *vq; struct virtqueue *vq;
int err; int err;
err = vring_alloc_queue_split(&vring_split, vdev, num, vring_align, err = vring_alloc_queue_split(&vring_split, vdev, num, vring_align,
may_reduce_num, dma_dev); may_reduce_num, map);
if (err) if (err)
return NULL; return NULL;
vq = __vring_new_virtqueue_split(index, &vring_split, vdev, weak_barriers, vq = __vring_new_virtqueue_split(index, &vring_split, vdev, weak_barriers,
context, notify, callback, name, dma_dev); context, notify, callback, name, map);
if (!vq) { if (!vq) {
vring_free_split(&vring_split, vdev, dma_dev); vring_free_split(&vring_split, vdev, map);
return NULL; return NULL;
} }
@ -1220,7 +1220,7 @@ static int virtqueue_resize_split(struct virtqueue *_vq, u32 num)
err = vring_alloc_queue_split(&vring_split, vdev, num, err = vring_alloc_queue_split(&vring_split, vdev, num,
vq->split.vring_align, vq->split.vring_align,
vq->split.may_reduce_num, vq->split.may_reduce_num,
vring_dma_dev(vq)); vq->map);
if (err) if (err)
goto err; goto err;
@ -1238,7 +1238,7 @@ static int virtqueue_resize_split(struct virtqueue *_vq, u32 num)
return 0; return 0;
err_state_extra: err_state_extra:
vring_free_split(&vring_split, vdev, vring_dma_dev(vq)); vring_free_split(&vring_split, vdev, vq->map);
err: err:
virtqueue_reinit_split(vq); virtqueue_reinit_split(vq);
return -ENOMEM; return -ENOMEM;
@ -1947,25 +1947,25 @@ static struct vring_desc_extra *vring_alloc_desc_extra(unsigned int num)
static void vring_free_packed(struct vring_virtqueue_packed *vring_packed, static void vring_free_packed(struct vring_virtqueue_packed *vring_packed,
struct virtio_device *vdev, struct virtio_device *vdev,
struct device *dma_dev) union virtio_map map)
{ {
if (vring_packed->vring.desc) if (vring_packed->vring.desc)
vring_free_queue(vdev, vring_packed->ring_size_in_bytes, vring_free_queue(vdev, vring_packed->ring_size_in_bytes,
vring_packed->vring.desc, vring_packed->vring.desc,
vring_packed->ring_dma_addr, vring_packed->ring_dma_addr,
dma_dev); map);
if (vring_packed->vring.driver) if (vring_packed->vring.driver)
vring_free_queue(vdev, vring_packed->event_size_in_bytes, vring_free_queue(vdev, vring_packed->event_size_in_bytes,
vring_packed->vring.driver, vring_packed->vring.driver,
vring_packed->driver_event_dma_addr, vring_packed->driver_event_dma_addr,
dma_dev); map);
if (vring_packed->vring.device) if (vring_packed->vring.device)
vring_free_queue(vdev, vring_packed->event_size_in_bytes, vring_free_queue(vdev, vring_packed->event_size_in_bytes,
vring_packed->vring.device, vring_packed->vring.device,
vring_packed->device_event_dma_addr, vring_packed->device_event_dma_addr,
dma_dev); map);
kfree(vring_packed->desc_state); kfree(vring_packed->desc_state);
kfree(vring_packed->desc_extra); kfree(vring_packed->desc_extra);
@ -1973,7 +1973,7 @@ static void vring_free_packed(struct vring_virtqueue_packed *vring_packed,
static int vring_alloc_queue_packed(struct vring_virtqueue_packed *vring_packed, static int vring_alloc_queue_packed(struct vring_virtqueue_packed *vring_packed,
struct virtio_device *vdev, struct virtio_device *vdev,
u32 num, struct device *dma_dev) u32 num, union virtio_map map)
{ {
struct vring_packed_desc *ring; struct vring_packed_desc *ring;
struct vring_packed_desc_event *driver, *device; struct vring_packed_desc_event *driver, *device;
@ -1985,7 +1985,7 @@ static int vring_alloc_queue_packed(struct vring_virtqueue_packed *vring_packed,
ring = vring_alloc_queue(vdev, ring_size_in_bytes, ring = vring_alloc_queue(vdev, ring_size_in_bytes,
&ring_dma_addr, &ring_dma_addr,
GFP_KERNEL | __GFP_NOWARN | __GFP_ZERO, GFP_KERNEL | __GFP_NOWARN | __GFP_ZERO,
dma_dev); map);
if (!ring) if (!ring)
goto err; goto err;
@ -1998,7 +1998,7 @@ static int vring_alloc_queue_packed(struct vring_virtqueue_packed *vring_packed,
driver = vring_alloc_queue(vdev, event_size_in_bytes, driver = vring_alloc_queue(vdev, event_size_in_bytes,
&driver_event_dma_addr, &driver_event_dma_addr,
GFP_KERNEL | __GFP_NOWARN | __GFP_ZERO, GFP_KERNEL | __GFP_NOWARN | __GFP_ZERO,
dma_dev); map);
if (!driver) if (!driver)
goto err; goto err;
@ -2009,7 +2009,7 @@ static int vring_alloc_queue_packed(struct vring_virtqueue_packed *vring_packed,
device = vring_alloc_queue(vdev, event_size_in_bytes, device = vring_alloc_queue(vdev, event_size_in_bytes,
&device_event_dma_addr, &device_event_dma_addr,
GFP_KERNEL | __GFP_NOWARN | __GFP_ZERO, GFP_KERNEL | __GFP_NOWARN | __GFP_ZERO,
dma_dev); map);
if (!device) if (!device)
goto err; goto err;
@ -2021,7 +2021,7 @@ static int vring_alloc_queue_packed(struct vring_virtqueue_packed *vring_packed,
return 0; return 0;
err: err:
vring_free_packed(vring_packed, vdev, dma_dev); vring_free_packed(vring_packed, vdev, map);
return -ENOMEM; return -ENOMEM;
} }
@ -2097,7 +2097,7 @@ static struct virtqueue *__vring_new_virtqueue_packed(unsigned int index,
bool (*notify)(struct virtqueue *), bool (*notify)(struct virtqueue *),
void (*callback)(struct virtqueue *), void (*callback)(struct virtqueue *),
const char *name, const char *name,
struct device *dma_dev) union virtio_map map)
{ {
struct vring_virtqueue *vq; struct vring_virtqueue *vq;
int err; int err;
@ -2120,7 +2120,7 @@ static struct virtqueue *__vring_new_virtqueue_packed(unsigned int index,
vq->broken = false; vq->broken = false;
#endif #endif
vq->packed_ring = true; vq->packed_ring = true;
vq->dma_dev = dma_dev; vq->map = map;
vq->use_map_api = vring_use_map_api(vdev); vq->use_map_api = vring_use_map_api(vdev);
vq->indirect = virtio_has_feature(vdev, VIRTIO_RING_F_INDIRECT_DESC) && vq->indirect = virtio_has_feature(vdev, VIRTIO_RING_F_INDIRECT_DESC) &&
@ -2158,18 +2158,18 @@ static struct virtqueue *vring_create_virtqueue_packed(
bool (*notify)(struct virtqueue *), bool (*notify)(struct virtqueue *),
void (*callback)(struct virtqueue *), void (*callback)(struct virtqueue *),
const char *name, const char *name,
struct device *dma_dev) union virtio_map map)
{ {
struct vring_virtqueue_packed vring_packed = {}; struct vring_virtqueue_packed vring_packed = {};
struct virtqueue *vq; struct virtqueue *vq;
if (vring_alloc_queue_packed(&vring_packed, vdev, num, dma_dev)) if (vring_alloc_queue_packed(&vring_packed, vdev, num, map))
return NULL; return NULL;
vq = __vring_new_virtqueue_packed(index, &vring_packed, vdev, weak_barriers, vq = __vring_new_virtqueue_packed(index, &vring_packed, vdev, weak_barriers,
context, notify, callback, name, dma_dev); context, notify, callback, name, map);
if (!vq) { if (!vq) {
vring_free_packed(&vring_packed, vdev, dma_dev); vring_free_packed(&vring_packed, vdev, map);
return NULL; return NULL;
} }
@ -2185,7 +2185,7 @@ static int virtqueue_resize_packed(struct virtqueue *_vq, u32 num)
struct virtio_device *vdev = _vq->vdev; struct virtio_device *vdev = _vq->vdev;
int err; int err;
if (vring_alloc_queue_packed(&vring_packed, vdev, num, vring_dma_dev(vq))) if (vring_alloc_queue_packed(&vring_packed, vdev, num, vq->map))
goto err_ring; goto err_ring;
err = vring_alloc_state_extra_packed(&vring_packed); err = vring_alloc_state_extra_packed(&vring_packed);
@ -2202,7 +2202,7 @@ static int virtqueue_resize_packed(struct virtqueue *_vq, u32 num)
return 0; return 0;
err_state_extra: err_state_extra:
vring_free_packed(&vring_packed, vdev, vring_dma_dev(vq)); vring_free_packed(&vring_packed, vdev, vq->map);
err_ring: err_ring:
virtqueue_reinit_packed(vq); virtqueue_reinit_packed(vq);
return -ENOMEM; return -ENOMEM;
@ -2434,7 +2434,7 @@ struct device *virtqueue_dma_dev(struct virtqueue *_vq)
struct vring_virtqueue *vq = to_vvq(_vq); struct vring_virtqueue *vq = to_vvq(_vq);
if (vq->use_map_api) if (vq->use_map_api)
return vring_dma_dev(vq); return vq->map.dma_dev;
else else
return NULL; return NULL;
} }
@ -2719,19 +2719,20 @@ struct virtqueue *vring_create_virtqueue(
void (*callback)(struct virtqueue *), void (*callback)(struct virtqueue *),
const char *name) const char *name)
{ {
union virtio_map map = {.dma_dev = vdev->dev.parent};
if (virtio_has_feature(vdev, VIRTIO_F_RING_PACKED)) if (virtio_has_feature(vdev, VIRTIO_F_RING_PACKED))
return vring_create_virtqueue_packed(index, num, vring_align, return vring_create_virtqueue_packed(index, num, vring_align,
vdev, weak_barriers, may_reduce_num, vdev, weak_barriers, may_reduce_num,
context, notify, callback, name, vdev->dev.parent); context, notify, callback, name, map);
return vring_create_virtqueue_split(index, num, vring_align, return vring_create_virtqueue_split(index, num, vring_align,
vdev, weak_barriers, may_reduce_num, vdev, weak_barriers, may_reduce_num,
context, notify, callback, name, vdev->dev.parent); context, notify, callback, name, map);
} }
EXPORT_SYMBOL_GPL(vring_create_virtqueue); EXPORT_SYMBOL_GPL(vring_create_virtqueue);
struct virtqueue *vring_create_virtqueue_dma( struct virtqueue *vring_create_virtqueue_map(
unsigned int index, unsigned int index,
unsigned int num, unsigned int num,
unsigned int vring_align, unsigned int vring_align,
@ -2742,19 +2743,19 @@ struct virtqueue *vring_create_virtqueue_dma(
bool (*notify)(struct virtqueue *), bool (*notify)(struct virtqueue *),
void (*callback)(struct virtqueue *), void (*callback)(struct virtqueue *),
const char *name, const char *name,
struct device *dma_dev) union virtio_map map)
{ {
if (virtio_has_feature(vdev, VIRTIO_F_RING_PACKED)) if (virtio_has_feature(vdev, VIRTIO_F_RING_PACKED))
return vring_create_virtqueue_packed(index, num, vring_align, return vring_create_virtqueue_packed(index, num, vring_align,
vdev, weak_barriers, may_reduce_num, vdev, weak_barriers, may_reduce_num,
context, notify, callback, name, dma_dev); context, notify, callback, name, map);
return vring_create_virtqueue_split(index, num, vring_align, return vring_create_virtqueue_split(index, num, vring_align,
vdev, weak_barriers, may_reduce_num, vdev, weak_barriers, may_reduce_num,
context, notify, callback, name, dma_dev); context, notify, callback, name, map);
} }
EXPORT_SYMBOL_GPL(vring_create_virtqueue_dma); EXPORT_SYMBOL_GPL(vring_create_virtqueue_map);
/** /**
* virtqueue_resize - resize the vring of vq * virtqueue_resize - resize the vring of vq
@ -2865,6 +2866,7 @@ struct virtqueue *vring_new_virtqueue(unsigned int index,
const char *name) const char *name)
{ {
struct vring_virtqueue_split vring_split = {}; struct vring_virtqueue_split vring_split = {};
union virtio_map map = {.dma_dev = vdev->dev.parent};
if (virtio_has_feature(vdev, VIRTIO_F_RING_PACKED)) { if (virtio_has_feature(vdev, VIRTIO_F_RING_PACKED)) {
struct vring_virtqueue_packed vring_packed = {}; struct vring_virtqueue_packed vring_packed = {};
@ -2874,13 +2876,13 @@ struct virtqueue *vring_new_virtqueue(unsigned int index,
return __vring_new_virtqueue_packed(index, &vring_packed, return __vring_new_virtqueue_packed(index, &vring_packed,
vdev, weak_barriers, vdev, weak_barriers,
context, notify, callback, context, notify, callback,
name, vdev->dev.parent); name, map);
} }
vring_init(&vring_split.vring, num, pages, vring_align); vring_init(&vring_split.vring, num, pages, vring_align);
return __vring_new_virtqueue_split(index, &vring_split, vdev, weak_barriers, return __vring_new_virtqueue_split(index, &vring_split, vdev, weak_barriers,
context, notify, callback, name, context, notify, callback, name,
vdev->dev.parent); map);
} }
EXPORT_SYMBOL_GPL(vring_new_virtqueue); EXPORT_SYMBOL_GPL(vring_new_virtqueue);
@ -2894,19 +2896,19 @@ static void vring_free(struct virtqueue *_vq)
vq->packed.ring_size_in_bytes, vq->packed.ring_size_in_bytes,
vq->packed.vring.desc, vq->packed.vring.desc,
vq->packed.ring_dma_addr, vq->packed.ring_dma_addr,
vring_dma_dev(vq)); vq->map);
vring_free_queue(vq->vq.vdev, vring_free_queue(vq->vq.vdev,
vq->packed.event_size_in_bytes, vq->packed.event_size_in_bytes,
vq->packed.vring.driver, vq->packed.vring.driver,
vq->packed.driver_event_dma_addr, vq->packed.driver_event_dma_addr,
vring_dma_dev(vq)); vq->map);
vring_free_queue(vq->vq.vdev, vring_free_queue(vq->vq.vdev,
vq->packed.event_size_in_bytes, vq->packed.event_size_in_bytes,
vq->packed.vring.device, vq->packed.vring.device,
vq->packed.device_event_dma_addr, vq->packed.device_event_dma_addr,
vring_dma_dev(vq)); vq->map);
kfree(vq->packed.desc_state); kfree(vq->packed.desc_state);
kfree(vq->packed.desc_extra); kfree(vq->packed.desc_extra);
@ -2915,7 +2917,7 @@ static void vring_free(struct virtqueue *_vq)
vq->split.queue_size_in_bytes, vq->split.queue_size_in_bytes,
vq->split.vring.desc, vq->split.vring.desc,
vq->split.queue_dma_addr, vq->split.queue_dma_addr,
vring_dma_dev(vq)); vq->map);
} }
} }
if (!vq->packed_ring) { if (!vq->packed_ring) {

6
drivers/virtio/virtio_vdpa.c
View File

@ -139,6 +139,7 @@ virtio_vdpa_setup_vq(struct virtio_device *vdev, unsigned int index,
struct vdpa_callback cb; struct vdpa_callback cb;
struct virtqueue *vq; struct virtqueue *vq;
u64 desc_addr, driver_addr, device_addr; u64 desc_addr, driver_addr, device_addr;
union virtio_map map = {0};
/* Assume split virtqueue, switch to packed if necessary */ /* Assume split virtqueue, switch to packed if necessary */
struct vdpa_vq_state state = {0}; struct vdpa_vq_state state = {0};
u32 align, max_num, min_num = 1; u32 align, max_num, min_num = 1;
@ -185,9 +186,10 @@ virtio_vdpa_setup_vq(struct virtio_device *vdev, unsigned int index,
dma_dev = ops->get_vq_dma_dev(vdpa, index); dma_dev = ops->get_vq_dma_dev(vdpa, index);
else else
dma_dev = vdpa_get_dma_dev(vdpa); dma_dev = vdpa_get_dma_dev(vdpa);
vq = vring_create_virtqueue_dma(index, max_num, align, vdev, map.dma_dev = dma_dev;
vq = vring_create_virtqueue_map(index, max_num, align, vdev,
true, may_reduce_num, ctx, true, may_reduce_num, ctx,
notify, callback, name, dma_dev); notify, callback, name, map);
if (!vq) { if (!vq) {
err = -ENOMEM; err = -ENOMEM;
goto error_new_virtqueue; goto error_new_virtqueue;

5
include/linux/virtio.h
View File

@ -41,6 +41,11 @@ struct virtqueue {
void *priv; void *priv;
}; };
union virtio_map {
/* Device that performs DMA */
struct device *dma_dev;
};
int virtqueue_add_outbuf(struct virtqueue *vq, int virtqueue_add_outbuf(struct virtqueue *vq,
struct scatterlist sg[], unsigned int num, struct scatterlist sg[], unsigned int num,
void *data, void *data,

7
include/linux/virtio_ring.h
View File

@ -3,6 +3,7 @@
#define _LINUX_VIRTIO_RING_H #define _LINUX_VIRTIO_RING_H
#include <asm/barrier.h> #include <asm/barrier.h>
#include <linux/virtio.h>
#include <linux/irqreturn.h> #include <linux/irqreturn.h>
#include <uapi/linux/virtio_ring.h> #include <uapi/linux/virtio_ring.h>
@ -79,9 +80,9 @@ struct virtqueue *vring_create_virtqueue(unsigned int index,
/* /*
* Creates a virtqueue and allocates the descriptor ring with per * Creates a virtqueue and allocates the descriptor ring with per
* virtqueue DMA device. * virtqueue mapping operations.
*/ */
struct virtqueue *vring_create_virtqueue_dma(unsigned int index, struct virtqueue *vring_create_virtqueue_map(unsigned int index,
unsigned int num, unsigned int num,
unsigned int vring_align, unsigned int vring_align,
struct virtio_device *vdev, struct virtio_device *vdev,
@ -91,7 +92,7 @@ struct virtqueue *vring_create_virtqueue_dma(unsigned int index,
bool (*notify)(struct virtqueue *vq), bool (*notify)(struct virtqueue *vq),
void (*callback)(struct virtqueue *vq), void (*callback)(struct virtqueue *vq),
const char *name, const char *name,
struct device *dma_dev); union virtio_map map);
/* /*
* Creates a virtqueue with a standard layout but a caller-allocated * Creates a virtqueue with a standard layout but a caller-allocated