mirrors/qemu
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

aio: drop io_flush argument

Browse Source 
The .io_flush() handler no longer exists and has no users.  Drop the
io_flush argument to aio_set_fd_handler() and related functions.

The AioFlushEventNotifierHandler and AioFlushHandler typedefs are no
longer used and are dropped too.

Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
This commit is contained in:
Stefan Hajnoczi 2013-04-11 17:26:25 +02:00
parent 1b9ecdb164
commit f2e5dca46b
16 changed files with 61 additions and 88 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
aio-posix.c
View File

@ -46,7 +46,6 @@ void aio_set_fd_handler(AioContext *ctx,
int fd, int fd,
IOHandler *io_read, IOHandler *io_read,
IOHandler *io_write, IOHandler *io_write,
AioFlushHandler *io_flush,
void *opaque) void *opaque)
{ {
AioHandler *node; AioHandler *node;
@ -95,12 +94,10 @@ void aio_set_fd_handler(AioContext *ctx,
void aio_set_event_notifier(AioContext *ctx, void aio_set_event_notifier(AioContext *ctx,
EventNotifier *notifier, EventNotifier *notifier,
EventNotifierHandler *io_read, EventNotifierHandler *io_read)
AioFlushEventNotifierHandler *io_flush)
{ {
aio_set_fd_handler(ctx, event_notifier_get_fd(notifier), aio_set_fd_handler(ctx, event_notifier_get_fd(notifier),
(IOHandler *)io_read, NULL, (IOHandler *)io_read, NULL, notifier);
(AioFlushHandler *)io_flush, notifier);
} }
bool aio_pending(AioContext *ctx) bool aio_pending(AioContext *ctx)

3
aio-win32.c
View File

@ -30,8 +30,7 @@ struct AioHandler {
void aio_set_event_notifier(AioContext *ctx, void aio_set_event_notifier(AioContext *ctx,
EventNotifier *e, EventNotifier *e,
EventNotifierHandler *io_notify, EventNotifierHandler *io_notify)
AioFlushEventNotifierHandler *io_flush)
{ {
AioHandler *node; AioHandler *node;

4
async.c
View File

@ -201,7 +201,7 @@ aio_ctx_finalize(GSource *source)
AioContext *ctx = (AioContext *) source; AioContext *ctx = (AioContext *) source;
thread_pool_free(ctx->thread_pool); thread_pool_free(ctx->thread_pool);
aio_set_event_notifier(ctx, &ctx->notifier, NULL, NULL); aio_set_event_notifier(ctx, &ctx->notifier, NULL);
event_notifier_cleanup(&ctx->notifier); event_notifier_cleanup(&ctx->notifier);
qemu_mutex_destroy(&ctx->bh_lock); qemu_mutex_destroy(&ctx->bh_lock);
g_array_free(ctx->pollfds, TRUE); g_array_free(ctx->pollfds, TRUE);
@ -243,7 +243,7 @@ AioContext *aio_context_new(void)
event_notifier_init(&ctx->notifier, false); event_notifier_init(&ctx->notifier, false);
aio_set_event_notifier(ctx, &ctx->notifier, aio_set_event_notifier(ctx, &ctx->notifier,
(EventNotifierHandler *) (EventNotifierHandler *)
event_notifier_test_and_clear, NULL); event_notifier_test_and_clear);
return ctx; return ctx;
} }

9
block/curl.c
View File

@ -93,17 +93,16 @@ static int curl_sock_cb(CURL *curl, curl_socket_t fd, int action,
DPRINTF("CURL (AIO): Sock action %d on fd %d\n", action, fd); DPRINTF("CURL (AIO): Sock action %d on fd %d\n", action, fd);
switch (action) { switch (action) {
case CURL_POLL_IN: case CURL_POLL_IN:
qemu_aio_set_fd_handler(fd, curl_multi_do, NULL, NULL, s); qemu_aio_set_fd_handler(fd, curl_multi_do, NULL, s);
break; break;
case CURL_POLL_OUT: case CURL_POLL_OUT:
qemu_aio_set_fd_handler(fd, NULL, curl_multi_do, NULL, s); qemu_aio_set_fd_handler(fd, NULL, curl_multi_do, s);
break; break;
case CURL_POLL_INOUT: case CURL_POLL_INOUT:
qemu_aio_set_fd_handler(fd, curl_multi_do, curl_multi_do, qemu_aio_set_fd_handler(fd, curl_multi_do, curl_multi_do, s);
NULL, s);
break; break;
case CURL_POLL_REMOVE: case CURL_POLL_REMOVE:
qemu_aio_set_fd_handler(fd, NULL, NULL, NULL, NULL); qemu_aio_set_fd_handler(fd, NULL, NULL, NULL);
break; break;
} }

7
block/gluster.c
View File

@ -339,7 +339,7 @@ static int qemu_gluster_open(BlockDriverState *bs, QDict *options,
} }
fcntl(s->fds[GLUSTER_FD_READ], F_SETFL, O_NONBLOCK); fcntl(s->fds[GLUSTER_FD_READ], F_SETFL, O_NONBLOCK);
qemu_aio_set_fd_handler(s->fds[GLUSTER_FD_READ], qemu_aio_set_fd_handler(s->fds[GLUSTER_FD_READ],
qemu_gluster_aio_event_reader, NULL, NULL, s); qemu_gluster_aio_event_reader, NULL, s);
out: out:
qemu_opts_del(opts); qemu_opts_del(opts);
@ -438,8 +438,7 @@ static void gluster_finish_aiocb(struct glfs_fd *fd, ssize_t ret, void *arg)
qemu_aio_release(acb); qemu_aio_release(acb);
close(s->fds[GLUSTER_FD_READ]); close(s->fds[GLUSTER_FD_READ]);
close(s->fds[GLUSTER_FD_WRITE]); close(s->fds[GLUSTER_FD_WRITE]);
qemu_aio_set_fd_handler(s->fds[GLUSTER_FD_READ], NULL, NULL, NULL, qemu_aio_set_fd_handler(s->fds[GLUSTER_FD_READ], NULL, NULL, NULL);
NULL);
bs->drv = NULL; /* Make the disk inaccessible */ bs->drv = NULL; /* Make the disk inaccessible */
qemu_mutex_unlock_iothread(); qemu_mutex_unlock_iothread();
} }
@ -595,7 +594,7 @@ static void qemu_gluster_close(BlockDriverState *bs)
close(s->fds[GLUSTER_FD_READ]); close(s->fds[GLUSTER_FD_READ]);
close(s->fds[GLUSTER_FD_WRITE]); close(s->fds[GLUSTER_FD_WRITE]);
qemu_aio_set_fd_handler(s->fds[GLUSTER_FD_READ], NULL, NULL, NULL, NULL); qemu_aio_set_fd_handler(s->fds[GLUSTER_FD_READ], NULL, NULL, NULL);
if (s->fd) { if (s->fd) {
glfs_close(s->fd); glfs_close(s->fd);

3
block/iscsi.c
View File

@ -159,7 +159,6 @@ iscsi_set_events(IscsiLun *iscsilun)
qemu_aio_set_fd_handler(iscsi_get_fd(iscsi), qemu_aio_set_fd_handler(iscsi_get_fd(iscsi),
iscsi_process_read, iscsi_process_read,
(ev & POLLOUT) ? iscsi_process_write : NULL, (ev & POLLOUT) ? iscsi_process_write : NULL,
NULL,
iscsilun); iscsilun);
} }
@ -1208,7 +1207,7 @@ static void iscsi_close(BlockDriverState *bs)
qemu_del_timer(iscsilun->nop_timer); qemu_del_timer(iscsilun->nop_timer);
qemu_free_timer(iscsilun->nop_timer); qemu_free_timer(iscsilun->nop_timer);
} }
qemu_aio_set_fd_handler(iscsi_get_fd(iscsi), NULL, NULL, NULL, NULL); qemu_aio_set_fd_handler(iscsi_get_fd(iscsi), NULL, NULL, NULL);
iscsi_destroy_context(iscsi); iscsi_destroy_context(iscsi);
memset(iscsilun, 0, sizeof(IscsiLun)); memset(iscsilun, 0, sizeof(IscsiLun));
} }

