lkml.org 
[lkml]   [2022]   [Jun]   [7]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH 5.17 390/772] io_uring: cache poll/double-poll state with a request flag
    Date
    From: Jens Axboe <axboe@kernel.dk>

    [ Upstream commit 91eac1c69c202d9dad8bf717ae5b92db70bfe5cf ]

    With commit "io_uring: cache req->apoll->events in req->cflags" applied,
    we now have just io_poll_remove_entries() dipping into req->apoll when
    it isn't strictly necessary.

    Mark poll and double-poll with a flag, so we know if we need to look
    at apoll->double_poll. This avoids pulling in those cachelines if we
    don't need them. The common case is that the poll wake handler already
    removed these entries while hot off the completion path.

    Signed-off-by: Jens Axboe <axboe@kernel.dk>
    Signed-off-by: Sasha Levin <sashal@kernel.org>
    ---
    fs/io_uring.c | 24 +++++++++++++++++++-----
    1 file changed, 19 insertions(+), 5 deletions(-)

    diff --git a/fs/io_uring.c b/fs/io_uring.c
    index 26bf488096b2..8711d92f4d71 100644
    --- a/fs/io_uring.c
    +++ b/fs/io_uring.c
    @@ -740,6 +740,8 @@ enum {
    REQ_F_ARM_LTIMEOUT_BIT,
    REQ_F_ASYNC_DATA_BIT,
    REQ_F_SKIP_LINK_CQES_BIT,
    + REQ_F_SINGLE_POLL_BIT,
    + REQ_F_DOUBLE_POLL_BIT,
    /* keep async read/write and isreg together and in order */
    REQ_F_SUPPORT_NOWAIT_BIT,
    REQ_F_ISREG_BIT,
    @@ -798,6 +800,10 @@ enum {
    REQ_F_ASYNC_DATA = BIT(REQ_F_ASYNC_DATA_BIT),
    /* don't post CQEs while failing linked requests */
    REQ_F_SKIP_LINK_CQES = BIT(REQ_F_SKIP_LINK_CQES_BIT),
    + /* single poll may be active */
    + REQ_F_SINGLE_POLL = BIT(REQ_F_SINGLE_POLL_BIT),
    + /* double poll may active */
    + REQ_F_DOUBLE_POLL = BIT(REQ_F_DOUBLE_POLL_BIT),
    };

    struct async_poll {
    @@ -5464,8 +5470,12 @@ static inline void io_poll_remove_entry(struct io_poll_iocb *poll)

    static void io_poll_remove_entries(struct io_kiocb *req)
    {
    - struct io_poll_iocb *poll = io_poll_get_single(req);
    - struct io_poll_iocb *poll_double = io_poll_get_double(req);
    + /*
    + * Nothing to do if neither of those flags are set. Avoid dipping
    + * into the poll/apoll/double cachelines if we can.
    + */
    + if (!(req->flags & (REQ_F_SINGLE_POLL | REQ_F_DOUBLE_POLL)))
    + return;

    /*
    * While we hold the waitqueue lock and the waitqueue is nonempty,
    @@ -5483,9 +5493,10 @@ static void io_poll_remove_entries(struct io_kiocb *req)
    * In that case, only RCU prevents the queue memory from being freed.
    */
    rcu_read_lock();
    - io_poll_remove_entry(poll);
    - if (poll_double)
    - io_poll_remove_entry(poll_double);
    + if (req->flags & REQ_F_SINGLE_POLL)
    + io_poll_remove_entry(io_poll_get_single(req));
    + if (req->flags & REQ_F_DOUBLE_POLL)
    + io_poll_remove_entry(io_poll_get_double(req));
    rcu_read_unlock();
    }

    @@ -5662,6 +5673,7 @@ static int io_poll_wake(struct wait_queue_entry *wait, unsigned mode, int sync,
    if (mask && poll->events & EPOLLONESHOT) {
    list_del_init(&poll->wait.entry);
    poll->head = NULL;
    + req->flags &= ~REQ_F_SINGLE_POLL;
    }
    __io_poll_execute(req, mask);
    }
    @@ -5698,12 +5710,14 @@ static void __io_queue_proc(struct io_poll_iocb *poll, struct io_poll_table *pt,
    pt->error = -ENOMEM;
    return;
    }
    + req->flags |= REQ_F_DOUBLE_POLL;
    io_init_poll_iocb(poll, first->events, first->wait.func);
    *poll_ptr = poll;
    if (req->opcode == IORING_OP_POLL_ADD)
    req->flags |= REQ_F_ASYNC_DATA;
    }

    + req->flags |= REQ_F_SINGLE_POLL;
    pt->nr_entries++;
    poll->head = head;
    poll->wait.private = req;
    --
    2.35.1


    \
     
     \ /
      Last update: 2022-06-07 23:13    [W:4.023 / U:0.060 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site