fsnotify: create helpers for group mark_mutex lock

Create helpers to take and release the group mark_mutex lock.

Define a flag FSNOTIFY_GROUP_NOFS in fsnotify_group that determines
if the mark_mutex lock is fs reclaim safe or not.  If not safe, the
lock helpers take the lock and disable direct fs reclaim.

In that case we annotate the mutex with a different lockdep class to
express to lockdep that an allocation of mark of an fs reclaim safe group
may take the group lock of another "NOFS" group to evict inodes.

For now, converted only the callers in common code and no backend
defines the NOFS flag.  It is intended to be set by fanotify for
evictable marks support.

Link: https://lore.kernel.org/r/20220422120327.3459282-7-amir73il@gmail.com
Suggested-by: Jan Kara <jack@suse.cz>
Link: https://lore.kernel.org/r/20220321112310.vpr7oxro2xkz5llh@quack3.lan/
Signed-off-by: Amir Goldstein <amir73il@gmail.com>
Signed-off-by: Jan Kara <jack@suse.cz>

diff --git a/fs/notify/fdinfo.c b/fs/notify/fdinfo.c
index 3451708fd035c86b662791c9033bf91659b4443e..1f34c5c29fdbd9aa7f6b62ac31fcb0913725388f 100644 (file)
--- a/fs/notify/fdinfo.c
+++ b/fs/notify/fdinfo.c
@@ -28,13 +28,13 @@ static void show_fdinfo(struct seq_file *m, struct file *f,
        struct fsnotify_group *group = f->private_data;
        struct fsnotify_mark *mark;
 
-       mutex_lock(&group->mark_mutex);
+       fsnotify_group_lock(group);
        list_for_each_entry(mark, &group->marks_list, g_list) {
                show(m, mark);
                if (seq_has_overflowed(m))
                        break;
        }
-       mutex_unlock(&group->mark_mutex);
+       fsnotify_group_unlock(group);
 }
 
 #if defined(CONFIG_EXPORTFS)

