io_uring/rsrc: add lockdep sanity checks

[platform/kernel/linux-starfive.git] / io_uring / rsrc.c

diff --git a/io_uring/rsrc.c b/io_uring/rsrc.c
index 95e7130..d4bca5e 100644 (file)
--- a/io_uring/rsrc.c
+++ b/io_uring/rsrc.c
@@ -145,15 +145,8 @@ static void io_rsrc_put_work_one(struct io_rsrc_data *rsrc_data,
 {
        struct io_ring_ctx *ctx = rsrc_data->ctx;
 
-       if (prsrc->tag) {
-               if (ctx->flags & IORING_SETUP_IOPOLL) {
-                       mutex_lock(&ctx->uring_lock);
-                       io_post_aux_cqe(ctx, prsrc->tag, 0, 0);
-                       mutex_unlock(&ctx->uring_lock);
-               } else {
-                       io_post_aux_cqe(ctx, prsrc->tag, 0, 0);
-               }
-       }
+       if (prsrc->tag)
+               io_post_aux_cqe(ctx, prsrc->tag, 0, 0);
        rsrc_data->do_put(ctx, prsrc);
 }
 
@@ -171,89 +164,54 @@ static void __io_rsrc_put_work(struct io_rsrc_node *ref_node)
                kfree(prsrc);
        }
 
-       io_rsrc_node_destroy(ref_node);
+       io_rsrc_node_destroy(rsrc_data->ctx, ref_node);
        if (atomic_dec_and_test(&rsrc_data->refs))
                complete(&rsrc_data->done);
 }
 
-void io_rsrc_put_work(struct work_struct *work)
-{
-       struct io_ring_ctx *ctx;
-       struct llist_node *node;
-
-       ctx = container_of(work, struct io_ring_ctx, rsrc_put_work.work);
-       node = llist_del_all(&ctx->rsrc_put_llist);
-
-       while (node) {
-               struct io_rsrc_node *ref_node;
-               struct llist_node *next = node->next;
-
-               ref_node = llist_entry(node, struct io_rsrc_node, llist);
-               __io_rsrc_put_work(ref_node);
-               node = next;
-       }
-}
-
-void io_rsrc_put_tw(struct callback_head *cb)
-{
-       struct io_ring_ctx *ctx = container_of(cb, struct io_ring_ctx,
-                                              rsrc_put_tw);
-
-       io_rsrc_put_work(&ctx->rsrc_put_work.work);
-}
-
 void io_wait_rsrc_data(struct io_rsrc_data *data)
 {
        if (data && !atomic_dec_and_test(&data->refs))
                wait_for_completion(&data->done);
 }
 
-void io_rsrc_node_destroy(struct io_rsrc_node *ref_node)
+void io_rsrc_node_destroy(struct io_ring_ctx *ctx, struct io_rsrc_node *node)
 {
-       kfree(ref_node);
+       if (!io_alloc_cache_put(&ctx->rsrc_node_cache, &node->cache))
+               kfree(node);
 }
 
 void io_rsrc_node_ref_zero(struct io_rsrc_node *node)
        __must_hold(&node->rsrc_data->ctx->uring_lock)
 {
        struct io_ring_ctx *ctx = node->rsrc_data->ctx;
-       bool first_add = false;
-       unsigned long delay = HZ;
 
        node->done = true;
-
-       /* if we are mid-quiesce then do not delay */
-       if (node->rsrc_data->quiesce)
-               delay = 0;
-
        while (!list_empty(&ctx->rsrc_ref_list)) {
                node = list_first_entry(&ctx->rsrc_ref_list,
                                            struct io_rsrc_node, node);
                /* recycle ref nodes in order */
                if (!node->done)
                        break;
-               list_del(&node->node);
-               first_add |= llist_add(&node->llist, &ctx->rsrc_put_llist);
-       }
 
-       if (!first_add)
-               return;
-
-       if (ctx->submitter_task) {
-               if (!task_work_add(ctx->submitter_task, &ctx->rsrc_put_tw,
-                                  ctx->notify_method))
-                       return;
+               list_del(&node->node);
+               __io_rsrc_put_work(node);
        }
-       mod_delayed_work(system_wq, &ctx->rsrc_put_work, delay);
 }
 
-static struct io_rsrc_node *io_rsrc_node_alloc(void)
+static struct io_rsrc_node *io_rsrc_node_alloc(struct io_ring_ctx *ctx)
 {
        struct io_rsrc_node *ref_node;
+       struct io_cache_entry *entry;
 
-       ref_node = kzalloc(sizeof(*ref_node), GFP_KERNEL);
-       if (!ref_node)
-               return NULL;
+       entry = io_alloc_cache_get(&ctx->rsrc_node_cache);
+       if (entry) {
+               ref_node = container_of(entry, struct io_rsrc_node, cache);
+       } else {
+               ref_node = kzalloc(sizeof(*ref_node), GFP_KERNEL);
+               if (!ref_node)
+                       return NULL;
+       }
 
        ref_node->refs = 1;
        INIT_LIST_HEAD(&ref_node->node);
@@ -278,7 +236,7 @@ void io_rsrc_node_switch(struct io_ring_ctx *ctx,
 
                atomic_inc(&data_to_kill->refs);
                /* put master ref */
-               io_put_rsrc_node(rsrc_node);
+               io_put_rsrc_node(ctx, rsrc_node);
                ctx->rsrc_node = NULL;
        }
 
@@ -292,7 +250,7 @@ int io_rsrc_node_switch_start(struct io_ring_ctx *ctx)
 {
        if (ctx->rsrc_backup_node)
                return 0;
-       ctx->rsrc_backup_node = io_rsrc_node_alloc();
+       ctx->rsrc_backup_node = io_rsrc_node_alloc(ctx);
        return ctx->rsrc_backup_node ? 0 : -ENOMEM;
 }
 
@@ -320,13 +278,11 @@ __cold static int io_rsrc_ref_quiesce(struct io_rsrc_data *data,
                if (ret < 0) {
                        atomic_inc(&data->refs);
                        /* wait for all works potentially completing data->done */
-                       flush_delayed_work(&ctx->rsrc_put_work);
                        reinit_completion(&data->done);
                        mutex_lock(&ctx->uring_lock);
                        break;
                }
 
-               flush_delayed_work(&ctx->rsrc_put_work);
                ret = wait_for_completion_interruptible(&data->done);
                if (!ret) {
                        mutex_lock(&ctx->uring_lock);