3
block/linux-aio.c
View File

@ -190,8 +190,7 @@ void *laio_init(void)
goto out_close_efd; goto out_close_efd;
} }
qemu_aio_set_event_notifier(&s->e, qemu_laio_completion_cb, qemu_aio_set_event_notifier(&s->e, qemu_laio_completion_cb);
NULL);
return s; return s;

11
block/nbd.c
View File

@ -334,8 +334,7 @@ static int nbd_co_send_request(BDRVNBDState *s, struct nbd_request *request,
qemu_co_mutex_lock(&s->send_mutex); qemu_co_mutex_lock(&s->send_mutex);
s->send_coroutine = qemu_coroutine_self(); s->send_coroutine = qemu_coroutine_self();
qemu_aio_set_fd_handler(s->sock, nbd_reply_ready, nbd_restart_write, qemu_aio_set_fd_handler(s->sock, nbd_reply_ready, nbd_restart_write, s);
NULL, s);
if (qiov) { if (qiov) {
if (!s->is_unix) { if (!s->is_unix) {
socket_set_cork(s->sock, 1); socket_set_cork(s->sock, 1);
@ -354,8 +353,7 @@ static int nbd_co_send_request(BDRVNBDState *s, struct nbd_request *request,
} else { } else {
rc = nbd_send_request(s->sock, request); rc = nbd_send_request(s->sock, request);
} }
qemu_aio_set_fd_handler(s->sock, nbd_reply_ready, NULL, qemu_aio_set_fd_handler(s->sock, nbd_reply_ready, NULL, s);
NULL, s);
s->send_coroutine = NULL; s->send_coroutine = NULL;
qemu_co_mutex_unlock(&s->send_mutex); qemu_co_mutex_unlock(&s->send_mutex);
return rc; return rc;
@ -431,8 +429,7 @@ static int nbd_establish_connection(BlockDriverState *bs)
/* Now that we're connected, set the socket to be non-blocking and /* Now that we're connected, set the socket to be non-blocking and
* kick the reply mechanism. */ * kick the reply mechanism. */
qemu_set_nonblock(sock); qemu_set_nonblock(sock);
qemu_aio_set_fd_handler(sock, nbd_reply_ready, NULL, qemu_aio_set_fd_handler(sock, nbd_reply_ready, NULL, s);
NULL, s);
s->sock = sock; s->sock = sock;
s->size = size; s->size = size;
@ -452,7 +449,7 @@ static void nbd_teardown_connection(BlockDriverState *bs)
request.len = 0; request.len = 0;
nbd_send_request(s->sock, &request); nbd_send_request(s->sock, &request);
qemu_aio_set_fd_handler(s->sock, NULL, NULL, NULL, NULL); qemu_aio_set_fd_handler(s->sock, NULL, NULL, NULL);
closesocket(s->sock); closesocket(s->sock);
} }

4
block/rbd.c
View File

@ -545,7 +545,7 @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags)
fcntl(s->fds[0], F_SETFL, O_NONBLOCK); fcntl(s->fds[0], F_SETFL, O_NONBLOCK);
fcntl(s->fds[1], F_SETFL, O_NONBLOCK); fcntl(s->fds[1], F_SETFL, O_NONBLOCK);
qemu_aio_set_fd_handler(s->fds[RBD_FD_READ], qemu_rbd_aio_event_reader, qemu_aio_set_fd_handler(s->fds[RBD_FD_READ], qemu_rbd_aio_event_reader,
NULL, NULL, s); NULL, s);
qemu_opts_del(opts); qemu_opts_del(opts);
@ -569,7 +569,7 @@ static void qemu_rbd_close(BlockDriverState *bs)
close(s->fds[0]); close(s->fds[0]);
close(s->fds[1]); close(s->fds[1]);
qemu_aio_set_fd_handler(s->fds[RBD_FD_READ], NULL, NULL, NULL, NULL); qemu_aio_set_fd_handler(s->fds[RBD_FD_READ], NULL, NULL, NULL);
rbd_close(s->image); rbd_close(s->image);
rados_ioctx_destroy(s->io_ctx); rados_ioctx_destroy(s->io_ctx);

18
block/sheepdog.c
View File

@ -531,14 +531,14 @@ static coroutine_fn void do_co_req(void *opaque)
unsigned int *rlen = srco->rlen; unsigned int *rlen = srco->rlen;
co = qemu_coroutine_self(); co = qemu_coroutine_self();
qemu_aio_set_fd_handler(sockfd, NULL, restart_co_req, NULL, co); qemu_aio_set_fd_handler(sockfd, NULL, restart_co_req, co);
ret = send_co_req(sockfd, hdr, data, wlen); ret = send_co_req(sockfd, hdr, data, wlen);
if (ret < 0) { if (ret < 0) {
goto out; goto out;
} }
qemu_aio_set_fd_handler(sockfd, restart_co_req, NULL, NULL, co); qemu_aio_set_fd_handler(sockfd, restart_co_req, NULL, co);
ret = qemu_co_recv(sockfd, hdr, sizeof(*hdr)); ret = qemu_co_recv(sockfd, hdr, sizeof(*hdr));
if (ret < sizeof(*hdr)) { if (ret < sizeof(*hdr)) {
@ -563,7 +563,7 @@ static coroutine_fn void do_co_req(void *opaque)
out: out:
/* there is at most one request for this sockfd, so it is safe to /* there is at most one request for this sockfd, so it is safe to
* set each handler to NULL. */ * set each handler to NULL. */
qemu_aio_set_fd_handler(sockfd, NULL, NULL, NULL, NULL); qemu_aio_set_fd_handler(sockfd, NULL, NULL, NULL);
srco->ret = ret; srco->ret = ret;
srco->finished = true; srco->finished = true;
@ -804,7 +804,7 @@ static int get_sheep_fd(BDRVSheepdogState *s)
return fd; return fd;
} }
qemu_aio_set_fd_handler(fd, co_read_response, NULL, NULL, s); qemu_aio_set_fd_handler(fd, co_read_response, NULL, s);
return fd; return fd;
} }
@ -1054,8 +1054,7 @@ static int coroutine_fn add_aio_request(BDRVSheepdogState *s, AIOReq *aio_req,
qemu_co_mutex_lock(&s->lock); qemu_co_mutex_lock(&s->lock);
s->co_send = qemu_coroutine_self(); s->co_send = qemu_coroutine_self();
qemu_aio_set_fd_handler(s->fd, co_read_response, co_write_request, qemu_aio_set_fd_handler(s->fd, co_read_response, co_write_request, s);
NULL, s);
socket_set_cork(s->fd, 1); socket_set_cork(s->fd, 1);
/* send a header */ /* send a header */
@ -1076,8 +1075,7 @@ static int coroutine_fn add_aio_request(BDRVSheepdogState *s, AIOReq *aio_req,
} }
socket_set_cork(s->fd, 0); socket_set_cork(s->fd, 0);
qemu_aio_set_fd_handler(s->fd, co_read_response, NULL, qemu_aio_set_fd_handler(s->fd, co_read_response, NULL, s);
NULL, s);
qemu_co_mutex_unlock(&s->lock); qemu_co_mutex_unlock(&s->lock);
return 0; return 0;
@ -1335,7 +1333,7 @@ static int sd_open(BlockDriverState *bs, QDict *options, int flags)
g_free(buf); g_free(buf);
return 0; return 0;
out: out:
qemu_aio_set_fd_handler(s->fd, NULL, NULL, NULL, NULL); qemu_aio_set_fd_handler(s->fd, NULL, NULL, NULL);
if (s->fd >= 0) { if (s->fd >= 0) {
closesocket(s->fd); closesocket(s->fd);
} }
@ -1563,7 +1561,7 @@ static void sd_close(BlockDriverState *bs)
error_report("%s, %s", sd_strerror(rsp->result), s->name); error_report("%s, %s", sd_strerror(rsp->result), s->name);
} }
qemu_aio_set_fd_handler(s->fd, NULL, NULL, NULL, NULL); qemu_aio_set_fd_handler(s->fd, NULL, NULL, NULL);
closesocket(s->fd); closesocket(s->fd);
g_free(s->host_spec); g_free(s->host_spec);
} }

