fuse: add fuse_iqueue_ops callbacks

The /dev/fuse device uses fiq->waitq and fasync to signal that requests are
available.  These mechanisms do not apply to virtio-fs.  This patch
introduces callbacks so alternative behavior can be used.

Note that queue_interrupt() changes along these lines:

  spin_lock(&fiq->waitq.lock);
  wake_up_locked(&fiq->waitq);
+ kill_fasync(&fiq->fasync, SIGIO, POLL_IN);
  spin_unlock(&fiq->waitq.lock);
- kill_fasync(&fiq->fasync, SIGIO, POLL_IN);

Since queue_request() and queue_forget() also call kill_fasync() inside
the spinlock this should be safe.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Miklos Szeredi <mszeredi@redhat.com>

4 files changed, 81 insertions, 22 deletions

diff --git a/fs/fuse/cuse.c b/fs/fuse/cuse.c
index 2332e7f960a8..6a0de0ce4403 100644
--- a/fs/fuse/cuse.c
+++ b/fs/fuse/cuse.c
@@ -506,7 +506,7 @@ static int cuse_channel_open(struct inode *inode, struct file *file)
          * Limit the cuse channel to requests that can
          * be represented in file->f_cred->user_ns.
          */
-        fuse_conn_init(&cc->fc, file->f_cred->user_ns);
+        fuse_conn_init(&cc->fc, file->f_cred->user_ns, &fuse_dev_fiq_ops, NULL);
 
         fud = fuse_dev_alloc(&cc->fc);
         if (!fud) {
diff --git a/fs/fuse/dev.c b/fs/fuse/dev.c
index 943bc5cf941a..358a01435058 100644
--- a/fs/fuse/dev.c
+++ b/fs/fuse/dev.c
@@ -201,14 +201,33 @@ static unsigned int fuse_req_hash(u64 unique)
         return hash_long(unique & ~FUSE_INT_REQ_BIT, FUSE_PQ_HASH_BITS);
 }
 
-static void queue_request(struct fuse_iqueue *fiq, struct fuse_req *req)
+/**
+ * A new request is available, wake fiq->waitq
+ */
+static void fuse_dev_wake_and_unlock(struct fuse_iqueue *fiq)
+__releases(fiq->lock)
+{
+        wake_up(&fiq->waitq);
+        kill_fasync(&fiq->fasync, SIGIO, POLL_IN);
+        spin_unlock(&fiq->lock);
+}
+
+const struct fuse_iqueue_ops fuse_dev_fiq_ops = {
+        .wake_forget_and_unlock         = fuse_dev_wake_and_unlock,
+        .wake_interrupt_and_unlock      = fuse_dev_wake_and_unlock,
+        .wake_pending_and_unlock        = fuse_dev_wake_and_unlock,
+};
+EXPORT_SYMBOL_GPL(fuse_dev_fiq_ops);
+
+static void queue_request_and_unlock(struct fuse_iqueue *fiq,
+                                     struct fuse_req *req)
+__releases(fiq->lock)
 {
         req->in.h.len = sizeof(struct fuse_in_header) +
                 fuse_len_args(req->args->in_numargs,
                               (struct fuse_arg *) req->args->in_args);
         list_add_tail(&req->list, &fiq->pending);
-        wake_up(&fiq->waitq);
-        kill_fasync(&fiq->fasync, SIGIO, POLL_IN);
+        fiq->ops->wake_pending_and_unlock(fiq);
 }
 
 void fuse_queue_forget(struct fuse_conn *fc, struct fuse_forget_link *forget,
@@ -223,12 +242,11 @@ void fuse_queue_forget(struct fuse_conn *fc, struct fuse_forget_link *forget,
         if (fiq->connected) {
                 fiq->forget_list_tail->next = forget;
                 fiq->forget_list_tail = forget;
-                wake_up(&fiq->waitq);
-                kill_fasync(&fiq->fasync, SIGIO, POLL_IN);
+                fiq->ops->wake_forget_and_unlock(fiq);
         } else {
                 kfree(forget);
+                spin_unlock(&fiq->lock);
         }
-        spin_unlock(&fiq->lock);
 }
 
 static void flush_bg_queue(struct fuse_conn *fc)
@@ -244,8 +262,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(fiq, req);
-                spin_unlock(&fiq->lock);
+                queue_request_and_unlock(fiq, req);
         }
 }
 
@@ -334,10 +351,10 @@ static int queue_interrupt(struct fuse_iqueue *fiq, struct fuse_req *req)
                         spin_unlock(&fiq->lock);
                         return 0;
                 }
-                wake_up(&fiq->waitq);
-                kill_fasync(&fiq->fasync, SIGIO, POLL_IN);
+                fiq->ops->wake_interrupt_and_unlock(fiq);
+        } else {
+                spin_unlock(&fiq->lock);
         }
-        spin_unlock(&fiq->lock);
         return 0;
 }
 
