ShuriZma
/
xemu
mirror of https://github.com/xemu-project/xemu.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

file-posix: Reorganise RawPosixAIOData 

RawPosixAIOData contains a lot of fields for several separate operations
that are to be processed in a worker thread and that need different
parameters. The struct is currently rather unorganised, with unions that
cover some, but not all operations, and even one #define for field names
instead of a union.

Clean this up to have some common fields and a single union. As a side
effect, on x86_64 the struct shrinks from 72 to 48 bytes.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
This commit is contained in:
Kevin Wolf 2018-10-25 16:21:14 +01:00
parent e23c9d7a1c
commit d57c44d00f
1 changed files with 50 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

91
block/file-posix.c
View File

@ -182,25 +182,29 @@ static int64_t raw_getlength(BlockDriverState *bs);
typedef struct RawPosixAIOData { typedef struct RawPosixAIOData {
BlockDriverState *bs; BlockDriverState *bs;
int aio_fildes;
union {
struct iovec *aio_iov;
void *aio_ioctl_buf;
};
int aio_niov;
uint64_t aio_nbytes;
#define aio_ioctl_cmd aio_nbytes /* for QEMU_AIO_IOCTL */
off_t aio_offset;
int aio_type; int aio_type;
int aio_fildes;
off_t aio_offset;
uint64_t aio_nbytes;
union { union {
struct {
struct iovec *iov;
int niov;
} io;
struct {
uint64_t cmd;
void *buf;
} ioctl;
struct { struct {
int aio_fd2; int aio_fd2;
off_t aio_offset2; off_t aio_offset2;
}; } copy_range;
struct { struct {
PreallocMode prealloc; PreallocMode prealloc;
Error **errp; Error **errp;
}; } truncate;
}; };
} RawPosixAIOData; } RawPosixAIOData;
@ -1152,7 +1156,7 @@ static ssize_t handle_aiocb_ioctl(RawPosixAIOData *aiocb)
{ {
int ret; int ret;
ret = ioctl(aiocb->aio_fildes, aiocb->aio_ioctl_cmd, aiocb->aio_ioctl_buf); ret = ioctl(aiocb->aio_fildes, aiocb->ioctl.cmd, aiocb->ioctl.buf);
if (ret == -1) { if (ret == -1) {
return -errno; return -errno;
} }
@ -1233,13 +1237,13 @@ static ssize_t handle_aiocb_rw_vector(RawPosixAIOData *aiocb)
do { do {
if (aiocb->aio_type & QEMU_AIO_WRITE) if (aiocb->aio_type & QEMU_AIO_WRITE)
len = qemu_pwritev(aiocb->aio_fildes, len = qemu_pwritev(aiocb->aio_fildes,
aiocb->aio_iov, aiocb->io.iov,
aiocb->aio_niov, aiocb->io.niov,
aiocb->aio_offset); aiocb->aio_offset);
else else
len = qemu_preadv(aiocb->aio_fildes, len = qemu_preadv(aiocb->aio_fildes,
aiocb->aio_iov, aiocb->io.iov,
aiocb->aio_niov, aiocb->io.niov,
aiocb->aio_offset); aiocb->aio_offset);
} while (len == -1 && errno == EINTR); } while (len == -1 && errno == EINTR);
@ -1305,8 +1309,8 @@ static ssize_t handle_aiocb_rw(RawPosixAIOData *aiocb)
* If there is just a single buffer, and it is properly aligned * If there is just a single buffer, and it is properly aligned
* we can just use plain pread/pwrite without any problems. * we can just use plain pread/pwrite without any problems.
*/ */
if (aiocb->aio_niov == 1) { if (aiocb->io.niov == 1) {
return handle_aiocb_rw_linear(aiocb, aiocb->aio_iov->iov_base); return handle_aiocb_rw_linear(aiocb, aiocb->io.iov->iov_base);
} }
/* /*
* We have more than one iovec, and all are properly aligned. * We have more than one iovec, and all are properly aligned.
@ -1343,9 +1347,9 @@ static ssize_t handle_aiocb_rw(RawPosixAIOData *aiocb)
char *p = buf; char *p = buf;
int i; int i;
for (i = 0; i < aiocb->aio_niov; ++i) { for (i = 0; i < aiocb->io.niov; ++i) {
memcpy(p, aiocb->aio_iov[i].iov_base, aiocb->aio_iov[i].iov_len); memcpy(p, aiocb->io.iov[i].iov_base, aiocb->io.iov[i].iov_len);
p += aiocb->aio_iov[i].iov_len; p += aiocb->io.iov[i].iov_len;
} }
assert(p - buf == aiocb->aio_nbytes); assert(p - buf == aiocb->aio_nbytes);
} }
@ -1356,12 +1360,12 @@ static ssize_t handle_aiocb_rw(RawPosixAIOData *aiocb)
size_t count = aiocb->aio_nbytes, copy; size_t count = aiocb->aio_nbytes, copy;
int i; int i;
for (i = 0; i < aiocb->aio_niov && count; ++i) { for (i = 0; i < aiocb->io.niov && count; ++i) {
copy = count; copy = count;
if (copy > aiocb->aio_iov[i].iov_len) { if (copy > aiocb->io.iov[i].iov_len) {
copy = aiocb->aio_iov[i].iov_len; copy = aiocb->io.iov[i].iov_len;
} }
memcpy(aiocb->aio_iov[i].iov_base, p, copy); memcpy(aiocb->io.iov[i].iov_base, p, copy);
assert(count >= copy); assert(count >= copy);
p += copy; p += copy;
count -= copy; count -= copy;
@ -1572,14 +1576,15 @@ static ssize_t handle_aiocb_copy_range(RawPosixAIOData *aiocb)
{ {
uint64_t bytes = aiocb->aio_nbytes; uint64_t bytes = aiocb->aio_nbytes;
off_t in_off = aiocb->aio_offset; off_t in_off = aiocb->aio_offset;
off_t out_off = aiocb->aio_offset2; off_t out_off = aiocb->copy_range.aio_offset2;
while (bytes) { while (bytes) {
ssize_t ret = copy_file_range(aiocb->aio_fildes, &in_off, ssize_t ret = copy_file_range(aiocb->aio_fildes, &in_off,
aiocb->aio_fd2, &out_off, aiocb->copy_range.aio_fd2, &out_off,
bytes, 0); bytes, 0);
trace_file_copy_file_range(aiocb->bs, aiocb->aio_fildes, in_off, trace_file_copy_file_range(aiocb->bs, aiocb->aio_fildes, in_off,
aiocb->aio_fd2, out_off, bytes, 0, ret); aiocb->copy_range.aio_fd2, out_off, bytes,
0, ret);
if (ret == 0) { if (ret == 0) {
/* No progress (e.g. when beyond EOF), let the caller fall back to /* No progress (e.g. when beyond EOF), let the caller fall back to
* buffer I/O. */ * buffer I/O. */
@ -1648,7 +1653,8 @@ static int handle_aiocb_truncate(RawPosixAIOData *aiocb)
struct stat st; struct stat st;
int fd = aiocb->aio_fildes; int fd = aiocb->aio_fildes;
int64_t offset = aiocb->aio_offset; int64_t offset = aiocb->aio_offset;
Error **errp = aiocb->errp; PreallocMode prealloc = aiocb->truncate.prealloc;
Error **errp = aiocb->truncate.errp;
if (fstat(fd, &st) < 0) { if (fstat(fd, &st) < 0) {
result = -errno; result = -errno;
@ -1657,12 +1663,12 @@ static int handle_aiocb_truncate(RawPosixAIOData *aiocb)
} }
current_length = st.st_size; current_length = st.st_size;
if (current_length > offset && aiocb->prealloc != PREALLOC_MODE_OFF) { if (current_length > offset && prealloc != PREALLOC_MODE_OFF) {
error_setg(errp, "Cannot use preallocation for shrinking files"); error_setg(errp, "Cannot use preallocation for shrinking files");
return -ENOTSUP; return -ENOTSUP;
} }
switch (aiocb->prealloc) { switch (prealloc) {
#ifdef CONFIG_POSIX_FALLOCATE #ifdef CONFIG_POSIX_FALLOCATE
case PREALLOC_MODE_FALLOC: case PREALLOC_MODE_FALLOC:
/* /*
@ -1743,7 +1749,7 @@ static int handle_aiocb_truncate(RawPosixAIOData *aiocb)
default: default:
result = -ENOTSUP; result = -ENOTSUP;
error_setg(errp, "Unsupported preallocation mode: %s", error_setg(errp, "Unsupported preallocation mode: %s",
PreallocMode_str(aiocb->prealloc)); PreallocMode_str(prealloc));
return result; return result;
} }
@ -1768,7 +1774,7 @@ static int aio_worker(void *arg)
case QEMU_AIO_READ: case QEMU_AIO_READ:
ret = handle_aiocb_rw(aiocb); ret = handle_aiocb_rw(aiocb);
if (ret >= 0 && ret < aiocb->aio_nbytes) { if (ret >= 0 && ret < aiocb->aio_nbytes) {
iov_memset(aiocb->aio_iov, aiocb->aio_niov, ret, iov_memset(aiocb->io.iov, aiocb->io.niov, ret,
0, aiocb->aio_nbytes - ret); 0, aiocb->aio_nbytes - ret);
ret = aiocb->aio_nbytes; ret = aiocb->aio_nbytes;
@ -1829,16 +1835,17 @@ static int paio_submit_co_full(BlockDriverState *bs, int fd,
acb->bs = bs; acb->bs = bs;
acb->aio_type = type; acb->aio_type = type;
acb->aio_fildes = fd; acb->aio_fildes = fd;
acb->aio_fd2 = fd2;
acb->aio_offset2 = offset2;
acb->aio_nbytes = bytes; acb->aio_nbytes = bytes;
acb->aio_offset = offset; acb->aio_offset = offset;
if (qiov) { if (qiov) {
acb->aio_iov = qiov->iov; acb->io.iov = qiov->iov;
acb->aio_niov = qiov->niov; acb->io.niov = qiov->niov;
assert(qiov->size == bytes); assert(qiov->size == bytes);
} else {
acb->copy_range.aio_fd2 = fd2;
acb->copy_range.aio_offset2 = offset2;
} }
trace_file_paio_submit_co(offset, bytes, type); trace_file_paio_submit_co(offset, bytes, type);
@ -1976,8 +1983,10 @@ raw_regular_truncate(BlockDriverState *bs, int fd, int64_t offset,
.aio_fildes = fd, .aio_fildes = fd,
.aio_type = QEMU_AIO_TRUNCATE, .aio_type = QEMU_AIO_TRUNCATE,
.aio_offset = offset, .aio_offset = offset,
.prealloc = prealloc, .truncate = {
.errp = errp, .prealloc = prealloc,
.errp = errp,
},
}; };
/* @bs can be NULL, bdrv_get_aio_context() returns the main context then */ /* @bs can be NULL, bdrv_get_aio_context() returns the main context then */
@ -3089,8 +3098,8 @@ static BlockAIOCB *hdev_aio_ioctl(BlockDriverState *bs,
acb->aio_type = QEMU_AIO_IOCTL; acb->aio_type = QEMU_AIO_IOCTL;
acb->aio_fildes = s->fd; acb->aio_fildes = s->fd;
acb->aio_offset = 0; acb->aio_offset = 0;
acb->aio_ioctl_buf = buf; acb->ioctl.buf = buf;
acb->aio_ioctl_cmd = req; acb->ioctl.cmd = req;
pool = aio_get_thread_pool(bdrv_get_aio_context(bs)); pool = aio_get_thread_pool(bdrv_get_aio_context(bs));
return thread_pool_submit_aio(pool, aio_worker, acb, cb, opaque); return thread_pool_submit_aio(pool, aio_worker, acb, cb, opaque);
} }