fsnotify: let connector point to an abstract object

Make the code to attach/detach a connector to object more generic
by letting the fsnotify connector point to an abstract fsnotify_connp_t.
Code that needs to dereference an inode or mount object now uses the
helpers fsnotify_conn_{inode,mount}.

Signed-off-by: Amir Goldstein <amir73il@gmail.com>
Signed-off-by: Jan Kara <jack@suse.cz>

5 files changed, 45 insertions, 37 deletions

diff --git a/fs/notify/fdinfo.c b/fs/notify/fdinfo.c
index 10aac1942c9f..86fcf5814279 100644
--- a/fs/notify/fdinfo.c
+++ b/fs/notify/fdinfo.c
@@ -15,7 +15,7 @@
 #include <linux/exportfs.h>
 
 #include "inotify/inotify.h"
-#include "../fs/mount.h"
+#include "fsnotify.h"
 
 #if defined(CONFIG_PROC_FS)
 
@@ -81,7 +81,7 @@ static void inotify_fdinfo(struct seq_file *m, struct fsnotify_mark *mark)
                 return;
 
         inode_mark = container_of(mark, struct inotify_inode_mark, fsn_mark);
-        inode = igrab(mark->connector->inode);
+        inode = igrab(fsnotify_conn_inode(mark->connector));
         if (inode) {
                 /*
                  * IN_ALL_EVENTS represents all of the mask bits
@@ -117,7 +117,7 @@ static void fanotify_fdinfo(struct seq_file *m, struct fsnotify_mark *mark)
                 mflags |= FAN_MARK_IGNORED_SURV_MODIFY;
 
         if (mark->connector->type == FSNOTIFY_OBJ_TYPE_INODE) {
-                inode = igrab(mark->connector->inode);
+                inode = igrab(fsnotify_conn_inode(mark->connector));
                 if (!inode)
                         return;
                 seq_printf(m, "fanotify ino:%lx sdev:%x mflags:%x mask:%x ignored_mask:%x ",
@@ -127,7 +127,7 @@ static void fanotify_fdinfo(struct seq_file *m, struct fsnotify_mark *mark)
                 seq_putc(m, '\n');
                 iput(inode);
         } else if (mark->connector->type == FSNOTIFY_OBJ_TYPE_VFSMOUNT) {
-                struct mount *mnt = real_mount(mark->connector->mnt);
+                struct mount *mnt = fsnotify_conn_mount(mark->connector);
 
                 seq_printf(m, "fanotify mnt_id:%x mflags:%x mask:%x ignored_mask:%x\n",
                            mnt->mnt_id, mflags, mark->mask, mark->ignored_mask);
diff --git a/fs/notify/fsnotify.h b/fs/notify/fsnotify.h
index caeee042d1cc..7902653dd577 100644
--- a/fs/notify/fsnotify.h
+++ b/fs/notify/fsnotify.h
@@ -9,14 +9,16 @@
 
 #include "../mount.h"
 
-static inline struct inode *fsnotify_obj_inode(fsnotify_connp_t *connp)
+static inline struct inode *fsnotify_conn_inode(
+                                struct fsnotify_mark_connector *conn)
 {
-        return container_of(connp, struct inode, i_fsnotify_marks);
+        return container_of(conn->obj, struct inode, i_fsnotify_marks);
 }
 
-static inline struct mount *fsnotify_obj_mount(fsnotify_connp_t *connp)
+static inline struct mount *fsnotify_conn_mount(
+                                struct fsnotify_mark_connector *conn)
 {
-        return container_of(connp, struct mount, mnt_fsnotify_marks);
+        return container_of(conn->obj, struct mount, mnt_fsnotify_marks);
 }
 
 /* destroy all events sitting in this groups notification queue */
diff --git a/fs/notify/mark.c b/fs/notify/mark.c
index 7abb73b5beba..959bc73aaae7 100644
--- a/fs/notify/mark.c
+++ b/fs/notify/mark.c
@@ -120,14 +120,14 @@ static void __fsnotify_recalc_mask(struct fsnotify_mark_connector *conn)
                         new_mask |= mark->mask;
         }
         if (conn->type == FSNOTIFY_OBJ_TYPE_INODE)