@@ -397,11 +414,10 @@ static void __fuse_request_send(struct fuse_conn *fc, struct fuse_req *req)
                 req->out.h.error = -ENOTCONN;
         } else {
                 req->in.h.unique = fuse_get_unique(fiq);
-                queue_request(fiq, req);
                 /* acquire extra reference, since request is still needed
                    after fuse_request_end() */
                 __fuse_get_request(req);
-                spin_unlock(&fiq->lock);
+                queue_request_and_unlock(fiq, req);
 
                 request_wait_answer(fc, req);
                 /* Pairs with smp_wmb() in fuse_request_end() */
@@ -570,14 +586,12 @@ static int fuse_simple_notify_reply(struct fuse_conn *fc,
 
         spin_lock(&fiq->lock);
         if (fiq->connected) {
-                queue_request(fiq, req);
-                spin_unlock(&fiq->lock);
+                queue_request_and_unlock(fiq, req);
         } else {
                 err = -ENODEV;
                 spin_unlock(&fiq->lock);
                 fuse_put_request(fc, req);
         }
-        spin_unlock(&fiq->lock);
 
         return err;
 }
diff --git a/fs/fuse/fuse_i.h b/fs/fuse/fuse_i.h
index 1902148281cc..8c13865955d4 100644
--- a/fs/fuse/fuse_i.h
+++ b/fs/fuse/fuse_i.h
@@ -355,6 +355,39 @@ struct fuse_req {
 
 };
 
+struct fuse_iqueue;
+
+/**
+ * Input queue callbacks
+ *
+ * Input queue signalling is device-specific.  For example, the /dev/fuse file
+ * uses fiq->waitq and fasync to wake processes that are waiting on queue
+ * readiness.  These callbacks allow other device types to respond to input
+ * queue activity.
+ */
+struct fuse_iqueue_ops {
+        /**
+         * Signal that a forget has been queued
+         */
+        void (*wake_forget_and_unlock)(struct fuse_iqueue *fiq)
+                __releases(fiq->lock);
+
+        /**
+         * Signal that an INTERRUPT request has been queued
+         */
+        void (*wake_interrupt_and_unlock)(struct fuse_iqueue *fiq)
+                __releases(fiq->lock);
+
+        /**
+         * Signal that a request has been queued
+         */
+        void (*wake_pending_and_unlock)(struct fuse_iqueue *fiq)
+                __releases(fiq->lock);
+};
+
+/** /dev/fuse input queue operations */
+extern const struct fuse_iqueue_ops fuse_dev_fiq_ops;
+
 struct fuse_iqueue {
         /** Connection established */
         unsigned connected;
@@ -383,6 +416,12 @@ struct fuse_iqueue {
 
         /** O_ASYNC requests */
         struct fasync_struct *fasync;
+
+        /** Device-specific callbacks */
+        const struct fuse_iqueue_ops *ops;
+
+        /** Device-specific state */
+        void *priv;
 };
 
 #define FUSE_PQ_HASH_BITS 8
@@ -882,7 +921,8 @@ struct fuse_conn *fuse_conn_get(struct fuse_conn *fc);
 /**
  * Initialize fuse_conn
  */
-void fuse_conn_init(struct fuse_conn *fc, struct user_namespace *user_ns);
+void fuse_conn_init(struct fuse_conn *fc, struct user_namespace *user_ns,
+                    const struct fuse_iqueue_ops *fiq_ops, void *fiq_priv);
 
 /**
  * Release reference to fuse_conn
diff --git a/fs/fuse/inode.c b/fs/fuse/inode.c
index 30d92e633ece..734fdd597c3e 100644
--- a/fs/fuse/inode.c
+++ b/fs/fuse/inode.c
@@ -568,7 +568,9 @@ static int fuse_show_options(struct seq_file *m, struct dentry *root)
         return 0;
 }
 
-static void fuse_iqueue_init(struct fuse_iqueue *fiq)
+static void fuse_iqueue_init(struct fuse_iqueue *fiq,
+                             const struct fuse_iqueue_ops *ops,
+                             void *priv)
 {
         memset(fiq, 0, sizeof(struct fuse_iqueue));
         spin_lock_init(&fiq->lock);
@@ -577,6 +579,8 @@ static void fuse_iqueue_init(struct fuse_iqueue *fiq)
         INIT_LIST_HEAD(&fiq->interrupts);
         fiq->forget_list_tail = &fiq->forget_list_head;
         fiq->connected = 1;
+        fiq->ops = ops;
+        fiq->priv = priv;
 }
 
 static void fuse_pqueue_init(struct fuse_pqueue *fpq)
@@ -590,7 +594,8 @@ static void fuse_pqueue_init(struct fuse_pqueue *fpq)
         fpq->connected = 1;
 }
 
-void fuse_conn_init(struct fuse_conn *fc, struct user_namespace *user_ns)
+void fuse_conn_init(struct fuse_conn *fc, struct user_namespace *user_ns,
+                    const struct fuse_iqueue_ops *fiq_ops, void *fiq_priv)
 {
         memset(fc, 0, sizeof(*fc));
         spin_lock_init(&fc->lock);
@@ -599,7 +604,7 @@ void fuse_conn_init(struct fuse_conn *fc, struct user_namespace *user_ns)
         refcount_set(&fc->count, 1);
         atomic_set(&fc->dev_count, 1);
         init_waitqueue_head(&fc->blocked_waitq);
-        fuse_iqueue_init(&fc->iq);
+        fuse_iqueue_init(&fc->iq, fiq_ops, fiq_priv);
         INIT_LIST_HEAD(&fc->bg_queue);
         INIT_LIST_HEAD(&fc->entry);
         INIT_LIST_HEAD(&fc->devices);
@@ -1209,7 +1214,7 @@ static int fuse_fill_super(struct super_block *sb, struct fs_context *fsc)
         if (!fc)
                 goto err_fput;
 
-        fuse_conn_init(fc, sb->s_user_ns);
+        fuse_conn_init(fc, sb->s_user_ns, &fuse_dev_fiq_ops, NULL);
         fc->release = fuse_free_conn;
         sb->s_fs_info = fc;