| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Message-Id: <20230602092206.50108-7-xuanzhuo@linux.alibaba.com>
Date: Fri, 2 Jun 2023 17:22:02 +0800
From: Xuan Zhuo <xuanzhuo@...ux.alibaba.com>
To: virtualization@...ts.linux-foundation.org
Cc: "Michael S. Tsirkin" <mst@...hat.com>,
Jason Wang <jasowang@...hat.com>,
Xuan Zhuo <xuanzhuo@...ux.alibaba.com>,
"David S. Miller" <davem@...emloft.net>,
Eric Dumazet <edumazet@...gle.com>,
Jakub Kicinski <kuba@...nel.org>,
Paolo Abeni <pabeni@...hat.com>,
Alexei Starovoitov <ast@...nel.org>,
Daniel Borkmann <daniel@...earbox.net>,
Jesper Dangaard Brouer <hawk@...nel.org>,
John Fastabend <john.fastabend@...il.com>,
netdev@...r.kernel.org,
bpf@...r.kernel.org
Subject: [PATCH vhost v10 06/10] virtio_ring: packed-detach: support return dma info to driver
Under the premapped mode, the driver needs to unmap the DMA address
after receiving the buffer. The virtio core records the DMA address,
so the driver needs a way to get the dma info from the virtio core.
A straightforward approach is to pass an array to the virtio core when
calling virtqueue_get_buf(). However, it is not feasible when there are
multiple DMA addresses in the descriptor chain, and the array size is
unknown.
To solve this problem, a helper be introduced. After calling
virtqueue_get_buf(), the driver can call the helper to
retrieve a dma info. If the helper function returns -EAGAIN, it means
that there are more DMA addresses to be processed, and the driver should
call the helper function again. To keep track of the current position in
the chain, a cursor must be passed to the helper function, which is
initialized by virtqueue_get_buf().
Some processes are done inside this helper, so this helper MUST be
called under the premapped mode.
Signed-off-by: Xuan Zhuo <xuanzhuo@...ux.alibaba.com>
---
drivers/virtio/virtio_ring.c | 105 ++++++++++++++++++++++++++++++++---
include/linux/virtio.h | 9 ++-
2 files changed, 103 insertions(+), 11 deletions(-)
diff --git a/drivers/virtio/virtio_ring.c b/drivers/virtio/virtio_ring.c
index cdc4349f6066..cbc22daae7e1 100644
--- a/drivers/virtio/virtio_ring.c
+++ b/drivers/virtio/virtio_ring.c
@@ -1695,8 +1695,85 @@ static bool virtqueue_kick_prepare_packed(struct virtqueue *_vq)
return needs_kick;
}
+static void detach_cursor_init_packed(struct vring_virtqueue *vq,
+ struct virtqueue_detach_cursor *cursor, u16 id)
+{
+ struct vring_desc_state_packed *state = NULL;
+ u32 len;
+
+ state = &vq->packed.desc_state[id];
+
+ /* Clear data ptr. */
+ state->data = NULL;
+
+ vq->packed.desc_extra[state->last].next = vq->free_head;
+ vq->free_head = id;
+ vq->vq.num_free += state->num;
+
+ /* init cursor */
+ cursor->curr = id;
+ cursor->done = 0;
+ cursor->pos = 0;
+
+ if (vq->packed.desc_extra[id].flags & VRING_DESC_F_INDIRECT) {
+ len = vq->split.desc_extra[id].len;
+
+ cursor->num = len / sizeof(struct vring_packed_desc);
+ cursor->indirect = true;
+
+ vring_unmap_extra_packed(vq, &vq->packed.desc_extra[id]);
+ } else {
+ cursor->num = state->num;
+ cursor->indirect = false;
+ }
+}
+
+static int virtqueue_detach_packed(struct virtqueue *_vq, struct virtqueue_detach_cursor *cursor,
+ dma_addr_t *addr, u32 *len, enum dma_data_direction *dir)
+{
+ struct vring_virtqueue *vq = to_vvq(_vq);
+
+ if (unlikely(cursor->done))
+ return -EINVAL;
+
+ if (!cursor->indirect) {
+ struct vring_desc_extra *extra;
+
+ extra = &vq->packed.desc_extra[cursor->curr];
+ cursor->curr = extra->next;
+
+ *addr = extra->addr;
+ *len = extra->len;
+ *dir = (extra->flags & VRING_DESC_F_WRITE) ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
+
+ if (++cursor->pos == cursor->num) {
+ cursor->done = true;
+ return 0;
+ }
+ } else {
+ struct vring_packed_desc *indir_desc, *desc;
+ u16 flags;
+
+ indir_desc = vq->packed.desc_state[cursor->curr].indir_desc;
+ desc = &indir_desc[cursor->pos];
+
+ flags = le16_to_cpu(desc->flags);
+ *addr = le64_to_cpu(desc->addr);
+ *len = le32_to_cpu(desc->len);
+ *dir = (flags & VRING_DESC_F_WRITE) ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
+
+ if (++cursor->pos == cursor->num) {
+ kfree(indir_desc);
+ cursor->done = true;
+ return 0;
+ }
+ }
+
+ return -EAGAIN;
+}
+
static void detach_buf_packed(struct vring_virtqueue *vq,
- unsigned int id, void **ctx)
+ unsigned int id)
{
struct vring_desc_state_packed *state = NULL;
struct vring_packed_desc *desc;
@@ -1736,8 +1813,6 @@ static void detach_buf_packed(struct vring_virtqueue *vq,
}
kfree(desc);
state->indir_desc = NULL;
- } else if (ctx) {
- *ctx = state->indir_desc;
}
}
@@ -1768,7 +1843,8 @@ static bool more_used_packed(const struct vring_virtqueue *vq)
static void *virtqueue_get_buf_ctx_packed(struct virtqueue *_vq,
unsigned int *len,
- void **ctx)
+ void **ctx,
+ struct virtqueue_detach_cursor *cursor)
{
struct vring_virtqueue *vq = to_vvq(_vq);
u16 last_used, id, last_used_idx;
@@ -1808,7 +1884,14 @@ static void *virtqueue_get_buf_ctx_packed(struct virtqueue *_vq,
/* detach_buf_packed clears data, so grab it now. */
ret = vq->packed.desc_state[id].data;
- detach_buf_packed(vq, id, ctx);
+
+ if (!vq->indirect && ctx)
+ *ctx = vq->packed.desc_state[id].indir_desc;
+
+ if (vq->premapped)
+ detach_cursor_init_packed(vq, cursor, id);
+ else
+ detach_buf_packed(vq, id);
last_used += vq->packed.desc_state[id].num;
if (unlikely(last_used >= vq->packed.vring.num)) {
@@ -1960,7 +2043,8 @@ static bool virtqueue_enable_cb_delayed_packed(struct virtqueue *_vq)
return true;
}
-static void *virtqueue_detach_unused_buf_packed(struct virtqueue *_vq)
+static void *virtqueue_detach_unused_buf_packed(struct virtqueue *_vq,
+ struct virtqueue_detach_cursor *cursor)
{
struct vring_virtqueue *vq = to_vvq(_vq);
unsigned int i;
@@ -1973,7 +2057,10 @@ static void *virtqueue_detach_unused_buf_packed(struct virtqueue *_vq)
continue;
/* detach_buf clears data, so grab it now. */
buf = vq->packed.desc_state[i].data;
- detach_buf_packed(vq, i, NULL);
+ if (vq->premapped)
+ detach_cursor_init_packed(vq, cursor, i);
+ else
+ detach_buf_packed(vq, i);
END_USE(vq);
return buf;
}
@@ -2458,7 +2545,7 @@ void *virtqueue_get_buf_ctx(struct virtqueue *_vq, unsigned int *len,
{
struct vring_virtqueue *vq = to_vvq(_vq);
- return vq->packed_ring ? virtqueue_get_buf_ctx_packed(_vq, len, ctx) :
+ return vq->packed_ring ? virtqueue_get_buf_ctx_packed(_vq, len, ctx, NULL) :
virtqueue_get_buf_ctx_split(_vq, len, ctx, NULL);
}
EXPORT_SYMBOL_GPL(virtqueue_get_buf_ctx);
@@ -2590,7 +2677,7 @@ void *virtqueue_detach_unused_buf(struct virtqueue *_vq)
{
struct vring_virtqueue *vq = to_vvq(_vq);
- return vq->packed_ring ? virtqueue_detach_unused_buf_packed(_vq) :
+ return vq->packed_ring ? virtqueue_detach_unused_buf_packed(_vq, NULL) :
virtqueue_detach_unused_buf_split(_vq, NULL);
}
EXPORT_SYMBOL_GPL(virtqueue_detach_unused_buf);
diff --git a/include/linux/virtio.h b/include/linux/virtio.h
index eb4a4e4329aa..7f137c7a9034 100644
--- a/include/linux/virtio.h
+++ b/include/linux/virtio.h
@@ -43,8 +43,13 @@ struct virtqueue_detach_cursor {
unsigned done:1;
unsigned hole:14;
- /* for split head */
- unsigned head:16;
+ union {
+ /* for split head */
+ unsigned head:16;
+
+ /* for packed id */
+ unsigned curr:16;
+ };
unsigned num:16;
unsigned pos:16;
};
--
2.32.0.3.g01195cf9f
Powered by blists - more mailing lists