-                conn->inode->i_fsnotify_mask = new_mask;
+                fsnotify_conn_inode(conn)->i_fsnotify_mask = new_mask;
         else if (conn->type == FSNOTIFY_OBJ_TYPE_VFSMOUNT)
-                real_mount(conn->mnt)->mnt_fsnotify_mask = new_mask;
+                fsnotify_conn_mount(conn)->mnt_fsnotify_mask = new_mask;
 }
 
 /*
  * Calculate mask of events for a list of marks. The caller must make sure
- * connector and connector->inode cannot disappear under us.  Callers achieve
+ * connector and connector->obj cannot disappear under us.  Callers achieve
  * this by holding a mark->lock or mark->group->mark_mutex for a mark on this
  * list.
  */
@@ -140,7 +140,8 @@ void fsnotify_recalc_mask(struct fsnotify_mark_connector *conn)
         __fsnotify_recalc_mask(conn);
         spin_unlock(&conn->lock);
         if (conn->type == FSNOTIFY_OBJ_TYPE_INODE)
-                __fsnotify_update_child_dentry_flags(conn->inode);
+                __fsnotify_update_child_dentry_flags(
+                                        fsnotify_conn_inode(conn));
 }
 
 /* Free all connectors queued for freeing once SRCU period ends */
@@ -166,20 +167,20 @@ static struct inode *fsnotify_detach_connector_from_object(
 {
         struct inode *inode = NULL;
 
+        if (conn->type == FSNOTIFY_OBJ_TYPE_DETACHED)
+                return NULL;
+
         if (conn->type == FSNOTIFY_OBJ_TYPE_INODE) {
-                inode = conn->inode;
-                rcu_assign_pointer(inode->i_fsnotify_marks, NULL);
+                inode = fsnotify_conn_inode(conn);
                 inode->i_fsnotify_mask = 0;
-                conn->inode = NULL;
-                conn->type = FSNOTIFY_OBJ_TYPE_DETACHED;
         } else if (conn->type == FSNOTIFY_OBJ_TYPE_VFSMOUNT) {
-                rcu_assign_pointer(real_mount(conn->mnt)->mnt_fsnotify_marks,
-                                   NULL);
-                real_mount(conn->mnt)->mnt_fsnotify_mask = 0;
-                conn->mnt = NULL;
-                conn->type = FSNOTIFY_OBJ_TYPE_DETACHED;
+                fsnotify_conn_mount(conn)->mnt_fsnotify_mask = 0;
         }
 
+        rcu_assign_pointer(*(conn->obj), NULL);
+        conn->obj = NULL;
+        conn->type = FSNOTIFY_OBJ_TYPE_DETACHED;
+
         return inode;
 }
 
@@ -448,10 +449,9 @@ static int fsnotify_attach_connector_to_object(fsnotify_connp_t *connp,
         spin_lock_init(&conn->lock);
         INIT_HLIST_HEAD(&conn->list);
         conn->type = type;
+        conn->obj = connp;
         if (conn->type == FSNOTIFY_OBJ_TYPE_INODE)
-                inode = conn->inode = igrab(fsnotify_obj_inode(connp));
-        else if (conn->type == FSNOTIFY_OBJ_TYPE_VFSMOUNT)
-                conn->mnt = &fsnotify_obj_mount(connp)->mnt;
+                inode = igrab(fsnotify_conn_inode(conn));
         /*
          * cmpxchg() provides the barrier so that readers of *connp can see
          * only initialized structure
diff --git a/include/linux/fsnotify_backend.h b/include/linux/fsnotify_backend.h
index 8efb8663453d..381cfb0e67fa 100644
--- a/include/linux/fsnotify_backend.h
+++ b/include/linux/fsnotify_backend.h
@@ -256,6 +256,13 @@ FSNOTIFY_ITER_FUNCS(vfsmount, VFSMOUNT)
         for (type = 0; type < FSNOTIFY_OBJ_TYPE_COUNT; type++)
 
 /*
+ * fsnotify_connp_t is what we embed in objects which connector can be attached
+ * to. fsnotify_connp_t * is how we refer from connector back to object.
+ */
+struct fsnotify_mark_connector;
+typedef struct fsnotify_mark_connector __rcu *fsnotify_connp_t;
+
+/*
  * Inode / vfsmount point to this structure which tracks all marks attached to
  * the inode / vfsmount. The reference to inode / vfsmount is held by this
  * structure. We destroy this structure when there are no more marks attached
@@ -264,17 +271,15 @@ FSNOTIFY_ITER_FUNCS(vfsmount, VFSMOUNT)
 struct fsnotify_mark_connector {
         spinlock_t lock;
         unsigned int type;      /* Type of object [lock] */
-        union { /* Object pointer [lock] */
-                struct inode *inode;
-                struct vfsmount *mnt;
+        union {
+                /* Object pointer [lock] */
+                fsnotify_connp_t *obj;
                 /* Used listing heads to free after srcu period expires */
                 struct fsnotify_mark_connector *destroy_next;
         };
         struct hlist_head list;
 };
 
-typedef struct fsnotify_mark_connector __rcu *fsnotify_connp_t;
-
 /*
  * A mark is simply an object attached to an in core inode which allows an
  * fsnotify listener to indicate they are either no longer interested in events
diff --git a/kernel/audit_tree.c b/kernel/audit_tree.c
index c99ebaae5abc..02feef939560 100644
--- a/kernel/audit_tree.c
+++ b/kernel/audit_tree.c
@@ -168,7 +168,8 @@ static __cacheline_aligned_in_smp DEFINE_SPINLOCK(hash_lock);
 /* Function to return search key in our hash from inode. */
 static unsigned long inode_to_key(const struct inode *inode)
 {
-        return (unsigned long)inode;
+        /* Use address pointed to by connector->obj as the key */
+        return (unsigned long)&inode->i_fsnotify_marks;
 }
 
 /*
@@ -183,7 +184,7 @@ static unsigned long chunk_to_key(struct audit_chunk *chunk)
          */
         if (WARN_ON_ONCE(!chunk->mark.connector))
                 return 0;
-        return (unsigned long)chunk->mark.connector->inode;
+        return (unsigned long)chunk->mark.connector->obj;
 }
 
 static inline struct list_head *chunk_hash(unsigned long key)
@@ -258,7 +259,7 @@ static void untag_chunk(struct node *p)
         spin_lock(&entry->lock);
         /*
          * mark_mutex protects mark from getting detached and thus also from
-         * mark->connector->inode getting NULL.
+         * mark->connector->obj getting NULL.
          */
         if (chunk->dead || !(entry->flags & FSNOTIFY_MARK_FLAG_ATTACHED)) {
                 spin_unlock(&entry->lock);
@@ -288,8 +289,8 @@ static void untag_chunk(struct node *p)
         if (!new)
                 goto Fallback;
 
-        if (fsnotify_add_inode_mark_locked(&new->mark, entry->connector->inode,
-                                           1)) {
+        if (fsnotify_add_mark_locked(&new->mark, entry->connector->obj,
+                                     FSNOTIFY_OBJ_TYPE_INODE, 1)) {
                 fsnotify_put_mark(&new->mark);
                 goto Fallback;
         }
@@ -423,7 +424,7 @@ static int tag_chunk(struct inode *inode, struct audit_tree *tree)
         spin_lock(&old_entry->lock);
         /*
          * mark_mutex protects mark from getting detached and thus also from
-         * mark->connector->inode getting NULL.
+         * mark->connector->obj getting NULL.
          */
         if (!(old_entry->flags & FSNOTIFY_MARK_FLAG_ATTACHED)) {
                 /* old_entry is being shot, lets just lie */
@@ -434,8 +435,8 @@ static int tag_chunk(struct inode *inode, struct audit_tree *tree)
                 return -ENOENT;
         }
 
-        if (fsnotify_add_inode_mark_locked(chunk_entry,
-                             old_entry->connector->inode, 1)) {
+        if (fsnotify_add_mark_locked(chunk_entry, old_entry->connector->obj,
+                                     FSNOTIFY_OBJ_TYPE_INODE, 1)) {
                 spin_unlock(&old_entry->lock);
                 mutex_unlock(&old_entry->group->mark_mutex);
                 fsnotify_put_mark(chunk_entry);