4
block/ssh.c
View File

@ -758,13 +758,13 @@ static coroutine_fn void set_fd_handler(BDRVSSHState *s)
DPRINTF("s->sock=%d rd_handler=%p wr_handler=%p", s->sock, DPRINTF("s->sock=%d rd_handler=%p wr_handler=%p", s->sock,
rd_handler, wr_handler); rd_handler, wr_handler);
qemu_aio_set_fd_handler(s->sock, rd_handler, wr_handler, NULL, co); qemu_aio_set_fd_handler(s->sock, rd_handler, wr_handler, co);
} }
static coroutine_fn void clear_fd_handler(BDRVSSHState *s) static coroutine_fn void clear_fd_handler(BDRVSSHState *s)
{ {
DPRINTF("s->sock=%d", s->sock); DPRINTF("s->sock=%d", s->sock);
qemu_aio_set_fd_handler(s->sock, NULL, NULL, NULL, NULL); qemu_aio_set_fd_handler(s->sock, NULL, NULL, NULL);
} }
/* A non-blocking call returned EAGAIN, so yield, ensuring the /* A non-blocking call returned EAGAIN, so yield, ensuring the

8
hw/block/dataplane/virtio-blk.c
View File

@ -472,7 +472,7 @@ void virtio_blk_data_plane_start(VirtIOBlockDataPlane *s)
exit(1); exit(1);
} }
s->host_notifier = *virtio_queue_get_host_notifier(vq); s->host_notifier = *virtio_queue_get_host_notifier(vq);
aio_set_event_notifier(s->ctx, &s->host_notifier, handle_notify, NULL); aio_set_event_notifier(s->ctx, &s->host_notifier, handle_notify);
/* Set up ioqueue */ /* Set up ioqueue */
ioq_init(&s->ioqueue, s->fd, REQ_MAX); ioq_init(&s->ioqueue, s->fd, REQ_MAX);
@ -480,7 +480,7 @@ void virtio_blk_data_plane_start(VirtIOBlockDataPlane *s)
ioq_put_iocb(&s->ioqueue, &s->requests[i].iocb); ioq_put_iocb(&s->ioqueue, &s->requests[i].iocb);
} }
s->io_notifier = *ioq_get_notifier(&s->ioqueue); s->io_notifier = *ioq_get_notifier(&s->ioqueue);
aio_set_event_notifier(s->ctx, &s->io_notifier, handle_io, NULL); aio_set_event_notifier(s->ctx, &s->io_notifier, handle_io);
s->started = true; s->started = true;
trace_virtio_blk_data_plane_start(s); trace_virtio_blk_data_plane_start(s);
@ -512,10 +512,10 @@ void virtio_blk_data_plane_stop(VirtIOBlockDataPlane *s)
qemu_thread_join(&s->thread); qemu_thread_join(&s->thread);
} }
aio_set_event_notifier(s->ctx, &s->io_notifier, NULL, NULL); aio_set_event_notifier(s->ctx, &s->io_notifier, NULL);
ioq_cleanup(&s->ioqueue); ioq_cleanup(&s->ioqueue);
aio_set_event_notifier(s->ctx, &s->host_notifier, NULL, NULL); aio_set_event_notifier(s->ctx, &s->host_notifier, NULL);
k->set_host_notifier(qbus->parent, 0, false); k->set_host_notifier(qbus->parent, 0, false);
aio_context_unref(s->ctx); aio_context_unref(s->ctx);

