hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

virtio_ring: remove a level of indirection 

We have a single virtqueue_ops implementation,
and it seems unlikely we'll get another one
at this point. So let's remove an unnecessary
level of indirection: it would be very easy to
re-add it if another implementation surfaces.

Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
This commit is contained in:
Michael S. Tsirkin 2010-04-12 16:19:07 +03:00 committed by Rusty Russell
parent 1915a712f2
commit 7c5e9ed0c8
2 changed files with 34 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
drivers/virtio/virtio_ring.c
View File

@ -155,11 +155,11 @@ static int vring_add_indirect(struct vring_virtqueue *vq,
return head; return head;
} }
static int vring_add_buf(struct virtqueue *_vq, int virtqueue_add_buf(struct virtqueue *_vq,
struct scatterlist sg[], struct scatterlist sg[],
unsigned int out, unsigned int out,
unsigned int in, unsigned int in,
void *data) void *data)
{ {
struct vring_virtqueue *vq = to_vvq(_vq); struct vring_virtqueue *vq = to_vvq(_vq);
unsigned int i, avail, head, uninitialized_var(prev); unsigned int i, avail, head, uninitialized_var(prev);
@ -232,8 +232,9 @@ add_head:
return vq->num_free ? vq->vring.num : 0; return vq->num_free ? vq->vring.num : 0;
return vq->num_free; return vq->num_free;
} }
EXPORT_SYMBOL_GPL(virtqueue_add_buf);
static void vring_kick(struct virtqueue *_vq) void virtqueue_kick(struct virtqueue *_vq)
{ {
struct vring_virtqueue *vq = to_vvq(_vq); struct vring_virtqueue *vq = to_vvq(_vq);
START_USE(vq); START_USE(vq);
@ -253,6 +254,7 @@ static void vring_kick(struct virtqueue *_vq)
END_USE(vq); END_USE(vq);
} }
EXPORT_SYMBOL_GPL(virtqueue_kick);
static void detach_buf(struct vring_virtqueue *vq, unsigned int head) static void detach_buf(struct vring_virtqueue *vq, unsigned int head)
{ {
@ -284,7 +286,7 @@ static inline bool more_used(const struct vring_virtqueue *vq)
return vq->last_used_idx != vq->vring.used->idx; return vq->last_used_idx != vq->vring.used->idx;
} }
static void *vring_get_buf(struct virtqueue *_vq, unsigned int *len) void *virtqueue_get_buf(struct virtqueue *_vq, unsigned int *len)
{ {
struct vring_virtqueue *vq = to_vvq(_vq); struct vring_virtqueue *vq = to_vvq(_vq);
void *ret; void *ret;
@ -325,15 +327,17 @@ static void *vring_get_buf(struct virtqueue *_vq, unsigned int *len)
END_USE(vq); END_USE(vq);
return ret; return ret;
} }
EXPORT_SYMBOL_GPL(virtqueue_get_buf);
static void vring_disable_cb(struct virtqueue *_vq) void virtqueue_disable_cb(struct virtqueue *_vq)
{ {
struct vring_virtqueue *vq = to_vvq(_vq); struct vring_virtqueue *vq = to_vvq(_vq);
vq->vring.avail->flags |= VRING_AVAIL_F_NO_INTERRUPT; vq->vring.avail->flags |= VRING_AVAIL_F_NO_INTERRUPT;
} }
EXPORT_SYMBOL_GPL(virtqueue_disable_cb);
static bool vring_enable_cb(struct virtqueue *_vq) bool virtqueue_enable_cb(struct virtqueue *_vq)
{ {
struct vring_virtqueue *vq = to_vvq(_vq); struct vring_virtqueue *vq = to_vvq(_vq);
@ -351,8 +355,9 @@ static bool vring_enable_cb(struct virtqueue *_vq)
END_USE(vq); END_USE(vq);
return true; return true;
} }
EXPORT_SYMBOL_GPL(virtqueue_enable_cb);
static void *vring_detach_unused_buf(struct virtqueue *_vq) void *virtqueue_detach_unused_buf(struct virtqueue *_vq)
{ {
struct vring_virtqueue *vq = to_vvq(_vq); struct vring_virtqueue *vq = to_vvq(_vq);
unsigned int i; unsigned int i;
@ -375,6 +380,7 @@ static void *vring_detach_unused_buf(struct virtqueue *_vq)
END_USE(vq); END_USE(vq);
return NULL; return NULL;
} }
EXPORT_SYMBOL_GPL(virtqueue_detach_unused_buf);
irqreturn_t vring_interrupt(int irq, void *_vq) irqreturn_t vring_interrupt(int irq, void *_vq)
{ {
@ -396,15 +402,6 @@ irqreturn_t vring_interrupt(int irq, void *_vq)
} }
EXPORT_SYMBOL_GPL(vring_interrupt); EXPORT_SYMBOL_GPL(vring_interrupt);
static struct virtqueue_ops vring_vq_ops = {
.add_buf = vring_add_buf,
.get_buf = vring_get_buf,
.kick = vring_kick,
.disable_cb = vring_disable_cb,
.enable_cb = vring_enable_cb,
.detach_unused_buf = vring_detach_unused_buf,
};
struct virtqueue *vring_new_virtqueue(unsigned int num, struct virtqueue *vring_new_virtqueue(unsigned int num,
unsigned int vring_align, unsigned int vring_align,
struct virtio_device *vdev, struct virtio_device *vdev,
@ -429,7 +426,6 @@ struct virtqueue *vring_new_virtqueue(unsigned int num,
vring_init(&vq->vring, num, pages, vring_align); vring_init(&vq->vring, num, pages, vring_align);
vq->vq.callback = callback; vq->vq.callback = callback;
vq->vq.vdev = vdev; vq->vq.vdev = vdev;
vq->vq.vq_ops = &vring_vq_ops;
vq->vq.name = name; vq->vq.name = name;
vq->notify = notify; vq->notify = notify;
vq->broken = false; vq->broken = false;

71
include/linux/virtio.h
View File

@ -14,7 +14,6 @@
* @callback: the function to call when buffers are consumed (can be NULL). * @callback: the function to call when buffers are consumed (can be NULL).
* @name: the name of this virtqueue (mainly for debugging) * @name: the name of this virtqueue (mainly for debugging)
* @vdev: the virtio device this queue was created for. * @vdev: the virtio device this queue was created for.
* @vq_ops: the operations for this virtqueue (see below).
* @priv: a pointer for the virtqueue implementation to use. * @priv: a pointer for the virtqueue implementation to use.
*/ */
struct virtqueue { struct virtqueue {
@ -22,94 +21,60 @@ struct virtqueue {
void (*callback)(struct virtqueue *vq); void (*callback)(struct virtqueue *vq);
const char *name; const char *name;
struct virtio_device *vdev; struct virtio_device *vdev;
struct virtqueue_ops *vq_ops;
void *priv; void *priv;
}; };
/** /**
* virtqueue_ops - operations for virtqueue abstraction layer * operations for virtqueue
* @add_buf: expose buffer to other end * virtqueue_add_buf: expose buffer to other end
* vq: the struct virtqueue we're talking about. * vq: the struct virtqueue we're talking about.
* sg: the description of the buffer(s). * sg: the description of the buffer(s).
* out_num: the number of sg readable by other side * out_num: the number of sg readable by other side
* in_num: the number of sg which are writable (after readable ones) * in_num: the number of sg which are writable (after readable ones)
* data: the token identifying the buffer. * data: the token identifying the buffer.
* Returns remaining capacity of queue (sg segments) or a negative error. * Returns remaining capacity of queue (sg segments) or a negative error.
* @kick: update after add_buf * virtqueue_kick: update after add_buf
* vq: the struct virtqueue * vq: the struct virtqueue
* After one or more add_buf calls, invoke this to kick the other side. * After one or more add_buf calls, invoke this to kick the other side.
* @get_buf: get the next used buffer * virtqueue_get_buf: get the next used buffer
* vq: the struct virtqueue we're talking about. * vq: the struct virtqueue we're talking about.
* len: the length written into the buffer * len: the length written into the buffer
* Returns NULL or the "data" token handed to add_buf. * Returns NULL or the "data" token handed to add_buf.
* @disable_cb: disable callbacks * virtqueue_disable_cb: disable callbacks
* vq: the struct virtqueue we're talking about. * vq: the struct virtqueue we're talking about.
* Note that this is not necessarily synchronous, hence unreliable and only * Note that this is not necessarily synchronous, hence unreliable and only
* useful as an optimization. * useful as an optimization.
* @enable_cb: restart callbacks after disable_cb. * virtqueue_enable_cb: restart callbacks after disable_cb.
* vq: the struct virtqueue we're talking about. * vq: the struct virtqueue we're talking about.
* This re-enables callbacks; it returns "false" if there are pending * This re-enables callbacks; it returns "false" if there are pending
* buffers in the queue, to detect a possible race between the driver * buffers in the queue, to detect a possible race between the driver
* checking for more work, and enabling callbacks. * checking for more work, and enabling callbacks.
* @detach_unused_buf: detach first unused buffer * virtqueue_detach_unused_buf: detach first unused buffer
* vq: the struct virtqueue we're talking about. * vq: the struct virtqueue we're talking about.
* Returns NULL or the "data" token handed to add_buf * Returns NULL or the "data" token handed to add_buf
* *
* Locking rules are straightforward: the driver is responsible for * Locking rules are straightforward: the driver is responsible for
* locking. No two operations may be invoked simultaneously, with the exception * locking. No two operations may be invoked simultaneously, with the exception
* of @disable_cb. * of virtqueue_disable_cb.
* *
* All operations can be called in any context. * All operations can be called in any context.
*/ */
struct virtqueue_ops {
int (*add_buf)(struct virtqueue *vq,
struct scatterlist sg[],
unsigned int out_num,
unsigned int in_num,
void *data);
void (*kick)(struct virtqueue *vq); int virtqueue_add_buf(struct virtqueue *vq,
struct scatterlist sg[],
unsigned int out_num,
unsigned int in_num,
void *data);
void *(*get_buf)(struct virtqueue *vq, unsigned int *len); void virtqueue_kick(struct virtqueue *vq);
void (*disable_cb)(struct virtqueue *vq); void *virtqueue_get_buf(struct virtqueue *vq, unsigned int *len);
bool (*enable_cb)(struct virtqueue *vq);
void *(*detach_unused_buf)(struct virtqueue *vq);
};
static inline int virtqueue_add_buf(struct virtqueue *vq, void virtqueue_disable_cb(struct virtqueue *vq);
struct scatterlist sg[],
unsigned int out_num,
unsigned int in_num,
void *data)
{
return vq->vq_ops->add_buf(vq, sg, out_num, in_num, data);
}
static inline int void virtqueue_kick(struct virtqueue *vq) bool virtqueue_enable_cb(struct virtqueue *vq);
{
return vq->vq_ops->kick(vq);
}
static inline void *virtqueue_get_buf(struct virtqueue *vq, unsigned int *len) void *virtqueue_detach_unused_buf(struct virtqueue *vq);
{
return vq->vq_ops->get_buf(vq, len);
}
static inline void virtqueue_disable_cb(struct virtqueue *vq)
{
vq->vq_ops->disable_cb(vq);
}
static inline bool virtqueue_enable_cb(struct virtqueue *vq)
{
return vq->vq_ops->enable_cb(vq);
}
static inline void *virtqueue_detach_unused_buf(struct virtqueue *vq)
{
return vq->vq_ops->detach_unused_buf(vq);
}
/** /**
* virtio_device - representation of a device using virtio * virtio_device - representation of a device using virtio