diff --git a/fs/notify/group.c b/fs/notify/group.c
index 18446b7b0d495d64af470e0b598c6f2c492939ce..1de6631a3925ee99266fe5516de5c3669c8385b3 100644 (file)
--- a/fs/notify/group.c
+++ b/fs/notify/group.c
@@ -115,6 +115,7 @@ static struct fsnotify_group *__fsnotify_alloc_group(
                                const struct fsnotify_ops *ops,
                                int flags, gfp_t gfp)
 {
+       static struct lock_class_key nofs_marks_lock;
        struct fsnotify_group *group;
 
        group = kzalloc(sizeof(struct fsnotify_group), gfp);
@@ -135,6 +136,16 @@ static struct fsnotify_group *__fsnotify_alloc_group(
 
        group->ops = ops;
        group->flags = flags;
+       /*
+        * For most backends, eviction of inode with a mark is not expected,
+        * because marks hold a refcount on the inode against eviction.
+        *
+        * Use a different lockdep class for groups that support evictable
+        * inode marks, because with evictable marks, mark_mutex is NOT
+        * fs-reclaim safe - the mutex is taken when evicting inodes.
+        */
+       if (flags & FSNOTIFY_GROUP_NOFS)
+               lockdep_set_class(&group->mark_mutex, &nofs_marks_lock);
 
        return group;
 }

diff --git a/fs/notify/mark.c b/fs/notify/mark.c
index 1fb246ea6175243ff9ef07eb2bd73a8341892553..982ca2f20ff5dba067840545f11806dabbbf9f08 100644 (file)
--- a/fs/notify/mark.c
+++ b/fs/notify/mark.c
@@ -398,9 +398,7 @@ void fsnotify_finish_user_wait(struct fsnotify_iter_info *iter_info)
  */
 void fsnotify_detach_mark(struct fsnotify_mark *mark)
 {
-       struct fsnotify_group *group = mark->group;
-
-       WARN_ON_ONCE(!mutex_is_locked(&group->mark_mutex));
+       fsnotify_group_assert_locked(mark->group);
        WARN_ON_ONCE(!srcu_read_lock_held(&fsnotify_mark_srcu) &&
                     refcount_read(&mark->refcnt) < 1 +
                        !!(mark->flags & FSNOTIFY_MARK_FLAG_ATTACHED));
@@ -452,9 +450,9 @@ void fsnotify_free_mark(struct fsnotify_mark *mark)
 void fsnotify_destroy_mark(struct fsnotify_mark *mark,
                           struct fsnotify_group *group)
 {
-       mutex_lock(&group->mark_mutex);
+       fsnotify_group_lock(group);
        fsnotify_detach_mark(mark);
-       mutex_unlock(&group->mark_mutex);
+       fsnotify_group_unlock(group);
        fsnotify_free_mark(mark);
 }
 EXPORT_SYMBOL_GPL(fsnotify_destroy_mark);
@@ -673,7 +671,7 @@ int fsnotify_add_mark_locked(struct fsnotify_mark *mark,
        struct fsnotify_group *group = mark->group;
        int ret = 0;
 
-       BUG_ON(!mutex_is_locked(&group->mark_mutex));
+       fsnotify_group_assert_locked(group);
 
        /*
         * LOCKING ORDER!!!!
@@ -714,9 +712,9 @@ int fsnotify_add_mark(struct fsnotify_mark *mark, fsnotify_connp_t *connp,
        int ret;
        struct fsnotify_group *group = mark->group;
 
-       mutex_lock(&group->mark_mutex);
+       fsnotify_group_lock(group);
        ret = fsnotify_add_mark_locked(mark, connp, obj_type, add_flags, fsid);
-       mutex_unlock(&group->mark_mutex);
+       fsnotify_group_unlock(group);
        return ret;
 }
 EXPORT_SYMBOL_GPL(fsnotify_add_mark);
@@ -770,24 +768,24 @@ void fsnotify_clear_marks_by_group(struct fsnotify_group *group,
         * move marks to free to to_free list in one go and then free marks in
         * to_free list one by one.
         */
-       mutex_lock(&group->mark_mutex);
+       fsnotify_group_lock(group);
        list_for_each_entry_safe(mark, lmark, &group->marks_list, g_list) {
                if (mark->connector->type == obj_type)
                        list_move(&mark->g_list, &to_free);
        }
-       mutex_unlock(&group->mark_mutex);
+       fsnotify_group_unlock(group);
 
 clear:
        while (1) {
-               mutex_lock(&group->mark_mutex);
+               fsnotify_group_lock(group);
                if (list_empty(head)) {
-                       mutex_unlock(&group->mark_mutex);
+                       fsnotify_group_unlock(group);
                        break;
                }
                mark = list_first_entry(head, struct fsnotify_mark, g_list);
                fsnotify_get_mark(mark);
                fsnotify_detach_mark(mark);
-               mutex_unlock(&group->mark_mutex);
+               fsnotify_group_unlock(group);
                fsnotify_free_mark(mark);
                fsnotify_put_mark(mark);
        }

diff --git a/include/linux/fsnotify_backend.h b/include/linux/fsnotify_backend.h
index dd440e6ff5285301591d703fe12376aaac46ee86..d62111e8324409ebe8528cb6837471df77f7b568 100644 (file)
--- a/include/linux/fsnotify_backend.h
+++ b/include/linux/fsnotify_backend.h
@@ -20,6 +20,7 @@
 #include <linux/user_namespace.h>
 #include <linux/refcount.h>
 #include <linux/mempool.h>
+#include <linux/sched/mm.h>
 
 /*
  * IN_* from inotfy.h lines up EXACTLY with FS_*, this is so we can easily
@@ -212,7 +213,9 @@ struct fsnotify_group {
 
 #define FSNOTIFY_GROUP_USER    0x01 /* user allocated group */
 #define FSNOTIFY_GROUP_DUPS    0x02 /* allow multiple marks per object */
+#define FSNOTIFY_GROUP_NOFS    0x04 /* group lock is not direct reclaim safe */
        int flags;
+       unsigned int owner_flags;       /* stored flags of mark_mutex owner */
 
        /* stores all fastpath marks assoc with this group so they can be cleaned on unregister */
        struct mutex mark_mutex;        /* protect marks_list */
@@ -254,6 +257,31 @@ struct fsnotify_group {
        };
 };
 
+/*
+ * These helpers are used to prevent deadlock when reclaiming inodes with
+ * evictable marks of the same group that is allocating a new mark.
+ */
+static inline void fsnotify_group_lock(struct fsnotify_group *group)
+{
+       mutex_lock(&group->mark_mutex);
+       if (group->flags & FSNOTIFY_GROUP_NOFS)
+               group->owner_flags = memalloc_nofs_save();
+}
+
+static inline void fsnotify_group_unlock(struct fsnotify_group *group)
+{
+       if (group->flags & FSNOTIFY_GROUP_NOFS)
+               memalloc_nofs_restore(group->owner_flags);
+       mutex_unlock(&group->mark_mutex);
+}
+
+static inline void fsnotify_group_assert_locked(struct fsnotify_group *group)
+{
+       WARN_ON_ONCE(!mutex_is_locked(&group->mark_mutex));
+       if (group->flags & FSNOTIFY_GROUP_NOFS)
+               WARN_ON_ONCE(!(current->flags & PF_MEMALLOC_NOFS));
+}
+
 /* When calling fsnotify tell it if the data is a path or inode */
 enum fsnotify_data_type {
        FSNOTIFY_EVENT_NONE,