Merge tag 'drm-intel-next-2023-11-23' of git://anongit.freedesktop.org/drm/drm-intel...

[linux-2.6-microblaze.git] / io_uring / cancel.c

diff --git a/io_uring/cancel.c b/io_uring/cancel.c
index 58c46c8..3c19ccc 100644 (file)
--- a/io_uring/cancel.c
+++ b/io_uring/cancel.c
@@ -15,6 +15,8 @@
 #include "tctx.h"
 #include "poll.h"
 #include "timeout.h"
+#include "waitid.h"
+#include "futex.h"
 #include "cancel.h"
 
 struct io_cancel {
@@ -22,35 +24,56 @@ struct io_cancel {
        u64                             addr;
        u32                             flags;
        s32                             fd;
+       u8                              opcode;
 };
 
 #define CANCEL_FLAGS   (IORING_ASYNC_CANCEL_ALL | IORING_ASYNC_CANCEL_FD | \
-                        IORING_ASYNC_CANCEL_ANY | IORING_ASYNC_CANCEL_FD_FIXED)
+                        IORING_ASYNC_CANCEL_ANY | IORING_ASYNC_CANCEL_FD_FIXED | \
+                        IORING_ASYNC_CANCEL_USERDATA | IORING_ASYNC_CANCEL_OP)
 
-static bool io_cancel_cb(struct io_wq_work *work, void *data)
+/*
+ * Returns true if the request matches the criteria outlined by 'cd'.
+ */
+bool io_cancel_req_match(struct io_kiocb *req, struct io_cancel_data *cd)
 {
-       struct io_kiocb *req = container_of(work, struct io_kiocb, work);
-       struct io_cancel_data *cd = data;
+       bool match_user_data = cd->flags & IORING_ASYNC_CANCEL_USERDATA;
 
        if (req->ctx != cd->ctx)
                return false;
-       if (cd->flags & IORING_ASYNC_CANCEL_ANY) {
-               ;
-       } else if (cd->flags & IORING_ASYNC_CANCEL_FD) {
+
+       if (!(cd->flags & (IORING_ASYNC_CANCEL_FD | IORING_ASYNC_CANCEL_OP)))
+               match_user_data = true;
+
+       if (cd->flags & IORING_ASYNC_CANCEL_ANY)
+               goto check_seq;
+       if (cd->flags & IORING_ASYNC_CANCEL_FD) {
                if (req->file != cd->file)
                        return false;
-       } else {
-               if (req->cqe.user_data != cd->data)
+       }
+       if (cd->flags & IORING_ASYNC_CANCEL_OP) {
+               if (req->opcode != cd->opcode)
                        return false;
        }
-       if (cd->flags & (IORING_ASYNC_CANCEL_ALL|IORING_ASYNC_CANCEL_ANY)) {
+       if (match_user_data && req->cqe.user_data != cd->data)
+               return false;
+       if (cd->flags & IORING_ASYNC_CANCEL_ALL) {
+check_seq:
                if (cd->seq == req->work.cancel_seq)
                        return false;
                req->work.cancel_seq = cd->seq;
        }
+
        return true;
 }
 
+static bool io_cancel_cb(struct io_wq_work *work, void *data)
+{
+       struct io_kiocb *req = container_of(work, struct io_kiocb, work);
+       struct io_cancel_data *cd = data;
+
+       return io_cancel_req_match(req, cd);
+}
+
 static int io_async_cancel_one(struct io_uring_task *tctx,
                               struct io_cancel_data *cd)
 {
@@ -98,6 +121,14 @@ int io_try_cancel(struct io_uring_task *tctx, struct io_cancel_data *cd,
        if (ret != -ENOENT)
                return ret;
 
+       ret = io_waitid_cancel(ctx, cd, issue_flags);
+       if (ret != -ENOENT)
+               return ret;
+
+       ret = io_futex_cancel(ctx, cd, issue_flags);
+       if (ret != -ENOENT)
+               return ret;
+
        spin_lock(&ctx->completion_lock);
        if (!(cd->flags & IORING_ASYNC_CANCEL_FD))
                ret = io_timeout_cancel(ctx, cd);
@@ -111,7 +142,7 @@ int io_async_cancel_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
 
        if (unlikely(req->flags & REQ_F_BUFFER_SELECT))
                return -EINVAL;
-       if (sqe->off || sqe->len || sqe->splice_fd_in)
+       if (sqe->off || sqe->splice_fd_in)
                return -EINVAL;
 
        cancel->addr = READ_ONCE(sqe->addr);
@@ -123,6 +154,11 @@ int io_async_cancel_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
                        return -EINVAL;
                cancel->fd = READ_ONCE(sqe->fd);
        }
+       if (cancel->flags & IORING_ASYNC_CANCEL_OP) {
+               if (cancel->flags & IORING_ASYNC_CANCEL_ANY)
+                       return -EINVAL;
+               cancel->opcode = READ_ONCE(sqe->len);
+       }
 
        return 0;
 }
@@ -169,6 +205,7 @@ int io_async_cancel(struct io_kiocb *req, unsigned int issue_flags)
                .ctx    = req->ctx,
                .data   = cancel->addr,
                .flags  = cancel->flags,
+               .opcode = cancel->opcode,
                .seq    = atomic_inc_return(&req->ctx->cancel_seq),
        };
        struct io_uring_task *tctx = req->task->io_uring;
@@ -238,17 +275,22 @@ int io_sync_cancel(struct io_ring_ctx *ctx, void __user *arg)
        struct io_uring_sync_cancel_reg sc;
        struct fd f = { };
        DEFINE_WAIT(wait);
-       int ret;
+       int ret, i;
 
        if (copy_from_user(&sc, arg, sizeof(sc)))
                return -EFAULT;
        if (sc.flags & ~CANCEL_FLAGS)
                return -EINVAL;
-       if (sc.pad[0] || sc.pad[1] || sc.pad[2] || sc.pad[3])
-               return -EINVAL;
+       for (i = 0; i < ARRAY_SIZE(sc.pad); i++)
+               if (sc.pad[i])
+                       return -EINVAL;
+       for (i = 0; i < ARRAY_SIZE(sc.pad2); i++)
+               if (sc.pad2[i])
+                       return -EINVAL;
 
        cd.data = sc.addr;
        cd.flags = sc.flags;
+       cd.opcode = sc.opcode;
 
        /* we can grab a normal file descriptor upfront */
        if ((cd.flags & IORING_ASYNC_CANCEL_FD) &&