motorhead/qemu
1
0
Fork 0
mirror of https://github.com/Motorhead1991/qemu.git synced 2025-08-04 08:13:54 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions

block/export: consolidate request structs into VuBlockReq

Browse source 
Only one struct is needed per request. Drop req_data and the separate
VuBlockReq instance. Instead let vu_queue_pop() allocate everything at
once.

This fixes the req_data memory leak in vu_block_virtio_process_req().

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20200924151549.913737-6-stefanha@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
This commit is contained in:
Stefan Hajnoczi 2020-09-24 16:15:41 +01:00
parent dad4f19431
commit df6af7ce77
1 changed files with 21 additions and 47 deletions
Download patch file Download diff file Expand all files Collapse all files

68
block/export/vhost-user-blk-server.c
View file

@ -25,7 +25,7 @@ struct virtio_blk_inhdr {
}; };
typedef struct VuBlockReq { typedef struct VuBlockReq {
VuVirtqElement *elem; VuVirtqElement elem;
int64_t sector_num; int64_t sector_num;
size_t size; size_t size;
struct virtio_blk_inhdr *in; struct virtio_blk_inhdr *in;
@ -39,14 +39,10 @@ static void vu_block_req_complete(VuBlockReq *req)
VuDev *vu_dev = &req->server->vu_dev; VuDev *vu_dev = &req->server->vu_dev;
/* IO size with 1 extra status byte */ /* IO size with 1 extra status byte */
vu_queue_push(vu_dev, req->vq, req->elem, req->size + 1); vu_queue_push(vu_dev, req->vq, &req->elem, req->size + 1);
vu_queue_notify(vu_dev, req->vq); vu_queue_notify(vu_dev, req->vq);
if (req->elem) { free(req);
free(req->elem);
}
g_free(req);
} }
static VuBlockDev *get_vu_block_device_by_server(VuServer *server) static VuBlockDev *get_vu_block_device_by_server(VuServer *server)
@ -89,20 +85,12 @@ static void coroutine_fn vu_block_flush(VuBlockReq *req)
blk_co_flush(backend); blk_co_flush(backend);
} }
struct req_data {
VuServer *server;
VuVirtq *vq;
VuVirtqElement *elem;
};
static void coroutine_fn vu_block_virtio_process_req(void *opaque) static void coroutine_fn vu_block_virtio_process_req(void *opaque)
{ {
struct req_data *data = opaque; VuBlockReq *req = opaque;
VuServer *server = data->server; VuServer *server = req->server;
VuVirtq *vq = data->vq; VuVirtqElement *elem = &req->elem;
VuVirtqElement *elem = data->elem;
uint32_t type; uint32_t type;
VuBlockReq *req;
VuBlockDev *vdev_blk = get_vu_block_device_by_server(server); VuBlockDev *vdev_blk = get_vu_block_device_by_server(server);
BlockBackend *backend = vdev_blk->backend; BlockBackend *backend = vdev_blk->backend;
@ -111,18 +99,13 @@ static void coroutine_fn vu_block_virtio_process_req(void *opaque)
struct iovec *out_iov = elem->out_sg; struct iovec *out_iov = elem->out_sg;
unsigned in_num = elem->in_num; unsigned in_num = elem->in_num;
unsigned out_num = elem->out_num; unsigned out_num = elem->out_num;
/* refer to hw/block/virtio_blk.c */ /* refer to hw/block/virtio_blk.c */
if (elem->out_num < 1 || elem->in_num < 1) { if (elem->out_num < 1 || elem->in_num < 1) {
error_report("virtio-blk request missing headers"); error_report("virtio-blk request missing headers");
free(elem); goto err;
return;
} }
req = g_new0(VuBlockReq, 1);
req->server = server;
req->vq = vq;
req->elem = elem;
if (unlikely(iov_to_buf(out_iov, out_num, 0, &req->out, if (unlikely(iov_to_buf(out_iov, out_num, 0, &req->out,
sizeof(req->out)) != sizeof(req->out))) { sizeof(req->out)) != sizeof(req->out))) {
error_report("virtio-blk request outhdr too short"); error_report("virtio-blk request outhdr too short");
@ -202,36 +185,27 @@ static void coroutine_fn vu_block_virtio_process_req(void *opaque)
err: err:
free(elem); free(elem);
g_free(req);
return;
} }
static void vu_block_process_vq(VuDev *vu_dev, int idx) static void vu_block_process_vq(VuDev *vu_dev, int idx)
{ {
VuServer *server; VuServer *server = container_of(vu_dev, VuServer, vu_dev);
VuVirtq *vq; VuVirtq *vq = vu_get_queue(vu_dev, idx);
struct req_data *req_data;
server = container_of(vu_dev, VuServer, vu_dev);
assert(server);
vq = vu_get_queue(vu_dev, idx);
assert(vq);
VuVirtqElement *elem;
while (1) { while (1) {
elem = vu_queue_pop(vu_dev, vq, sizeof(VuVirtqElement) + VuBlockReq *req;
sizeof(VuBlockReq));
if (elem) { req = vu_queue_pop(vu_dev, vq, sizeof(VuBlockReq));
req_data = g_new0(struct req_data, 1); if (!req) {
req_data->server = server;
req_data->vq = vq;
req_data->elem = elem;
Coroutine *co = qemu_coroutine_create(vu_block_virtio_process_req,
req_data);
aio_co_enter(server->ioc->ctx, co);
} else {
break; break;
} }
req->server = server;
req->vq = vq;
Coroutine *co =
qemu_coroutine_create(vu_block_virtio_process_req, req);
qemu_coroutine_enter(co);
} }
} }