14
include/block/aio.h
View File

@ -74,9 +74,6 @@ typedef struct AioContext {
struct ThreadPool *thread_pool; struct ThreadPool *thread_pool;
} AioContext; } AioContext;
/* Returns 1 if there are still outstanding AIO requests; 0 otherwise */
typedef int (AioFlushEventNotifierHandler)(EventNotifier *e);
/** /**
* aio_context_new: Allocate a new AioContext. * aio_context_new: Allocate a new AioContext.
* *
@ -198,9 +195,6 @@ bool aio_pending(AioContext *ctx);
bool aio_poll(AioContext *ctx, bool blocking); bool aio_poll(AioContext *ctx, bool blocking);
#ifdef CONFIG_POSIX #ifdef CONFIG_POSIX
/* Returns 1 if there are still outstanding AIO requests; 0 otherwise */
typedef int (AioFlushHandler)(void *opaque);
/* Register a file descriptor and associated callbacks. Behaves very similarly /* Register a file descriptor and associated callbacks. Behaves very similarly
* to qemu_set_fd_handler2. Unlike qemu_set_fd_handler2, these callbacks will * to qemu_set_fd_handler2. Unlike qemu_set_fd_handler2, these callbacks will
* be invoked when using qemu_aio_wait(). * be invoked when using qemu_aio_wait().
@ -212,7 +206,6 @@ void aio_set_fd_handler(AioContext *ctx,
int fd, int fd,
IOHandler *io_read, IOHandler *io_read,
IOHandler *io_write, IOHandler *io_write,
AioFlushHandler *io_flush,
void *opaque); void *opaque);
#endif #endif
@ -225,8 +218,7 @@ void aio_set_fd_handler(AioContext *ctx,
*/ */
void aio_set_event_notifier(AioContext *ctx, void aio_set_event_notifier(AioContext *ctx,
EventNotifier *notifier, EventNotifier *notifier,
EventNotifierHandler *io_read, EventNotifierHandler *io_read);
AioFlushEventNotifierHandler *io_flush);
/* Return a GSource that lets the main loop poll the file descriptors attached /* Return a GSource that lets the main loop poll the file descriptors attached
* to this AioContext. * to this AioContext.
@ -240,14 +232,12 @@ struct ThreadPool *aio_get_thread_pool(AioContext *ctx);
bool qemu_aio_wait(void); bool qemu_aio_wait(void);
void qemu_aio_set_event_notifier(EventNotifier *notifier, void qemu_aio_set_event_notifier(EventNotifier *notifier,
EventNotifierHandler *io_read, EventNotifierHandler *io_read);
AioFlushEventNotifierHandler *io_flush);
#ifdef CONFIG_POSIX #ifdef CONFIG_POSIX
void qemu_aio_set_fd_handler(int fd, void qemu_aio_set_fd_handler(int fd,
IOHandler *io_read, IOHandler *io_read,
IOHandler *io_write, IOHandler *io_write,
AioFlushHandler *io_flush,
void *opaque); void *opaque);
#endif #endif

9
main-loop.c
View File

@ -489,17 +489,14 @@ bool qemu_aio_wait(void)
void qemu_aio_set_fd_handler(int fd, void qemu_aio_set_fd_handler(int fd,
IOHandler *io_read, IOHandler *io_read,
IOHandler *io_write, IOHandler *io_write,
AioFlushHandler *io_flush,
void *opaque) void *opaque)
{ {
aio_set_fd_handler(qemu_aio_context, fd, io_read, io_write, io_flush, aio_set_fd_handler(qemu_aio_context, fd, io_read, io_write, opaque);
opaque);
} }
#endif #endif
void qemu_aio_set_event_notifier(EventNotifier *notifier, void qemu_aio_set_event_notifier(EventNotifier *notifier,
EventNotifierHandler *io_read, EventNotifierHandler *io_read)
AioFlushEventNotifierHandler *io_flush)
{ {
aio_set_event_notifier(qemu_aio_context, notifier, io_read, io_flush); aio_set_event_notifier(qemu_aio_context, notifier, io_read);
} }

40
tests/test-aio.c
View File

@ -233,11 +233,11 @@ static void test_set_event_notifier(void)
{ {
EventNotifierTestData data = { .n = 0, .active = 0 }; EventNotifierTestData data = { .n = 0, .active = 0 };
event_notifier_init(&data.e, false); event_notifier_init(&data.e, false);
aio_set_event_notifier(ctx, &data.e, event_ready_cb, NULL); aio_set_event_notifier(ctx, &data.e, event_ready_cb);
g_assert(!aio_poll(ctx, false)); g_assert(!aio_poll(ctx, false));
g_assert_cmpint(data.n, ==, 0); g_assert_cmpint(data.n, ==, 0);
aio_set_event_notifier(ctx, &data.e, NULL, NULL); aio_set_event_notifier(ctx, &data.e, NULL);
g_assert(!aio_poll(ctx, false)); g_assert(!aio_poll(ctx, false));
g_assert_cmpint(data.n, ==, 0); g_assert_cmpint(data.n, ==, 0);
event_notifier_cleanup(&data.e); event_notifier_cleanup(&data.e);
@ -247,7 +247,7 @@ static void test_wait_event_notifier(void)
{ {
EventNotifierTestData data = { .n = 0, .active = 1 }; EventNotifierTestData data = { .n = 0, .active = 1 };
event_notifier_init(&data.e, false); event_notifier_init(&data.e, false);
aio_set_event_notifier(ctx, &data.e, event_ready_cb, NULL); aio_set_event_notifier(ctx, &data.e, event_ready_cb);
g_assert(!aio_poll(ctx, false)); g_assert(!aio_poll(ctx, false));
g_assert_cmpint(data.n, ==, 0); g_assert_cmpint(data.n, ==, 0);
g_assert_cmpint(data.active, ==, 1); g_assert_cmpint(data.active, ==, 1);
@ -261,7 +261,7 @@ static void test_wait_event_notifier(void)
g_assert_cmpint(data.n, ==, 1); g_assert_cmpint(data.n, ==, 1);
g_assert_cmpint(data.active, ==, 0); g_assert_cmpint(data.active, ==, 0);
aio_set_event_notifier(ctx, &data.e, NULL, NULL); aio_set_event_notifier(ctx, &data.e, NULL);
g_assert(!aio_poll(ctx, false)); g_assert(!aio_poll(ctx, false));
g_assert_cmpint(data.n, ==, 1); g_assert_cmpint(data.n, ==, 1);
@ -272,7 +272,7 @@ static void test_flush_event_notifier(void)
{ {
EventNotifierTestData data = { .n = 0, .active = 10, .auto_set = true }; EventNotifierTestData data = { .n = 0, .active = 10, .auto_set = true };
event_notifier_init(&data.e, false); event_notifier_init(&data.e, false);
aio_set_event_notifier(ctx, &data.e, event_ready_cb, NULL); aio_set_event_notifier(ctx, &data.e, event_ready_cb);
g_assert(!aio_poll(ctx, false)); g_assert(!aio_poll(ctx, false));
g_assert_cmpint(data.n, ==, 0); g_assert_cmpint(data.n, ==, 0);
g_assert_cmpint(data.active, ==, 10); g_assert_cmpint(data.active, ==, 10);
@ -288,7 +288,7 @@ static void test_flush_event_notifier(void)
g_assert_cmpint(data.active, ==, 0); g_assert_cmpint(data.active, ==, 0);
g_assert(!aio_poll(ctx, false)); g_assert(!aio_poll(ctx, false));
aio_set_event_notifier(ctx, &data.e, NULL, NULL); aio_set_event_notifier(ctx, &data.e, NULL);
g_assert(!aio_poll(ctx, false)); g_assert(!aio_poll(ctx, false));
event_notifier_cleanup(&data.e); event_notifier_cleanup(&data.e);
} }
@ -299,7 +299,7 @@ static void test_wait_event_notifier_noflush(void)
EventNotifierTestData dummy = { .n = 0, .active = 1 }; EventNotifierTestData dummy = { .n = 0, .active = 1 };
event_notifier_init(&data.e, false); event_notifier_init(&data.e, false);
aio_set_event_notifier(ctx, &data.e, event_ready_cb, NULL); aio_set_event_notifier(ctx, &data.e, event_ready_cb);
g_assert(!aio_poll(ctx, false)); g_assert(!aio_poll(ctx, false));
g_assert_cmpint(data.n, ==, 0); g_assert_cmpint(data.n, ==, 0);
@ -312,7 +312,7 @@ static void test_wait_event_notifier_noflush(void)
/* An active event notifier forces aio_poll to look at EventNotifiers. */ /* An active event notifier forces aio_poll to look at EventNotifiers. */
event_notifier_init(&dummy.e, false); event_notifier_init(&dummy.e, false);
aio_set_event_notifier(ctx, &dummy.e, event_ready_cb, NULL); aio_set_event_notifier(ctx, &dummy.e, event_ready_cb);
event_notifier_set(&data.e); event_notifier_set(&data.e);
g_assert(aio_poll(ctx, false)); g_assert(aio_poll(ctx, false));
@ -332,10 +332,10 @@ static void test_wait_event_notifier_noflush(void)
g_assert_cmpint(dummy.n, ==, 1); g_assert_cmpint(dummy.n, ==, 1);
g_assert_cmpint(dummy.active, ==, 0); g_assert_cmpint(dummy.active, ==, 0);
aio_set_event_notifier(ctx, &dummy.e, NULL, NULL); aio_set_event_notifier(ctx, &dummy.e, NULL);
event_notifier_cleanup(&dummy.e); event_notifier_cleanup(&dummy.e);
aio_set_event_notifier(ctx, &data.e, NULL, NULL); aio_set_event_notifier(ctx, &data.e, NULL);
g_assert(!aio_poll(ctx, false)); g_assert(!aio_poll(ctx, false));
g_assert_cmpint(data.n, ==, 2); g_assert_cmpint(data.n, ==, 2);
@ -515,11 +515,11 @@ static void test_source_set_event_notifier(void)
{ {
EventNotifierTestData data = { .n = 0, .active = 0 }; EventNotifierTestData data = { .n = 0, .active = 0 };
event_notifier_init(&data.e, false); event_notifier_init(&data.e, false);
aio_set_event_notifier(ctx, &data.e, event_ready_cb, NULL); aio_set_event_notifier(ctx, &data.e, event_ready_cb);
while (g_main_context_iteration(NULL, false)); while (g_main_context_iteration(NULL, false));
g_assert_cmpint(data.n, ==, 0); g_assert_cmpint(data.n, ==, 0);
aio_set_event_notifier(ctx, &data.e, NULL, NULL); aio_set_event_notifier(ctx, &data.e, NULL);
while (g_main_context_iteration(NULL, false)); while (g_main_context_iteration(NULL, false));
g_assert_cmpint(data.n, ==, 0); g_assert_cmpint(data.n, ==, 0);
event_notifier_cleanup(&data.e); event_notifier_cleanup(&data.e);
@ -529,7 +529,7 @@ static void test_source_wait_event_notifier(void)
{ {
EventNotifierTestData data = { .n = 0, .active = 1 }; EventNotifierTestData data = { .n = 0, .active = 1 };
event_notifier_init(&data.e, false); event_notifier_init(&data.e, false);
aio_set_event_notifier(ctx, &data.e, event_ready_cb, NULL); aio_set_event_notifier(ctx, &data.e, event_ready_cb);
g_assert(g_main_context_iteration(NULL, false)); g_assert(g_main_context_iteration(NULL, false));
g_assert_cmpint(data.n, ==, 0); g_assert_cmpint(data.n, ==, 0);
g_assert_cmpint(data.active, ==, 1); g_assert_cmpint(data.active, ==, 1);
@ -543,7 +543,7 @@ static void test_source_wait_event_notifier(void)
g_assert_cmpint(data.n, ==, 1); g_assert_cmpint(data.n, ==, 1);
g_assert_cmpint(data.active, ==, 0); g_assert_cmpint(data.active, ==, 0);
aio_set_event_notifier(ctx, &data.e, NULL, NULL); aio_set_event_notifier(ctx, &data.e, NULL);
while (g_main_context_iteration(NULL, false)); while (g_main_context_iteration(NULL, false));
g_assert_cmpint(data.n, ==, 1); g_assert_cmpint(data.n, ==, 1);
@ -554,7 +554,7 @@ static void test_source_flush_event_notifier(void)
{ {
EventNotifierTestData data = { .n = 0, .active = 10, .auto_set = true }; EventNotifierTestData data = { .n = 0, .active = 10, .auto_set = true };
event_notifier_init(&data.e, false); event_notifier_init(&data.e, false);
aio_set_event_notifier(ctx, &data.e, event_ready_cb, NULL); aio_set_event_notifier(ctx, &data.e, event_ready_cb);
g_assert(g_main_context_iteration(NULL, false)); g_assert(g_main_context_iteration(NULL, false));
g_assert_cmpint(data.n, ==, 0); g_assert_cmpint(data.n, ==, 0);
g_assert_cmpint(data.active, ==, 10); g_assert_cmpint(data.active, ==, 10);
@ -570,7 +570,7 @@ static void test_source_flush_event_notifier(void)
g_assert_cmpint(data.active, ==, 0); g_assert_cmpint(data.active, ==, 0);
g_assert(!g_main_context_iteration(NULL, false)); g_assert(!g_main_context_iteration(NULL, false));
aio_set_event_notifier(ctx, &data.e, NULL, NULL); aio_set_event_notifier(ctx, &data.e, NULL);
while (g_main_context_iteration(NULL, false)); while (g_main_context_iteration(NULL, false));
event_notifier_cleanup(&data.e); event_notifier_cleanup(&data.e);
} }
@ -581,7 +581,7 @@ static void test_source_wait_event_notifier_noflush(void)
EventNotifierTestData dummy = { .n = 0, .active = 1 }; EventNotifierTestData dummy = { .n = 0, .active = 1 };
event_notifier_init(&data.e, false); event_notifier_init(&data.e, false);
aio_set_event_notifier(ctx, &data.e, event_ready_cb, NULL); aio_set_event_notifier(ctx, &data.e, event_ready_cb);
while (g_main_context_iteration(NULL, false)); while (g_main_context_iteration(NULL, false));
g_assert_cmpint(data.n, ==, 0); g_assert_cmpint(data.n, ==, 0);
@ -594,7 +594,7 @@ static void test_source_wait_event_notifier_noflush(void)
/* An active event notifier forces aio_poll to look at EventNotifiers. */ /* An active event notifier forces aio_poll to look at EventNotifiers. */
event_notifier_init(&dummy.e, false); event_notifier_init(&dummy.e, false);
aio_set_event_notifier(ctx, &dummy.e, event_ready_cb, NULL); aio_set_event_notifier(ctx, &dummy.e, event_ready_cb);
event_notifier_set(&data.e); event_notifier_set(&data.e);
g_assert(g_main_context_iteration(NULL, false)); g_assert(g_main_context_iteration(NULL, false));
@ -614,10 +614,10 @@ static void test_source_wait_event_notifier_noflush(void)
g_assert_cmpint(dummy.n, ==, 1); g_assert_cmpint(dummy.n, ==, 1);
g_assert_cmpint(dummy.active, ==, 0); g_assert_cmpint(dummy.active, ==, 0);
aio_set_event_notifier(ctx, &dummy.e, NULL, NULL); aio_set_event_notifier(ctx, &dummy.e, NULL);
event_notifier_cleanup(&dummy.e); event_notifier_cleanup(&dummy.e);
aio_set_event_notifier(ctx, &data.e, NULL, NULL); aio_set_event_notifier(ctx, &data.e, NULL);
while (g_main_context_iteration(NULL, false)); while (g_main_context_iteration(NULL, false));
g_assert_cmpint(data.n, ==, 2); g_assert_cmpint(data.n, ==, 2);

5
thread-pool.c
View File

@ -303,8 +303,7 @@ static void thread_pool_init_one(ThreadPool *pool, AioContext *ctx)
QLIST_INIT(&pool->head); QLIST_INIT(&pool->head);
QTAILQ_INIT(&pool->request_list); QTAILQ_INIT(&pool->request_list);
aio_set_event_notifier(ctx, &pool->notifier, event_notifier_ready, aio_set_event_notifier(ctx, &pool->notifier, event_notifier_ready);
NULL);
} }
ThreadPool *thread_pool_new(AioContext *ctx) ThreadPool *thread_pool_new(AioContext *ctx)
@ -338,7 +337,7 @@ void thread_pool_free(ThreadPool *pool)
qemu_mutex_unlock(&pool->lock); qemu_mutex_unlock(&pool->lock);
aio_set_event_notifier(pool->ctx, &pool->notifier, NULL, NULL); aio_set_event_notifier(pool->ctx, &pool->notifier, NULL);
qemu_sem_destroy(&pool->sem); qemu_sem_destroy(&pool->sem);
qemu_cond_destroy(&pool->check_cancel); qemu_cond_destroy(&pool->check_cancel);
qemu_cond_destroy(&pool->worker_stopped); qemu_cond_destroy(&pool->worker_stopped);