fsnotify: pass connp and object type to fsnotify_add_mark()

Instead of passing inode and vfsmount arguments to fsnotify_add_mark()
and its _locked variant, pass an abstract object pointer and the object
type.

The helpers fsnotify_obj_{inode,mount} are added to get the concrete
object pointer from abstract object pointer.

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

diff --git a/fs/notify/fanotify/fanotify_user.c b/fs/notify/fanotify/fanotify_user.c
index ec4d8c5..81212b2 100644 (file)
--- a/fs/notify/fanotify/fanotify_user.c
+++ b/fs/notify/fanotify/fanotify_user.c
@@ -615,8 +615,8 @@ static __u32 fanotify_mark_add_to_mask(struct fsnotify_mark *fsn_mark,
 }
 
 static struct fsnotify_mark *fanotify_add_new_mark(struct fsnotify_group *group,
-                                                  struct inode *inode,
-                                                  struct vfsmount *mnt)
+                                                  fsnotify_connp_t *connp,
+                                                  unsigned int type)
 {
        struct fsnotify_mark *mark;
        int ret;
@@ -629,7 +629,7 @@ static struct fsnotify_mark *fanotify_add_new_mark(struct fsnotify_group *group,
                return ERR_PTR(-ENOMEM);
 
        fsnotify_init_mark(mark, group);
-       ret = fsnotify_add_mark_locked(mark, inode, mnt, 0);
+       ret = fsnotify_add_mark_locked(mark, connp, type, 0);
        if (ret) {
                fsnotify_put_mark(mark);
                return ERR_PTR(ret);
@@ -643,14 +643,15 @@ static int fanotify_add_vfsmount_mark(struct fsnotify_group *group,
                                      struct vfsmount *mnt, __u32 mask,
                                      unsigned int flags)
 {
+       fsnotify_connp_t *connp = &real_mount(mnt)->mnt_fsnotify_marks;
        struct fsnotify_mark *fsn_mark;
        __u32 added;
 
        mutex_lock(&group->mark_mutex);
-       fsn_mark = fsnotify_find_mark(&real_mount(mnt)->mnt_fsnotify_marks,
-                                     group);
+       fsn_mark = fsnotify_find_mark(connp, group);
        if (!fsn_mark) {
-               fsn_mark = fanotify_add_new_mark(group, NULL, mnt);
+               fsn_mark = fanotify_add_new_mark(group, connp,
+                                                FSNOTIFY_OBJ_TYPE_VFSMOUNT);
                if (IS_ERR(fsn_mark)) {
                        mutex_unlock(&group->mark_mutex);
                        return PTR_ERR(fsn_mark);
@@ -669,6 +670,7 @@ static int fanotify_add_inode_mark(struct fsnotify_group *group,
                                   struct inode *inode, __u32 mask,
                                   unsigned int flags)
 {
+       fsnotify_connp_t *connp = &inode->i_fsnotify_marks;
        struct fsnotify_mark *fsn_mark;
        __u32 added;
 
@@ -685,9 +687,10 @@ static int fanotify_add_inode_mark(struct fsnotify_group *group,
                return 0;
 
        mutex_lock(&group->mark_mutex);
-       fsn_mark = fsnotify_find_mark(&inode->i_fsnotify_marks, group);
+       fsn_mark = fsnotify_find_mark(connp, group);
        if (!fsn_mark) {
-               fsn_mark = fanotify_add_new_mark(group, inode, NULL);
+               fsn_mark = fanotify_add_new_mark(group, connp,
+                                                FSNOTIFY_OBJ_TYPE_INODE);
                if (IS_ERR(fsn_mark)) {
                        mutex_unlock(&group->mark_mutex);
                        return PTR_ERR(fsn_mark);

diff --git a/fs/notify/fsnotify.h b/fs/notify/fsnotify.h
index 94cedf8..caeee04 100644 (file)
--- a/fs/notify/fsnotify.h
+++ b/fs/notify/fsnotify.h
@@ -9,6 +9,16 @@
 
 #include "../mount.h"
 
+static inline struct inode *fsnotify_obj_inode(fsnotify_connp_t *connp)
+{
+       return container_of(connp, struct inode, i_fsnotify_marks);
+}
+
+static inline struct mount *fsnotify_obj_mount(fsnotify_connp_t *connp)
+{
+       return container_of(connp, struct mount, mnt_fsnotify_marks);
+}
+
 /* destroy all events sitting in this groups notification queue */
 extern void fsnotify_flush_notify(struct fsnotify_group *group);
 

diff --git a/fs/notify/mark.c b/fs/notify/mark.c
index 7b595ac..7abb73b 100644 (file)
--- a/fs/notify/mark.c
+++ b/fs/notify/mark.c
@@ -437,9 +437,9 @@ int fsnotify_compare_groups(struct fsnotify_group *a, struct fsnotify_group *b)
 }
 
 static int fsnotify_attach_connector_to_object(fsnotify_connp_t *connp,
-                                              struct inode *inode,
-                                              struct vfsmount *mnt)
+                                              unsigned int type)
 {
+       struct inode *inode = NULL;
        struct fsnotify_mark_connector *conn;
 
        conn = kmem_cache_alloc(fsnotify_mark_connector_cachep, GFP_KERNEL);
@@ -447,13 +447,11 @@ static int fsnotify_attach_connector_to_object(fsnotify_connp_t *connp,
                return -ENOMEM;
        spin_lock_init(&conn->lock);
        INIT_HLIST_HEAD(&conn->list);
-       if (inode) {
-               conn->type = FSNOTIFY_OBJ_TYPE_INODE;
-               conn->inode = igrab(inode);
-       } else {
-               conn->type = FSNOTIFY_OBJ_TYPE_VFSMOUNT;
-               conn->mnt = mnt;
-       }
+       conn->type = type;
+       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;
        /*
         * cmpxchg() provides the barrier so that readers of *connp can see
         * only initialized structure
@@ -502,27 +500,22 @@ out:
  * priority, highest number first, and then by the group's location in memory.
  */
 static int fsnotify_add_mark_list(struct fsnotify_mark *mark,
-                                 struct inode *inode, struct vfsmount *mnt,
+                                 fsnotify_connp_t *connp, unsigned int type,
                                  int allow_dups)
 {
        struct fsnotify_mark *lmark, *last = NULL;
        struct fsnotify_mark_connector *conn;
-       fsnotify_connp_t *connp;
        int cmp;
        int err = 0;
 
-       if (WARN_ON(!inode && !mnt))
+       if (WARN_ON(!fsnotify_valid_obj_type(type)))
                return -EINVAL;
-       if (inode)
-               connp = &inode->i_fsnotify_marks;
-       else
-               connp = &real_mount(mnt)->mnt_fsnotify_marks;
 restart:
        spin_lock(&mark->lock);
        conn = fsnotify_grab_connector(connp);
        if (!conn) {
                spin_unlock(&mark->lock);
-               err = fsnotify_attach_connector_to_object(connp, inode, mnt);
+               err = fsnotify_attach_connector_to_object(connp, type);
                if (err)
                        return err;
                goto restart;
@@ -568,14 +561,13 @@ out_err:
  * These marks may be used for the fsnotify backend to determine which
  * event types should be delivered to which group.
  */
-int fsnotify_add_mark_locked(struct fsnotify_mark *mark, struct inode *inode,
-                            struct vfsmount *mnt, int allow_dups)
+int fsnotify_add_mark_locked(struct fsnotify_mark *mark,
+                            fsnotify_connp_t *connp, unsigned int type,
+                            int allow_dups)
 {
        struct fsnotify_group *group = mark->group;
        int ret = 0;
 
-       BUG_ON(inode && mnt);
-       BUG_ON(!inode && !mnt);
        BUG_ON(!mutex_is_locked(&group->mark_mutex));
 
        /*
@@ -592,7 +584,7 @@ int fsnotify_add_mark_locked(struct fsnotify_mark *mark, struct inode *inode,
        fsnotify_get_mark(mark); /* for g_list */
        spin_unlock(&mark->lock);
 
-       ret = fsnotify_add_mark_list(mark, inode, mnt, allow_dups);
+       ret = fsnotify_add_mark_list(mark, connp, type, allow_dups);
        if (ret)
                goto err;
 
@@ -612,14 +604,14 @@ err:
        return ret;
 }
 
-int fsnotify_add_mark(struct fsnotify_mark *mark, struct inode *inode,
-                     struct vfsmount *mnt, int allow_dups)
+int fsnotify_add_mark(struct fsnotify_mark *mark, fsnotify_connp_t *connp,
+                     unsigned int type, int allow_dups)
 {
        int ret;
        struct fsnotify_group *group = mark->group;
 
        mutex_lock(&group->mark_mutex);
-       ret = fsnotify_add_mark_locked(mark, inode, mnt, allow_dups);
+       ret = fsnotify_add_mark_locked(mark, connp, type, allow_dups);
        mutex_unlock(&group->mark_mutex);
        return ret;
 }

diff --git a/include/linux/fsnotify_backend.h b/include/linux/fsnotify_backend.h
index e7cd7fc..8efb866 100644 (file)
--- a/include/linux/fsnotify_backend.h
+++ b/include/linux/fsnotify_backend.h
@@ -210,6 +210,11 @@ enum fsnotify_obj_type {
 #define FSNOTIFY_OBJ_TYPE_VFSMOUNT_FL  (1U << FSNOTIFY_OBJ_TYPE_VFSMOUNT)
 #define FSNOTIFY_OBJ_ALL_TYPES_MASK    ((1U << FSNOTIFY_OBJ_TYPE_COUNT) - 1)
 
+static inline bool fsnotify_valid_obj_type(unsigned int type)
+{
+       return (type < FSNOTIFY_OBJ_TYPE_COUNT);
+}
+
 struct fsnotify_iter_info {
        struct fsnotify_mark *marks[FSNOTIFY_OBJ_TYPE_COUNT];
        unsigned int report_mask;
@@ -398,24 +403,27 @@ extern void fsnotify_init_mark(struct fsnotify_mark *mark,
 /* Find mark belonging to given group in the list of marks */
 extern struct fsnotify_mark *fsnotify_find_mark(fsnotify_connp_t *connp,
                                                struct fsnotify_group *group);
-/* attach the mark to the inode or vfsmount */
-extern int fsnotify_add_mark(struct fsnotify_mark *mark, struct inode *inode,
-                            struct vfsmount *mnt, int allow_dups);
+/* attach the mark to the object */
+extern int fsnotify_add_mark(struct fsnotify_mark *mark,
+                            fsnotify_connp_t *connp, unsigned int type,
+                            int allow_dups);
 extern int fsnotify_add_mark_locked(struct fsnotify_mark *mark,
-                                   struct inode *inode, struct vfsmount *mnt,
+                                   fsnotify_connp_t *connp, unsigned int type,
                                    int allow_dups);
 /* attach the mark to the inode */
 static inline int fsnotify_add_inode_mark(struct fsnotify_mark *mark,
                                          struct inode *inode,
                                          int allow_dups)
 {
-       return fsnotify_add_mark(mark, inode, NULL, allow_dups);
+       return fsnotify_add_mark(mark, &inode->i_fsnotify_marks,
+                                FSNOTIFY_OBJ_TYPE_INODE, allow_dups);
 }
 static inline int fsnotify_add_inode_mark_locked(struct fsnotify_mark *mark,
                                                 struct inode *inode,
                                                 int allow_dups)
 {
-       return fsnotify_add_mark_locked(mark, inode, NULL, allow_dups);
+       return fsnotify_add_mark_locked(mark, &inode->i_fsnotify_marks,
+                                       FSNOTIFY_OBJ_TYPE_INODE, allow_dups);
 }
 /* given a group and a mark, flag mark to be freed when all references are dropped */
 extern void fsnotify_destroy_mark(struct fsnotify_mark *mark,