| Message ID | 20180730071544.23998-4-hch@lst.de (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
| Series | [1/4] timerfd: add support for keyed wakeups | expand |
On Mon, Jul 30, 2018 at 09:15:43AM +0200, Christoph Hellwig wrote: > + apt.error = -EINVAL; /* same as no support for IOCB_CMD_POLL */ > + mask = vfs_poll(req->file, &apt.pt) & req->events; > + if (mask || apt.error) { > + bool removed = false; > + > + /* we did not manage to set up a waitqueue, done */ > + if (unlikely(!req->head)) > + goto out_fput; > +out_fput: > + fput(req->file); > + return apt.error; Ugh... So anything that simply returns a constant value, without even bothering to do poll_wait() (on the theory that no matter how much you wait, nothing will change) is going to git -EINVAL? What am I missing here?
On Mon, Jul 30, 2018 at 09:15:43AM +0200, Christoph Hellwig wrote: > +static void aio_poll_complete_work(struct work_struct *work) > +{ > + struct poll_iocb *req = container_of(work, struct poll_iocb, work); > + struct aio_kiocb *iocb = container_of(req, struct aio_kiocb, poll); > + struct poll_table_struct pt = { ._key = req->events }; > + struct kioctx *ctx = iocb->ki_ctx; > + __poll_t mask; > + > + if (READ_ONCE(req->cancelled)) { .... > + } > + > + mask = vfs_poll(req->file, &pt) & req->events; > + if (!mask) { > + add_wait_queue(req->head, &req->wait); > + return; > + } .... > +} > +/* assumes we are called with irqs disabled */ > +static int aio_poll_cancel(struct kiocb *iocb) > +{ > + struct aio_kiocb *aiocb = container_of(iocb, struct aio_kiocb, rw); > + struct poll_iocb *req = &aiocb->poll; > + > + spin_lock(&req->head->lock); > + if (!list_empty(&req->wait.entry)) { > + WRITE_ONCE(req->cancelled, true); > + list_del_init(&req->wait.entry); > + schedule_work(&aiocb->poll.work); > + } > + spin_unlock(&req->head->lock); > + > + return 0; > +} > +static int aio_poll_wake(struct wait_queue_entry *wait, unsigned mode, int sync, > + void *key) > +{ > + struct poll_iocb *req = container_of(wait, struct poll_iocb, wait); > + __poll_t mask = key_to_poll(key); > + > + /* for instances that support it check for an event match first: */ > + if (mask && !(mask & req->events)) > + return 0; > + > + list_del_init(&req->wait.entry); > + schedule_work(&req->work); > + return 1; > +} > +static ssize_t aio_poll(struct aio_kiocb *aiocb, struct iocb *iocb) > +{ > + struct kioctx *ctx = aiocb->ki_ctx; > + struct poll_iocb *req = &aiocb->poll; > + struct aio_poll_table apt; > + __poll_t mask; > + mask = vfs_poll(req->file, &apt.pt) & req->events; > + if (mask || apt.error) { > + } else { > + spin_lock_irq(&ctx->ctx_lock); > + if (!req->done) { > + list_add_tail(&aiocb->ki_list, &ctx->active_reqs); > + aiocb->ki_cancel = aio_poll_cancel; > + } > + spin_unlock_irq(&ctx->ctx_lock); > + } So what happens if * we call aio_poll(), add the sucker to queue and see that we need to wait * add to ->active_refs just as the wakeup comes * wakeup removes from queue and hits schedule_work() * io_cancel() is called, triggering aio_poll_cancel(), which sees that we are not from queue and buggers off. We are gone from ->active_refs. * aio_poll_complete_work() is called, sees no ->cancelled * aio_poll_complete_work() calls vfs_poll(), sees nothing interesting and puts us back on the queue. Unless I'm misreading it, cancel will end up with iocb still around and now impossible to cancel... What am I missing?
On Thu, Aug 02, 2018 at 12:54:12AM +0100, Al Viro wrote: > On Mon, Jul 30, 2018 at 09:15:43AM +0200, Christoph Hellwig wrote: > > > + apt.error = -EINVAL; /* same as no support for IOCB_CMD_POLL */ > > > + mask = vfs_poll(req->file, &apt.pt) & req->events; > > + if (mask || apt.error) { > > + bool removed = false; > > + > > + /* we did not manage to set up a waitqueue, done */ > > + if (unlikely(!req->head)) > > + goto out_fput; > > > +out_fput: > > + fput(req->file); > > + return apt.error; > > Ugh... So anything that simply returns a constant value, without > even bothering to do poll_wait() (on the theory that no matter how > much you wait, nothing will change) is going to git -EINVAL? > What am I missing here? I can change it to return that constant value, but is it really going to be useful to keep resubmitting an iocb for something that we can't actually poll? I don't think we help the application with that at all.
On Thu, Aug 02, 2018 at 01:21:22AM +0100, Al Viro wrote: > So what happens if > * we call aio_poll(), add the sucker to queue and see that we need > to wait > * add to ->active_refs just as the wakeup comes active_reqs I guess.. > * wakeup removes from queue and hits schedule_work() > * io_cancel() is called, triggering aio_poll_cancel(), which sees that > we are not from queue and buggers off. We are gone from ->active_refs. > * aio_poll_complete_work() is called, sees no ->cancelled > * aio_poll_complete_work() calls vfs_poll(), sees nothing interesting > and puts us back on the queue. So let me draw this up, we start with the following: THREAD 1 THREAD 2 aio_poll vfs_poll(...) add_wait_queue() (no pending mask) spin_lock_irq(&ctx->ctx_lock); list_add_tail(..., &ctx->active_reqs) aio_poll_wake spin_unlock_irq(&ctx->ctx_lock); (spin_trylock failed) list_del_init(&req->wait.entry); schedule_work(&req->work); Now switching to two new threads: io_cancel thread worker thread vfs_poll() (mask = 0) aio_poll_cancel (not on waitqueue, done) remove from active_reqs add_wait_queue() iocb still around > > Unless I'm misreading it, cancel will end up with iocb still around and now > impossible to cancel... What am I missing? Yes, I think you are right. I'll see how I could handle that case. One of the easiest options would be to just support aio poll on file ops that support keyed wakeups, we'd just need to pass that information up.
On Thu, Aug 02, 2018 at 11:22:34AM +0200, Christoph Hellwig wrote: > Yes, I think you are right. I'll see how I could handle that case. > One of the easiest options would be to just support aio poll on > file ops that support keyed wakeups, we'd just need to pass that > information up. BTW, what happens if we insert into one queue and immediately get woken up, even before the damn thing gets to the end of ->poll(), which proceeds to call poll_wait() again (on another queue)? AFAICS, apt.error will be set by the second callback and completely ignored. And so will the return value of ->poll()... Sigh... Analysis of that thing is bloody painful, mostly because it's hard to describe the state...
On Thu, Aug 02, 2018 at 05:00:32PM +0100, Al Viro wrote: > BTW, what happens if we insert into one queue and immediately get > woken up, even before the damn thing gets to the end of ->poll(), > which proceeds to call poll_wait() again (on another queue)? > AFAICS, apt.error will be set by the second callback and completely > ignored. And so will the return value of ->poll()... > > Sigh... Analysis of that thing is bloody painful, mostly because > it's hard to describe the state... That's the problem with the ->poll interface. We call it, then have magic happen underneath where it might or might not get added to one (or more if we didn't exclude that) waitqueues, and might have actually been worken before return. I can't really think of a good way to do that entirely sanely. Best I can think of is to only allow using file ops that do keyed wakeups and rely on the keyed wakeups alone. I've started coming up with a version of that, but it won't be until tomorrow at least that I can post it.
On Thu, Aug 02, 2018 at 06:08:16PM +0200, Christoph Hellwig wrote: > On Thu, Aug 02, 2018 at 05:00:32PM +0100, Al Viro wrote: > > BTW, what happens if we insert into one queue and immediately get > > woken up, even before the damn thing gets to the end of ->poll(), > > which proceeds to call poll_wait() again (on another queue)? > > AFAICS, apt.error will be set by the second callback and completely > > ignored. And so will the return value of ->poll()... > > > > Sigh... Analysis of that thing is bloody painful, mostly because > > it's hard to describe the state... > > That's the problem with the ->poll interface. We call it, then > have magic happen underneath where it might or might not get added > to one (or more if we didn't exclude that) waitqueues, and might > have actually been worken before return. I can't really think of > a good way to do that entirely sanely. > > Best I can think of is to only allow using file ops that do keyed > wakeups and rely on the keyed wakeups alone. I've started coming > up with a version of that, but it won't be until tomorrow at least > that I can post it. What does it buy you? You still have to deal with trylock failures in wakeup...
On Thu, Aug 02, 2018 at 05:08:38PM +0100, Al Viro wrote: > On Thu, Aug 02, 2018 at 06:08:16PM +0200, Christoph Hellwig wrote: > > On Thu, Aug 02, 2018 at 05:00:32PM +0100, Al Viro wrote: > > > BTW, what happens if we insert into one queue and immediately get > > > woken up, even before the damn thing gets to the end of ->poll(), > > > which proceeds to call poll_wait() again (on another queue)? > > > AFAICS, apt.error will be set by the second callback and completely > > > ignored. And so will the return value of ->poll()... > > > > > > Sigh... Analysis of that thing is bloody painful, mostly because > > > it's hard to describe the state... > > > > That's the problem with the ->poll interface. We call it, then > > have magic happen underneath where it might or might not get added > > to one (or more if we didn't exclude that) waitqueues, and might > > have actually been worken before return. I can't really think of > > a good way to do that entirely sanely. > > > > Best I can think of is to only allow using file ops that do keyed > > wakeups and rely on the keyed wakeups alone. I've started coming > > up with a version of that, but it won't be until tomorrow at least > > that I can post it. > > What does it buy you? You still have to deal with trylock failures > in wakeup... But we'll never re-add an iocb once it has been removed from the waitqueue.
On Thu, Aug 02, 2018 at 06:16:48PM +0200, Christoph Hellwig wrote: > On Thu, Aug 02, 2018 at 05:08:38PM +0100, Al Viro wrote: > > On Thu, Aug 02, 2018 at 06:08:16PM +0200, Christoph Hellwig wrote: > > > On Thu, Aug 02, 2018 at 05:00:32PM +0100, Al Viro wrote: > > > > BTW, what happens if we insert into one queue and immediately get > > > > woken up, even before the damn thing gets to the end of ->poll(), > > > > which proceeds to call poll_wait() again (on another queue)? > > > > AFAICS, apt.error will be set by the second callback and completely > > > > ignored. And so will the return value of ->poll()... > > > > > > > > Sigh... Analysis of that thing is bloody painful, mostly because > > > > it's hard to describe the state... > > > > > > That's the problem with the ->poll interface. We call it, then > > > have magic happen underneath where it might or might not get added > > > to one (or more if we didn't exclude that) waitqueues, and might > > > have actually been worken before return. I can't really think of > > > a good way to do that entirely sanely. > > > > > > Best I can think of is to only allow using file ops that do keyed > > > wakeups and rely on the keyed wakeups alone. I've started coming > > > up with a version of that, but it won't be until tomorrow at least > > > that I can post it. > > > > What does it buy you? You still have to deal with trylock failures > > in wakeup... > > But we'll never re-add an iocb once it has been removed from the > waitqueue. Umm... Frankly, I wonder if the right approach is to declare that if wakeup has happened at all, submit gives up any responsibility. IOW, have aio_poll * create iocb, feed to ->poll() * check if ->head is NULL; if it is, the mask we've got is *all* we are going to get; complete and bugger off. * lock ioctx * insert the sucker into ->active_reqs * lock the queue * check if wakeup has already happened. * if it has - go away, it's submitted * check apt.error; if set, fail with -EINVAL. * check the mask; if nothing of interest is in there, go away * dequeue, unlist, complete and bugger off On cancel side * lock queue * mark it cancelled * removed from queue if it was there * unlock queue On wakeup * mark it woken * complete or schedule completion, which would be where we check if it's marked cancelled - both before vfs_poll() (to avoid calling it if already set) and after (treating cancel during vfs_poll() as "complete and bugger off"). Comments?
diff --git a/fs/aio.c b/fs/aio.c index fe2018ada32c..6993684d0665 100644 --- a/fs/aio.c +++ b/fs/aio.c @@ -5,6 +5,7 @@ * Implements an efficient asynchronous io interface. * * Copyright 2000, 2001, 2002 Red Hat, Inc. All Rights Reserved. + * Copyright 2018 Christoph Hellwig. * * See ../COPYING for licensing terms. */ @@ -165,10 +166,21 @@ struct fsync_iocb { bool datasync; }; +struct poll_iocb { + struct file *file; + struct wait_queue_head *head; + __poll_t events; + bool cancelled; + bool done; + struct wait_queue_entry wait; + struct work_struct work; +}; + struct aio_kiocb { union { struct kiocb rw; struct fsync_iocb fsync; + struct poll_iocb poll; }; struct kioctx *ki_ctx; @@ -1601,6 +1613,169 @@ static int aio_fsync(struct fsync_iocb *req, struct iocb *iocb, bool datasync) return 0; } +static inline void aio_poll_complete(struct aio_kiocb *iocb, __poll_t mask) +{ + struct file *file = iocb->poll.file; + + aio_complete(iocb, mangle_poll(mask), 0); + fput(file); +} + +static void aio_poll_complete_work(struct work_struct *work) +{ + struct poll_iocb *req = container_of(work, struct poll_iocb, work); + struct aio_kiocb *iocb = container_of(req, struct aio_kiocb, poll); + struct poll_table_struct pt = { ._key = req->events }; + struct kioctx *ctx = iocb->ki_ctx; + __poll_t mask; + + if (READ_ONCE(req->cancelled)) { + /* synchronize with ki_list removal in the callers: */ + spin_lock_irq(&ctx->ctx_lock); + WARN_ON_ONCE(!list_empty(&iocb->ki_list)); + spin_unlock_irq(&ctx->ctx_lock); + + aio_poll_complete(iocb, 0); + return; + } + + mask = vfs_poll(req->file, &pt) & req->events; + if (!mask) { + add_wait_queue(req->head, &req->wait); + return; + } + + spin_lock_irq(&ctx->ctx_lock); + req->done = true; + list_del(&iocb->ki_list); + spin_unlock_irq(&ctx->ctx_lock); + + aio_poll_complete(iocb, mask); +} + +/* assumes we are called with irqs disabled */ +static int aio_poll_cancel(struct kiocb *iocb) +{ + struct aio_kiocb *aiocb = container_of(iocb, struct aio_kiocb, rw); + struct poll_iocb *req = &aiocb->poll; + + spin_lock(&req->head->lock); + if (!list_empty(&req->wait.entry)) { + WRITE_ONCE(req->cancelled, true); + list_del_init(&req->wait.entry); + schedule_work(&aiocb->poll.work); + } + spin_unlock(&req->head->lock); + + return 0; +} + +static int aio_poll_wake(struct wait_queue_entry *wait, unsigned mode, int sync, + void *key) +{ + struct poll_iocb *req = container_of(wait, struct poll_iocb, wait); + __poll_t mask = key_to_poll(key); + + /* for instances that support it check for an event match first: */ + if (mask && !(mask & req->events)) + return 0; + + list_del_init(&req->wait.entry); + schedule_work(&req->work); + return 1; +} + +struct aio_poll_table { + struct poll_table_struct pt; + struct aio_kiocb *iocb; + int error; +}; + +static void +aio_poll_queue_proc(struct file *file, struct wait_queue_head *head, + struct poll_table_struct *p) +{ + struct aio_poll_table *pt = container_of(p, struct aio_poll_table, pt); + + /* multiple wait queues per file are not supported */ + if (unlikely(pt->iocb->poll.head)) { + pt->error = -EINVAL; + return; + } + + pt->error = 0; + pt->iocb->poll.head = head; + add_wait_queue(head, &pt->iocb->poll.wait); +} + +static ssize_t aio_poll(struct aio_kiocb *aiocb, struct iocb *iocb) +{ + struct kioctx *ctx = aiocb->ki_ctx; + struct poll_iocb *req = &aiocb->poll; + struct aio_poll_table apt; + __poll_t mask; + + /* reject any unknown events outside the normal event mask. */ + if ((u16)iocb->aio_buf != iocb->aio_buf) + return -EINVAL; + /* reject fields that are not defined for poll */ + if (iocb->aio_offset || iocb->aio_nbytes || iocb->aio_rw_flags) + return -EINVAL; + + INIT_WORK(&req->work, aio_poll_complete_work); + req->events = demangle_poll(iocb->aio_buf) | EPOLLERR | EPOLLHUP; + req->file = fget(iocb->aio_fildes); + if (unlikely(!req->file)) + return -EBADF; + + apt.pt._qproc = aio_poll_queue_proc; + apt.pt._key = req->events; + apt.iocb = aiocb; + apt.error = -EINVAL; /* same as no support for IOCB_CMD_POLL */ + + /* initialized the list so that we can do list_empty checks */ + INIT_LIST_HEAD(&req->wait.entry); + init_waitqueue_func_entry(&req->wait, aio_poll_wake); + + /* one for removal from waitqueue, one for this function */ + refcount_set(&aiocb->ki_refcnt, 2); + + mask = vfs_poll(req->file, &apt.pt) & req->events; + if (mask || apt.error) { + bool removed = false; + + /* we did not manage to set up a waitqueue, done */ + if (unlikely(!req->head)) + goto out_fput; + + spin_lock_irq(&req->head->lock); + if (!list_empty(&req->wait.entry)) { + list_del_init(&req->wait.entry); + removed = true; + } + spin_unlock_irq(&req->head->lock); + + if (removed) { + if (apt.error) + goto out_fput; + aio_poll_complete(aiocb, mask); + } + } else { + spin_lock_irq(&ctx->ctx_lock); + if (!req->done) { + list_add_tail(&aiocb->ki_list, &ctx->active_reqs); + aiocb->ki_cancel = aio_poll_cancel; + } + spin_unlock_irq(&ctx->ctx_lock); + } + + iocb_put(aiocb); + return 0; +out_fput: + fput(req->file); + return apt.error; +} + static int io_submit_one(struct kioctx *ctx, struct iocb __user *user_iocb, bool compat) { @@ -1674,6 +1849,9 @@ static int io_submit_one(struct kioctx *ctx, struct iocb __user *user_iocb, case IOCB_CMD_FDSYNC: ret = aio_fsync(&req->fsync, &iocb, true); break; + case IOCB_CMD_POLL: + ret = aio_poll(req, &iocb); + break; default: pr_debug("invalid aio operation %d\n", iocb.aio_lio_opcode); ret = -EINVAL; diff --git a/include/uapi/linux/aio_abi.h b/include/uapi/linux/aio_abi.h index d4593a6062ef..ce43d340f010 100644 --- a/include/uapi/linux/aio_abi.h +++ b/include/uapi/linux/aio_abi.h @@ -38,10 +38,8 @@ enum { IOCB_CMD_PWRITE = 1, IOCB_CMD_FSYNC = 2, IOCB_CMD_FDSYNC = 3, - /* These two are experimental. - * IOCB_CMD_PREADX = 4, - * IOCB_CMD_POLL = 5, - */ + /* 4 was the experimental IOCB_CMD_PREADX */ + IOCB_CMD_POLL = 5, IOCB_CMD_NOOP = 6, IOCB_CMD_PREADV = 7, IOCB_CMD_PWRITEV = 8,
Simple one-shot poll through the io_submit() interface. To poll for a file descriptor the application should submit an iocb of type IOCB_CMD_POLL. It will poll the fd for the events specified in the the first 32 bits of the aio_buf field of the iocb. Unlike poll or epoll without EPOLLONESHOT this interface always works in one shot mode, that is once the iocb is completed, it will have to be resubmitted. Signed-off-by: Christoph Hellwig <hch@lst.de> --- fs/aio.c | 178 +++++++++++++++++++++++++++++++++++ include/uapi/linux/aio_abi.h | 6 +- 2 files changed, 180 insertions(+), 4 deletions(-)