[prev in list] [next in list] [prev in thread] [next in thread]
List: fuse-devel
Subject: [fuse-devel] [PATCH 13/13] fuse: Allow to queue to the ring
From: Bernd Schubert via fuse-devel <fuse-devel () lists ! sourceforge ! net>
Date: 2023-03-21 1:10:47
Message-ID: 20230321011047.3425786-14-bschubert () ddn ! com
[Download RAW message or body]
This enabled enqueuing requests through fuse uring queues.
For initial simplicity requests are always allocated the normal way
then added to ring queues lists and only then copied to ring queue
entries. Later on the allocation and adding the requests to a list
can be avoided, by directly using a ring entry. This introduces
some code complexity and is therefore not done for now.
Signed-off-by: Bernd Schubert <bschubert@ddn.com>
cc: Miklos Szeredi <miklos@szeredi.hu>
cc: linux-fsdevel@vger.kernel.org
cc: Amir Goldstein <amir73il@gmail.com>
cc: fuse-devel@lists.sourceforge.net
---
fs/fuse/dev.c | 80 ++++++++++++++++++++++++++++++++++++++-----
fs/fuse/dev_uring.c | 68 ++++++++++++++++++++++++++++++++++++
fs/fuse/dev_uring_i.h | 1 +
3 files changed, 141 insertions(+), 8 deletions(-)
diff --git a/fs/fuse/dev.c b/fs/fuse/dev.c
index cce55eaed8a3..e82db13da8f6 100644
--- a/fs/fuse/dev.c
+++ b/fs/fuse/dev.c
@@ -211,13 +211,29 @@ const struct fuse_iqueue_ops fuse_dev_fiq_ops = {
};
EXPORT_SYMBOL_GPL(fuse_dev_fiq_ops);
-static void queue_request_and_unlock(struct fuse_iqueue *fiq,
- struct fuse_req *req)
+
+static void queue_request_and_unlock(struct fuse_conn *fc,
+ struct fuse_req *req, bool allow_uring)
__releases(fiq->lock)
{
+ struct fuse_iqueue *fiq = &fc->iq;
+
req->in.h.len = sizeof(struct fuse_in_header) +
fuse_len_args(req->args->in_numargs,
(struct fuse_arg *) req->args->in_args);
+
+ if (allow_uring && fc->ring.ready) {
+ int res;
+
+ /* this lock is not needed at all for ring req handling */
+ spin_unlock(&fiq->lock);
+ res = fuse_uring_queue_fuse_req(fc, req);
+ if (!res)
+ return;
+
+ /* fallthrough, handled through /dev/fuse read/write */
+ }
+
list_add_tail(&req->list, &fiq->pending);
fiq->ops->wake_pending_and_unlock(fiq);
}
@@ -254,7 +270,7 @@ static void flush_bg_queue(struct fuse_conn *fc)
fc->active_background++;
spin_lock(&fiq->lock);
req->in.h.unique = fuse_get_unique(fiq);
- queue_request_and_unlock(fiq, req);
+ queue_request_and_unlock(fc, req, true);
}
}
@@ -398,7 +414,8 @@ static void request_wait_answer(struct fuse_req *req)
static void __fuse_request_send(struct fuse_req *req)
{
- struct fuse_iqueue *fiq = &req->fm->fc->iq;
+ struct fuse_conn *fc = req->fm->fc;
+ struct fuse_iqueue *fiq = &fc->iq;
BUG_ON(test_bit(FR_BACKGROUND, &req->flags));
spin_lock(&fiq->lock);
@@ -410,7 +427,7 @@ static void __fuse_request_send(struct fuse_req *req)
/* acquire extra reference, since request is still needed
after fuse_request_end() */
__fuse_get_request(req);
- queue_request_and_unlock(fiq, req);
+ queue_request_and_unlock(fc, req, true);
request_wait_answer(req);
/* Pairs with smp_wmb() in fuse_request_end() */
@@ -478,6 +495,12 @@ ssize_t fuse_simple_request(struct fuse_mount *fm, struct fuse_args *args)
if (args->force) {
atomic_inc(&fc->num_waiting);
req = fuse_request_alloc(fm, GFP_KERNEL | __GFP_NOFAIL);
+ if (unlikely(!req)) {
+ /* should only happen with uring on shutdown */
+ WARN_ON(!fc->ring.configured);
+ ret = -ENOTCONN;
+ goto err;
+ }
if (!args->nocreds)
fuse_force_creds(req);
@@ -505,16 +528,55 @@ ssize_t fuse_simple_request(struct fuse_mount *fm, struct fuse_args *args)
}
fuse_put_request(req);
+err:
return ret;
}
-static bool fuse_request_queue_background(struct fuse_req *req)
+static bool fuse_request_queue_background_uring(struct fuse_conn *fc,
+ struct fuse_req *req)
+{
+ struct fuse_iqueue *fiq = &fc->iq;
+ int err;
+
+ req->in.h.unique = fuse_get_unique(fiq);
+ req->in.h.len = sizeof(struct fuse_in_header) +
+ fuse_len_args(req->args->in_numargs,
+ (struct fuse_arg *) req->args->in_args);
+
+ err = fuse_uring_queue_fuse_req(fc, req);
+ if (!err) {
+ /* XXX remove and lets the users of that use per queue values -
+ * avoid the shared spin lock...
+ * Is this needed at all?
+ */
+ spin_lock(&fc->bg_lock);
+ fc->num_background++;
+ fc->active_background++;
+
+
+ /* XXX block when per ring queues get occupied */
+ if (fc->num_background == fc->max_background)
+ fc->blocked = 1;
+ spin_unlock(&fc->bg_lock);
+ }
+
+ return err ? false : true;
+}
+
+/*
+ * @return true if queued
+ */
+static int fuse_request_queue_background(struct fuse_req *req)
{
struct fuse_mount *fm = req->fm;
struct fuse_conn *fc = fm->fc;
bool queued = false;
WARN_ON(!test_bit(FR_BACKGROUND, &req->flags));
+
+ if (fc->ring.ready)
+ return fuse_request_queue_background_uring(fc, req);
+
if (!test_bit(FR_WAITING, &req->flags)) {
__set_bit(FR_WAITING, &req->flags);
atomic_inc(&fc->num_waiting);
@@ -567,7 +629,8 @@ static int fuse_simple_notify_reply(struct fuse_mount *fm,
struct fuse_args *args, u64 unique)
{
struct fuse_req *req;
- struct fuse_iqueue *fiq = &fm->fc->iq;
+ struct fuse_conn *fc = fm->fc;
+ struct fuse_iqueue *fiq = &fc->iq;
int err = 0;
req = fuse_get_req(fm, false);
@@ -581,7 +644,8 @@ static int fuse_simple_notify_reply(struct fuse_mount *fm,
spin_lock(&fiq->lock);
if (fiq->connected) {
- queue_request_and_unlock(fiq, req);
+ /* uring for notify not supported yet */
+ queue_request_and_unlock(fc, req, false);
} else {
err = -ENODEV;
spin_unlock(&fiq->lock);
diff --git a/fs/fuse/dev_uring.c b/fs/fuse/dev_uring.c
index 5c41f9f71410..9e02e58ac688 100644
--- a/fs/fuse/dev_uring.c
+++ b/fs/fuse/dev_uring.c
@@ -330,6 +330,74 @@ __must_hold(&queue.waitq.lock)
return true;
}
+int fuse_uring_queue_fuse_req(struct fuse_conn *fc, struct fuse_req *req)
+{
+ struct fuse_ring_queue *queue;
+ int qid = 0;
+ struct fuse_ring_ent *ring_ent = NULL;
+ const size_t queue_depth = fc->ring.queue_depth;
+ int res;
+ int is_bg = test_bit(FR_BACKGROUND, &req->flags);
+ struct list_head *head;
+ int *queue_avail;
+
+ pr_devel("%s req=%p bg=%d\n", __func__, req, is_bg);
+
+ if (fc->ring.per_core_queue) {
+ qid = task_cpu(current);
+ if (unlikely(qid >= fc->ring.nr_queues)) {
+ WARN_ONCE(1, "Core number (%u) exceeds nr ueues (%zu)\n",
+ qid, fc->ring.nr_queues);
+ qid = 0;
+ }
+ }
+
+ queue = fuse_uring_get_queue(fc, qid);
+ head = is_bg ? &queue->bg_queue : &queue->fg_queue;
+ queue_avail = is_bg ? &queue->req_bg : &queue->req_fg;
+
+ spin_lock(&queue->lock);
+
+ if (unlikely(queue->aborted)) {
+ res = -ENOTCONN;
+ goto err_unlock;
+ }
+
+ list_add_tail(&req->list, head);
+ if (*queue_avail) {
+ bool got_req;
+ int tag = find_first_bit(queue->req_avail_map, queue_depth);
+
+ if (unlikely(tag == queue_depth)) {
+ pr_err("queue: no free bit found for qid=%d "
+ "qdepth=%zu av-fg=%d av-bg=%d max-fg=%zu "
+ "max-bg=%zu is_bg=%d\n", queue->qid,
+ queue_depth, queue->req_fg, queue->req_bg,
+ fc->ring.max_fg, fc->ring.max_bg, is_bg);
+
+ WARN_ON(1);
+ res = -ENOENT;
+ goto err_unlock;
+ }
+ ring_ent = &queue->ring_ent[tag];
+ got_req = fuse_uring_assign_ring_entry(ring_ent, head, is_bg);
+ if (unlikely(!got_req)) {
+ WARN_ON(1);
+ ring_ent = NULL;
+ }
+ }
+ spin_unlock(&queue->lock);
+
+ if (ring_ent != NULL)
+ fuse_uring_send_to_ring(ring_ent);
+
+ return 0;
+
+err_unlock:
+ spin_unlock(&queue->lock);
+ return res;
+}
+
/*
* Checks for errors and stores it into the request
*/
diff --git a/fs/fuse/dev_uring_i.h b/fs/fuse/dev_uring_i.h
index b0ef36215b80..42260a2a22ee 100644
--- a/fs/fuse/dev_uring_i.h
+++ b/fs/fuse/dev_uring_i.h
@@ -10,6 +10,7 @@
#include "fuse_i.h"
void fuse_uring_end_requests(struct fuse_conn *fc);
+int fuse_uring_queue_fuse_req(struct fuse_conn *fc, struct fuse_req *req);
int fuse_uring_ioctl(struct file *file, struct fuse_uring_cfg *cfg);
void fuse_uring_ring_destruct(struct fuse_conn *fc);
int fuse_uring_mmap(struct file *filp, struct vm_area_struct *vma);
--
2.37.2
--
fuse-devel mailing list
To unsubscribe or subscribe, visit https://lists.sourceforge.net/lists/listinfo/fuse-devel
[prev in list] [next in list] [prev in thread] [next in thread]
Configure |
About |
News |
Add a list |
Sponsored by KoreLogic