eventfd: add EFD_AUTORESET flag
RFC 1/1 eventfd: add EFD_AUTORESET flag
Some applications simply use eventfd for inter-thread notifications without requiring counter or semaphore semantics. They wait for the eventfd to become readable using poll(2)/select(2) and then call read(2) to reset the counter.
This patch adds the EFD_AUTORESET flag to reset the counter when f_ops->poll() finds the eventfd is readable, eliminating the need to call read(2) to reset the counter.
This results in a small but measurable 1% performance improvement with QEMU virtio-blk emulation. Each read(2) takes 1 microsecond execution time in the event loop according to perf.
---
Does this look like a reasonable thing to do? I'm not very familiar with f_ops->poll() or the eventfd internals, so maybe I'm overlooking a design flaw.
I've tested this with QEMU and it works fine:
https://github.com/stefanha/qemu/commits/eventfd-autoreset
--- fs/eventfd.c | 99 +++++++++++++++++++++++++---------------- include/linux/eventfd.h | 3 +- 2 files changed, 62 insertions(+), 40 deletions(-)
fs/eventfd.c +60 -39
@@ -116,45 +116,62 @@ static __poll_t eventfd_poll(struct file *file, poll_table *wait)poll_wait (file, &ctx->wqh, wait); -/* -* All writes to ctx->count occur within ctx->wqh.lock. This read -* can be done outside ctx->wqh.lock because we know that poll_wait -* takes that lock (through add_wait_queue) if our caller will sleep. -* -* The read _can_ therefore seep into add_wait_queue's critical -* section, but cannot move above it! add_wait_queue's spin_lock acts -* as an acquire barrier and ensures that the read be ordered properly -* against the writes. The following CAN happen and is safe: -* -* poll write -* ----------------- ------------ -* lock ctx->wqh.lock (in poll_wait) -* count = ctx->count -* __add_wait_queue -* unlock ctx->wqh.lock -* lock ctx->qwh.lock -* ctx->count += n -* if (waitqueue_active) -* wake_up_locked_poll -* unlock ctx->qwh.lock -* eventfd_poll returns 0 -* -* but the following, which would miss a wakeup, cannot happen: -* -* poll write -* ----------------- ------------ -* count = ctx->count (INVALID!) -* lock ctx->qwh.lock -* ctx->count += n -* **waitqueue_active is false** -* **no wake_up_locked_poll!** -* unlock ctx->qwh.lock -* lock ctx->wqh.lock (in poll_wait) -* __add_wait_queue -* unlock ctx->wqh.lock -* eventfd_poll returns 0 -*/ - count =READ_ONCE (ctx->count); +if (ctx->flags &EFD_AUTORESET ) { +unsigned long flags; +__poll_t requested =poll_requested_events (wait); + +spin_lock_irqsave (&ctx->wqh.lock, flags); + count = ctx->count; + +/* Reset counter if caller is polling for read */ +if (count !=0 && (requested &EPOLLIN )) { + ctx->count =0 ; + events |=EPOLLOUT ; +/* TODO is a EPOLLOUT wakeup necessary here? */ + } + +spin_unlock_irqrestore (&ctx->wqh.lock, flags); + }else { +/* +* All writes to ctx->count occur within ctx->wqh.lock. This read +* can be done outside ctx->wqh.lock because we know that poll_wait +* takes that lock (through add_wait_queue) if our caller will sleep. +* +* The read _can_ therefore seep into add_wait_queue's critical +* section, but cannot move above it! add_wait_queue's spin_lock acts +* as an acquire barrier and ensures that the read be ordered properly +* against the writes. The following CAN happen and is safe: +* +* poll write +* ----------------- ------------ +* lock ctx->wqh.lock (in poll_wait) +* count = ctx->count +* __add_wait_queue +* unlock ctx->wqh.lock +* lock ctx->qwh.lock +* ctx->count += n +* if (waitqueue_active) +* wake_up_locked_poll +* unlock ctx->qwh.lock +* eventfd_poll returns 0 +* +* but the following, which would miss a wakeup, cannot happen: +* +* poll write +* ----------------- ------------ +* count = ctx->count (INVALID!) +* lock ctx->qwh.lock +* ctx->count += n +* **waitqueue_active is false** +* **no wake_up_locked_poll!** +* unlock ctx->qwh.lock +* lock ctx->wqh.lock (in poll_wait) +* __add_wait_queue +* unlock ctx->wqh.lock +* eventfd_poll returns 0 +*/ + count =READ_ONCE (ctx->count); + }if (count >0 ) events |=EPOLLIN ;
@@ -400,6 +417,10 @@ static int do_eventfd(unsigned int count, int flags)if (flags & ~EFD_FLAGS_SET )return -EINVAL ; +/* Semaphore semantics don't make sense when autoreset is enabled */ +if ((flags &EFD_SEMAPHORE ) && (flags &EFD_AUTORESET )) +return -EINVAL ; + ctx =kmalloc (sizeof (*ctx),GFP_KERNEL );if (!ctx)return -ENOMEM ;
include/linux/eventfd.h +2 -1
@@ -21,11 +21,12 @@* shared O_* flags. */ #define EFD_SEMAPHORE (1 << 0) +#define EFD_AUTORESET (1 << 6)/* aliases O_CREAT */ #define EFD_CLOEXEC O_CLOEXEC#define EFD_NONBLOCK O_NONBLOCK#define EFD_SHARED_FCNTL_FLAGS (O_CLOEXEC | O_NONBLOCK) -#define EFD_FLAGS_SET (EFD_SHARED_FCNTL_FLAGS | EFD_SEMAPHORE) +#define EFD_FLAGS_SET (EFD_SHARED_FCNTL_FLAGS | EFD_SEMAPHORE | EFD_AUTORESET)struct eventfd_ctx ;struct file ;
Signature · 1 line
2.24.1
Quoted 13 lines · Stefan Hajnoczi
Some applications simply use eventfd for inter-thread notifications without requiring counter or semaphore semantics. They wait for the eventfd to become readable using poll(2)/select(2) and then call read(2) to reset the counter.
This patch adds the
EFD_AUTORESETflag to reset the counter whenf_ops->poll()finds the eventfd is readable, eliminating the need to call read(2) to reset the counter.This results in a small but measurable 1% performance improvement with QEMU virtio-blk emulation. Each read(2) takes 1 microsecond execution time in the event loop according to perf.
Quoted 5 lines
Signed-off-by Stefan Hajnoczi <[email protected]>---
Does this look like a reasonable thing to do? I'm not very familiar withf_ops->poll()or the eventfd internals, so maybe I'm overlooking a design flaw.
Ping?
Quoted 145 lines
I've tested this with QEMU and it works fine:
https://github.com/stefanha/qemu/commits/eventfd-autoreset--- fs/eventfd.c | 99 +++++++++++++++++++++++++---------------- include/linux/eventfd.h | 3 +- 2 files changed, 62 insertions(+), 40 deletions(-)fs/eventfd.c +60
-39@@ -116,45 +116,62 @@ static __poll_t eventfd_poll(struct file *file, poll_table *wait)poll_wait (file, &ctx->wqh, wait); -/* -* All writes to ctx->count occur within ctx->wqh.lock. This read -* can be done outside ctx->wqh.lock because we know that poll_wait -* takes that lock (through add_wait_queue) if our caller will sleep. -* -* The read _can_ therefore seep into add_wait_queue's critical -* section, but cannot move above it! add_wait_queue's spin_lock acts -* as an acquire barrier and ensures that the read be ordered properly -* against the writes. The following CAN happen and is safe: -* -* poll write -* ----------------- ------------ -* lock ctx->wqh.lock (in poll_wait) -* count = ctx->count -* __add_wait_queue -* unlock ctx->wqh.lock -* lock ctx->qwh.lock -* ctx->count += n -* if (waitqueue_active) -* wake_up_locked_poll -* unlock ctx->qwh.lock -* eventfd_poll returns 0 -* -* but the following, which would miss a wakeup, cannot happen: -* -* poll write -* ----------------- ------------ -* count = ctx->count (INVALID!) -* lock ctx->qwh.lock -* ctx->count += n -* **waitqueue_active is false** -* **no wake_up_locked_poll!** -* unlock ctx->qwh.lock -* lock ctx->wqh.lock (in poll_wait) -* __add_wait_queue -* unlock ctx->wqh.lock -* eventfd_poll returns 0 -*/ - count =READ_ONCE (ctx->count); +if (ctx->flags &EFD_AUTORESET ) { +unsigned long flags; +__poll_t requested =poll_requested_events (wait); + +spin_lock_irqsave (&ctx->wqh.lock, flags); + count = ctx->count; + +/* Reset counter if caller is polling for read */ +if (count !=0 && (requested &EPOLLIN )) { + ctx->count =0 ; + events |=EPOLLOUT ; +/* TODO is a EPOLLOUT wakeup necessary here? */ + } + +spin_unlock_irqrestore (&ctx->wqh.lock, flags); + }else { +/* +* All writes to ctx->count occur within ctx->wqh.lock. This read +* can be done outside ctx->wqh.lock because we know that poll_wait +* takes that lock (through add_wait_queue) if our caller will sleep. +* +* The read _can_ therefore seep into add_wait_queue's critical +* section, but cannot move above it! add_wait_queue's spin_lock acts +* as an acquire barrier and ensures that the read be ordered properly +* against the writes. The following CAN happen and is safe: +* +* poll write +* ----------------- ------------ +* lock ctx->wqh.lock (in poll_wait) +* count = ctx->count +* __add_wait_queue +* unlock ctx->wqh.lock +* lock ctx->qwh.lock +* ctx->count += n +* if (waitqueue_active) +* wake_up_locked_poll +* unlock ctx->qwh.lock +* eventfd_poll returns 0 +* +* but the following, which would miss a wakeup, cannot happen: +* +* poll write +* ----------------- ------------ +* count = ctx->count (INVALID!) +* lock ctx->qwh.lock +* ctx->count += n +* **waitqueue_active is false** +* **no wake_up_locked_poll!** +* unlock ctx->qwh.lock +* lock ctx->wqh.lock (in poll_wait) +* __add_wait_queue +* unlock ctx->wqh.lock +* eventfd_poll returns 0 +*/ + count =READ_ONCE (ctx->count); + }if (count >0 ) events |=EPOLLIN ;@@ -400,6 +417,10 @@ static int do_eventfd(unsigned int count, int flags)if (flags & ~EFD_FLAGS_SET )return -EINVAL ; +/* Semaphore semantics don't make sense when autoreset is enabled */ +if ((flags &EFD_SEMAPHORE ) && (flags &EFD_AUTORESET )) +return -EINVAL ; + ctx =kmalloc (sizeof (*ctx),GFP_KERNEL );if (!ctx)return -ENOMEM ;include/linux/eventfd.h +2
-1@@ -21,11 +21,12 @@* shared O_* flags. */ #define EFD_SEMAPHORE (1 << 0) +#define EFD_AUTORESET (1 << 6)/* aliases O_CREAT */ #define EFD_CLOEXEC O_CLOEXEC#define EFD_NONBLOCK O_NONBLOCK#define EFD_SHARED_FCNTL_FLAGS (O_CLOEXEC | O_NONBLOCK) -#define EFD_FLAGS_SET (EFD_SHARED_FCNTL_FLAGS | EFD_SEMAPHORE) +#define EFD_FLAGS_SET (EFD_SHARED_FCNTL_FLAGS | EFD_SEMAPHORE | EFD_AUTORESET)struct eventfd_ctx ;struct file ;Signature · 1 line
2.24.1
Quoted 14 lines · Stefan Hajnoczi
Quoted 13 lines · Stefan Hajnoczi
Some applications simply use eventfd for inter-thread notifications without requiring counter or semaphore semantics. They wait for the eventfd to become readable using poll(2)/select(2) and then call read(2) to reset the counter.
This patch adds the
EFD_AUTORESETflag to reset the counter whenf_ops->poll()finds the eventfd is readable, eliminating the need to call read(2) to reset the counter.This results in a small but measurable 1% performance improvement with QEMU virtio-blk emulation. Each read(2) takes 1 microsecond execution time in the event loop according to perf.
Quoted 7 lines
Quoted 5 lines
Signed-off-by Stefan Hajnoczi <[email protected]>---
Does this look like a reasonable thing to do? I'm not very familiar withf_ops->poll()or the eventfd internals, so maybe I'm overlooking a design flaw.Ping?
Ping?
I would appreciate an indication of whether EFD_AUTORESET is an acceptable new feature. Thanks!
Quoted 145 lines
Quoted 145 lines
I've tested this with QEMU and it works fine:
https://github.com/stefanha/qemu/commits/eventfd-autoreset--- fs/eventfd.c | 99 +++++++++++++++++++++++++---------------- include/linux/eventfd.h | 3 +- 2 files changed, 62 insertions(+), 40 deletions(-)fs/eventfd.c +60
-39@@ -116,45 +116,62 @@ static __poll_t eventfd_poll(struct file *file, poll_table *wait)poll_wait (file, &ctx->wqh, wait); -/* -* All writes to ctx->count occur within ctx->wqh.lock. This read -* can be done outside ctx->wqh.lock because we know that poll_wait -* takes that lock (through add_wait_queue) if our caller will sleep. -* -* The read _can_ therefore seep into add_wait_queue's critical -* section, but cannot move above it! add_wait_queue's spin_lock acts -* as an acquire barrier and ensures that the read be ordered properly -* against the writes. The following CAN happen and is safe: -* -* poll write -* ----------------- ------------ -* lock ctx->wqh.lock (in poll_wait) -* count = ctx->count -* __add_wait_queue -* unlock ctx->wqh.lock -* lock ctx->qwh.lock -* ctx->count += n -* if (waitqueue_active) -* wake_up_locked_poll -* unlock ctx->qwh.lock -* eventfd_poll returns 0 -* -* but the following, which would miss a wakeup, cannot happen: -* -* poll write -* ----------------- ------------ -* count = ctx->count (INVALID!) -* lock ctx->qwh.lock -* ctx->count += n -* **waitqueue_active is false** -* **no wake_up_locked_poll!** -* unlock ctx->qwh.lock -* lock ctx->wqh.lock (in poll_wait) -* __add_wait_queue -* unlock ctx->wqh.lock -* eventfd_poll returns 0 -*/ - count =READ_ONCE (ctx->count); +if (ctx->flags &EFD_AUTORESET ) { +unsigned long flags; +__poll_t requested =poll_requested_events (wait); + +spin_lock_irqsave (&ctx->wqh.lock, flags); + count = ctx->count; + +/* Reset counter if caller is polling for read */ +if (count !=0 && (requested &EPOLLIN )) { + ctx->count =0 ; + events |=EPOLLOUT ; +/* TODO is a EPOLLOUT wakeup necessary here? */ + } + +spin_unlock_irqrestore (&ctx->wqh.lock, flags); + }else { +/* +* All writes to ctx->count occur within ctx->wqh.lock. This read +* can be done outside ctx->wqh.lock because we know that poll_wait +* takes that lock (through add_wait_queue) if our caller will sleep. +* +* The read _can_ therefore seep into add_wait_queue's critical +* section, but cannot move above it! add_wait_queue's spin_lock acts +* as an acquire barrier and ensures that the read be ordered properly +* against the writes. The following CAN happen and is safe: +* +* poll write +* ----------------- ------------ +* lock ctx->wqh.lock (in poll_wait) +* count = ctx->count +* __add_wait_queue +* unlock ctx->wqh.lock +* lock ctx->qwh.lock +* ctx->count += n +* if (waitqueue_active) +* wake_up_locked_poll +* unlock ctx->qwh.lock +* eventfd_poll returns 0 +* +* but the following, which would miss a wakeup, cannot happen: +* +* poll write +* ----------------- ------------ +* count = ctx->count (INVALID!) +* lock ctx->qwh.lock +* ctx->count += n +* **waitqueue_active is false** +* **no wake_up_locked_poll!** +* unlock ctx->qwh.lock +* lock ctx->wqh.lock (in poll_wait) +* __add_wait_queue +* unlock ctx->wqh.lock +* eventfd_poll returns 0 +*/ + count =READ_ONCE (ctx->count); + }if (count >0 ) events |=EPOLLIN ;@@ -400,6 +417,10 @@ static int do_eventfd(unsigned int count, int flags)if (flags & ~EFD_FLAGS_SET )return -EINVAL ; +/* Semaphore semantics don't make sense when autoreset is enabled */ +if ((flags &EFD_SEMAPHORE ) && (flags &EFD_AUTORESET )) +return -EINVAL ; + ctx =kmalloc (sizeof (*ctx),GFP_KERNEL );if (!ctx)return -ENOMEM ;include/linux/eventfd.h +2
-1@@ -21,11 +21,12 @@* shared O_* flags. */ #define EFD_SEMAPHORE (1 << 0) +#define EFD_AUTORESET (1 << 6)/* aliases O_CREAT */ #define EFD_CLOEXEC O_CLOEXEC#define EFD_NONBLOCK O_NONBLOCK#define EFD_SHARED_FCNTL_FLAGS (O_CLOEXEC | O_NONBLOCK) -#define EFD_FLAGS_SET (EFD_SHARED_FCNTL_FLAGS | EFD_SEMAPHORE) +#define EFD_FLAGS_SET (EFD_SHARED_FCNTL_FLAGS | EFD_SEMAPHORE | EFD_AUTORESET)struct eventfd_ctx ;struct file ;Signature · 1 line
2.24.1
Paolo Bonzini
maintainerfs/eventfd.c static int do_eventfd(unsigned int count, int flags) · line 423
Quoted 4 lines · Stefan Hajnoczi
fs/eventfd.c +4
-0+/* Semaphore semantics don't make sense when autoreset is enabled */ +if ((flags &EFD_SEMAPHORE ) && (flags &EFD_AUTORESET )) +return -EINVAL ; +
I think they do, you just want to subtract 1 instead of setting the count to 0. This way, writing 1 would be the post operation on the semaphore, while poll() would be the wait operation.
Paolo
Quoted 8 lines · Paolo Bonzini
fs/eventfd.c static int do_eventfd(unsigned int count, int flags) · line 423
Quoted 4 lines · Stefan Hajnoczi
fs/eventfd.c +4
-0+/* Semaphore semantics don't make sense when autoreset is enabled */ +if ((flags &EFD_SEMAPHORE ) && (flags &EFD_AUTORESET )) +return -EINVAL ; +I think they do, you just want to subtract 1 instead of setting the count to 0. This way, writing 1 would be the post operation on the semaphore, while
poll()would be the wait operation.
poll() is usually idempotent. Both resetting to zero and subtracting one goes against the grain.
Better to use uring async read. This way you get the value just as you do with with poll+read, and the syscall cost is amortized away by uring.
Quoted 9 lines · Paolo Bonzini
fs/eventfd.c static int do_eventfd(unsigned int count, int flags) · line 423
Quoted 4 lines · Stefan Hajnoczi
fs/eventfd.c +4
-0+/* Semaphore semantics don't make sense when autoreset is enabled */ +if ((flags &EFD_SEMAPHORE ) && (flags &EFD_AUTORESET )) +return -EINVAL ; +I think they do, you just want to subtract 1 instead of setting the count to 0. This way, writing 1 would be the post operation on the semaphore, while
poll()would be the wait operation.
True! Then EFD_AUTORESET is not a fitting name. EFD_AUTOREAD or EFD_POLL_READS?
Stefan
Paolo Bonzini
maintainerQuoted 11 lines · Stefan Hajnoczi
Quoted 9 lines · Paolo Bonzini
fs/eventfd.c static int do_eventfd(unsigned int count, int flags) · line 423
Quoted 4 lines · Stefan Hajnoczi
fs/eventfd.c +4
-0+/* Semaphore semantics don't make sense when autoreset is enabled */ +if ((flags &EFD_SEMAPHORE ) && (flags &EFD_AUTORESET )) +return -EINVAL ; +I think they do, you just want to subtract 1 instead of setting the count to 0. This way, writing 1 would be the post operation on the semaphore, while
poll()would be the wait operation.
Quoted 2 lines
True! Then
EFD_AUTORESETis not a fitting name.EFD_AUTOREADorEFD_POLL_READS?
Avi's suggestion also makes sense. Switching the event loop from poll() to IORING_OP_POLL_ADD would be good on its own, and then you could make it use IORING_OP_READV for eventfds.
In QEMU parlance, perhaps you need a different abstraction than EventNotifier (let's call it WakeupNotifier) which would also use eventfd but it would provide a smaller API. Thanks to the smaller API, it would not need EFD_NONBLOCK, unlike the regular EventNotifier, and it could either set up a poll() handler calling read(), or use IORING_OP_READV when io_uring is in use.
Paolo
Quoted 16 lines · Paolo Bonzini
Quoted 11 lines · Stefan Hajnoczi
Quoted 8 lines · Paolo Bonzini
fs/eventfd.c static int do_eventfd(unsigned int count, int flags) · line 423
Quoted 4 lines · Stefan Hajnoczi
fs/eventfd.c +4
-0+/* Semaphore semantics don't make sense when autoreset is enabled */ +if ((flags &EFD_SEMAPHORE ) && (flags &EFD_AUTORESET )) +return -EINVAL ; +I think they do, you just want to subtract 1 instead of setting the count to 0. This way, writing 1 would be the post operation on the semaphore, while
poll()would be the wait operation.True! Then
EFD_AUTORESETis not a fitting name.EFD_AUTOREADorEFD_POLL_READS?Avi's suggestion also makes sense. Switching the event loop from
poll()toIORING_OP_POLL_ADDwould be good on its own, and then you could make it useIORING_OP_READVfor eventfds.
Quoted 7 lines
In QEMU parlance, perhaps you need a different abstraction than EventNotifier (let's call it WakeupNotifier) which would also use eventfd but it would provide a smaller API. Thanks to the smaller API, it would not need
EFD_NONBLOCK, unlike the regular EventNotifier, and it could either set up apoll()handler callingread(), or useIORING_OP_READVwhenio_uringis in use.
Just to be clear, for best performance don't use IORING_OP_POLL_ADD, just IORING_OP_READ. That's what you say in the second paragraph but the first can be misleading.
Quoted 26 lines · Avi Kivity
Quoted 16 lines · Paolo Bonzini
Quoted 11 lines · Stefan Hajnoczi
Quoted 8 lines · Paolo Bonzini
fs/eventfd.c static int do_eventfd(unsigned int count, int flags) · line 423
Quoted 4 lines · Stefan Hajnoczi
fs/eventfd.c +4
-0+/* Semaphore semantics don't make sense when autoreset is enabled */ +if ((flags &EFD_SEMAPHORE ) && (flags &EFD_AUTORESET )) +return -EINVAL ; +I think they do, you just want to subtract 1 instead of setting the count to 0. This way, writing 1 would be the post operation on the semaphore, while
poll()would be the wait operation.True! Then
EFD_AUTORESETis not a fitting name.EFD_AUTOREADorEFD_POLL_READS?Avi's suggestion also makes sense. Switching the event loop from
poll()toIORING_OP_POLL_ADDwould be good on its own, and then you could make it useIORING_OP_READVfor eventfds.Quoted 7 lines
In QEMU parlance, perhaps you need a different abstraction than EventNotifier (let's call it WakeupNotifier) which would also use eventfd but it would provide a smaller API. Thanks to the smaller API, it would not need
EFD_NONBLOCK, unlike the regular EventNotifier, and it could either set up apoll()handler callingread(), or useIORING_OP_READVwhenio_uringis in use.
Quoted 3 lines
Just to be clear, for best performance don't use
IORING_OP_POLL_ADD, justIORING_OP_READ. That's what you say in the second paragraph but the first can be misleading.
Thanks, that's a nice idea! I already have experimental io_uring fd monitoring code written for QEMU and will extend it to use IORING_OP_READ.
Stefan
Quoted 25 lines · Stefan Hajnoczi
Quoted 24 lines · Avi Kivity
Quoted 23 lines · Paolo Bonzini
Quoted 11 lines · Stefan Hajnoczi
Quoted 8 lines · Paolo Bonzini
fs/eventfd.c static int do_eventfd(unsigned int count, int flags) · line 423
Quoted 4 lines · Stefan Hajnoczi
fs/eventfd.c +4
-0+/* Semaphore semantics don't make sense when autoreset is enabled */ +if ((flags &EFD_SEMAPHORE ) && (flags &EFD_AUTORESET )) +return -EINVAL ; +I think they do, you just want to subtract 1 instead of setting the count to 0. This way, writing 1 would be the post operation on the semaphore, while
poll()would be the wait operation.True! Then
EFD_AUTORESETis not a fitting name.EFD_AUTOREADorEFD_POLL_READS?Avi's suggestion also makes sense. Switching the event loop from
poll()toIORING_OP_POLL_ADDwould be good on its own, and then you could make it useIORING_OP_READVfor eventfds.In QEMU parlance, perhaps you need a different abstraction than EventNotifier (let's call it WakeupNotifier) which would also use eventfd but it would provide a smaller API. Thanks to the smaller API, it would not need
EFD_NONBLOCK, unlike the regular EventNotifier, and it could either set up apoll()handler callingread(), or useIORING_OP_READVwhenio_uringis in use.
Quoted 3 lines
Quoted 3 lines
Just to be clear, for best performance don't use
IORING_OP_POLL_ADD, justIORING_OP_READ. That's what you say in the second paragraph but the first can be misleading.
Actually it turns out that current uring OP_READ throws the work into a workqueue. Jens is fixing that now.
Quoted 2 lines
Thanks, that's a nice idea! I already have experimental
io_uringfd monitoring code written for QEMU and will extend it to useIORING_OP_READ.
Note linux-aio can do IOCB_CMD_POLL, starting with 4.19.
Paolo Bonzini
maintainerQuoted 6 lines · Avi Kivity
Quoted 4 lines
Thanks, that's a nice idea! I already have experimental
io_uringfd monitoring code written for QEMU and will extend it to useIORING_OP_READ.Note linux-aio can do
IOCB_CMD_POLL, starting with 4.19.
That was on the todo list, but io_uring came first. :)
Paolo