@@ -6,6 +6,7 @@
fscache-y := \
cache.o \
cookie.o \
+ dispatcher.o \
fsdef.o \
main.o \
netfs.o \
new file mode 100644
@@ -0,0 +1,145 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/* Object dispatcher
+ *
+ * Copyright (C) 2020 Red Hat, Inc. All Rights Reserved.
+ * Written by David Howells (dhowells@redhat.com)
+ */
+
+#define FSCACHE_DEBUG_LEVEL OPERATION
+#include <linux/kthread.h>
+#include <linux/slab.h>
+#include <linux/wait.h>
+#include <linux/freezer.h>
+#include "internal.h"
+
+#define FSCACHE_DISPATCHER_POOL_SIZE 8
+
+static LIST_HEAD(fscache_pending_work);
+static DEFINE_SPINLOCK(fscache_work_lock);
+static DECLARE_WAIT_QUEUE_HEAD(fscache_dispatcher_pool);
+static struct completion fscache_dispatcher_pool_done[FSCACHE_DISPATCHER_POOL_SIZE];
+static bool fscache_dispatcher_stop;
+
+struct fscache_work {
+ struct list_head link;
+ struct fscache_cookie *cookie;
+ struct fscache_object *object;
+ int param;
+ void (*func)(struct fscache_cookie *, struct fscache_object *, int);
+};
+
+/*
+ * Attempt to queue some work to do. If there's too much asynchronous work
+ * already queued, we'll do it here in this thread instead.
+ */
+void fscache_dispatch(struct fscache_cookie *cookie,
+ struct fscache_object *object,
+ int param,
+ void (*func)(struct fscache_cookie *,
+ struct fscache_object *, int))
+{
+ struct fscache_work *work;
+ bool queued = false;
+
+ work = kzalloc(sizeof(struct fscache_work), GFP_KERNEL);
+ if (work) {
+ work->cookie = cookie;
+ work->object = object;
+ work->param = param;
+ work->func = func;
+
+ spin_lock(&fscache_work_lock);
+ if (waitqueue_active(&fscache_dispatcher_pool) ||
+ list_empty(&fscache_pending_work)) {
+ fscache_cookie_get(cookie, fscache_cookie_get_work);
+ list_add_tail(&work->link, &fscache_pending_work);
+ wake_up(&fscache_dispatcher_pool);
+ queued = true;
+ }
+ spin_unlock(&fscache_work_lock);
+ }
+
+ if (!queued) {
+ kfree(work);
+ func(cookie, object, param);
+ }
+}
+
+/*
+ * A dispatcher thread.
+ */
+static int fscache_dispatcher(void *data)
+{
+ struct completion *done = data;
+
+ for (;;) {
+ if (!list_empty(&fscache_pending_work)) {
+ struct fscache_work *work = NULL;
+
+ spin_lock(&fscache_work_lock);
+ if (!list_empty(&fscache_pending_work)) {
+ work = list_entry(fscache_pending_work.next,
+ struct fscache_work, link);
+ list_del_init(&work->link);
+ }
+ spin_unlock(&fscache_work_lock);
+
+ if (work) {
+ work->func(work->cookie, work->object, work->param);
+ fscache_cookie_put(work->cookie, fscache_cookie_put_work);
+ kfree(work);
+ }
+ continue;
+ } else if (fscache_dispatcher_stop) {
+ break;
+ }
+
+ wait_event_freezable(fscache_dispatcher_pool,
+ (fscache_dispatcher_stop ||
+ !list_empty(&fscache_pending_work)));
+ }
+
+ complete_and_exit(done, 0);
+}
+
+/*
+ * Start up the dispatcher threads.
+ */
+int fscache_init_dispatchers(void)
+{
+ struct task_struct *t;
+ int i;
+
+ for (i = 0; i < FSCACHE_DISPATCHER_POOL_SIZE; i++) {
+ init_completion(&fscache_dispatcher_pool_done[i]);
+ t = kthread_create(fscache_dispatcher,
+ &fscache_dispatcher_pool_done[i],
+ "kfsc/%d", i);
+ if (IS_ERR(t))
+ goto failed;
+ wake_up_process(t);
+ }
+
+ return 0;
+
+failed:
+ fscache_dispatcher_stop = true;
+ wake_up_all(&fscache_dispatcher_pool);
+ for (i--; i >= 0; i--)
+ wait_for_completion(&fscache_dispatcher_pool_done[i]);
+ return PTR_ERR(t);
+}
+
+/*
+ * Kill off the dispatcher threads.
+ */
+void fscache_kill_dispatchers(void)
+{
+ int i;
+
+ fscache_dispatcher_stop = true;
+ wake_up_all(&fscache_dispatcher_pool);
+
+ for (i = 0; i < FSCACHE_DISPATCHER_POOL_SIZE; i++)
+ wait_for_completion(&fscache_dispatcher_pool_done[i]);
+}
@@ -75,6 +75,14 @@ extern struct fscache_cookie *fscache_hash_cookie(struct fscache_cookie *);
extern void fscache_cookie_put(struct fscache_cookie *,
enum fscache_cookie_trace);
+/*
+ * dispatcher.c
+ */
+extern void fscache_dispatch(struct fscache_cookie *, struct fscache_object *, int,
+ void (*func)(struct fscache_cookie *, struct fscache_object *, int));
+extern int fscache_init_dispatchers(void);
+extern void fscache_kill_dispatchers(void);
+
/*
* fsdef.c
*/
@@ -125,6 +125,10 @@ static int __init fscache_init(void)
for_each_possible_cpu(cpu)
init_waitqueue_head(&per_cpu(fscache_object_cong_wait, cpu));
+ ret = fscache_init_dispatchers();
+ if (ret < 0)
+ goto error_dispatchers;
+
ret = fscache_proc_init();
if (ret < 0)
goto error_proc;
@@ -159,6 +163,8 @@ static int __init fscache_init(void)
unregister_sysctl_table(fscache_sysctl_header);
error_sysctl:
#endif
+ fscache_kill_dispatchers();
+error_dispatchers:
fscache_proc_cleanup();
error_proc:
destroy_workqueue(fscache_op_wq);
@@ -183,6 +189,7 @@ static void __exit fscache_exit(void)
unregister_sysctl_table(fscache_sysctl_header);
#endif
fscache_proc_cleanup();
+ fscache_kill_dispatchers();
destroy_workqueue(fscache_op_wq);
destroy_workqueue(fscache_object_wq);
pr_notice("Unloaded\n");
@@ -26,11 +26,13 @@ enum fscache_cookie_trace {
fscache_cookie_get_attach_object,
fscache_cookie_get_reacquire,
fscache_cookie_get_register_netfs,
+ fscache_cookie_get_work,
fscache_cookie_put_acquire_nobufs,
fscache_cookie_put_dup_netfs,
fscache_cookie_put_relinquish,
fscache_cookie_put_object,
fscache_cookie_put_parent,
+ fscache_cookie_put_work,
};
#endif
@@ -45,11 +47,13 @@ enum fscache_cookie_trace {
EM(fscache_cookie_get_attach_object, "GET obj") \
EM(fscache_cookie_get_reacquire, "GET raq") \
EM(fscache_cookie_get_register_netfs, "GET net") \
+ EM(fscache_cookie_get_work, "GET wrk") \
EM(fscache_cookie_put_acquire_nobufs, "PUT nbf") \
EM(fscache_cookie_put_dup_netfs, "PUT dnt") \
EM(fscache_cookie_put_relinquish, "PUT rlq") \
EM(fscache_cookie_put_object, "PUT obj") \
- E_(fscache_cookie_put_parent, "PUT prn")
+ EM(fscache_cookie_put_parent, "PUT prn") \
+ E_(fscache_cookie_put_work, "PUT wrk")
/*
* Export enum symbols via userspace.
Provide a simple thread pool that can be used to run cookie management operations in the background and a dispatcher infrastructure to punt operations to the pool if threads are available or to just run the operation in the calling thread if not. A future patch will replace all the object state machine stuff with whole routines that do all the work in one go without trying to interleave bits from various objects. Signed-off-by: David Howells <dhowells@redhat.com> --- fs/fscache/Makefile | 1 fs/fscache/dispatcher.c | 145 ++++++++++++++++++++++++++++++++++++++++ fs/fscache/internal.h | 8 ++ fs/fscache/main.c | 7 ++ include/trace/events/fscache.h | 6 +- 5 files changed, 166 insertions(+), 1 deletion(-) create mode 100644 fs/fscache/dispatcher.c