fsnotify: pass flags argument to fsnotify_alloc_group()

Add flags argument to fsnotify_alloc_group(), define and use the flag
FSNOTIFY_GROUP_USER in inotify and fanotify instead of the helper
fsnotify_alloc_user_group() to indicate user allocation.

Although the flag FSNOTIFY_GROUP_USER is currently not used after group
allocation, we store the flags argument in the group struct for future
use of other group flags.

Link: https://lore.kernel.org/r/20220422120327.3459282-5-amir73il@gmail.com
Signed-off-by: Amir Goldstein <amir73il@gmail.com>
Signed-off-by: Jan Kara <jack@suse.cz>

diff --git a/fs/nfsd/filecache.c b/fs/nfsd/filecache.c
index 2c1b027..74ddb82 100644 (file)
--- a/fs/nfsd/filecache.c
+++ b/fs/nfsd/filecache.c
@@ -678,7 +678,8 @@ nfsd_file_cache_init(void)
                goto out_shrinker;
        }
 
-       nfsd_file_fsnotify_group = fsnotify_alloc_group(&nfsd_file_fsnotify_ops);
+       nfsd_file_fsnotify_group = fsnotify_alloc_group(&nfsd_file_fsnotify_ops,
+                                                       0);
        if (IS_ERR(nfsd_file_fsnotify_group)) {
                pr_err("nfsd: unable to create fsnotify group: %ld\n",
                        PTR_ERR(nfsd_file_fsnotify_group));

diff --git a/fs/notify/dnotify/dnotify.c b/fs/notify/dnotify/dnotify.c
index 829dd4a..e477992 100644 (file)
--- a/fs/notify/dnotify/dnotify.c
+++ b/fs/notify/dnotify/dnotify.c
@@ -401,7 +401,7 @@ static int __init dnotify_init(void)
                                          SLAB_PANIC|SLAB_ACCOUNT);
        dnotify_mark_cache = KMEM_CACHE(dnotify_mark, SLAB_PANIC|SLAB_ACCOUNT);
 
-       dnotify_group = fsnotify_alloc_group(&dnotify_fsnotify_ops);
+       dnotify_group = fsnotify_alloc_group(&dnotify_fsnotify_ops, 0);
        if (IS_ERR(dnotify_group))
                panic("unable to allocate fsnotify group for dnotify\n");
        dnotify_sysctl_init();

diff --git a/fs/notify/fanotify/fanotify_user.c b/fs/notify/fanotify/fanotify_user.c
index 9b32b76..3649c99 100644 (file)
--- a/fs/notify/fanotify/fanotify_user.c
+++ b/fs/notify/fanotify/fanotify_user.c
@@ -1355,7 +1355,8 @@ SYSCALL_DEFINE2(fanotify_init, unsigned int, flags, unsigned int, event_f_flags)
                f_flags |= O_NONBLOCK;
 
        /* fsnotify_alloc_group takes a ref.  Dropped in fanotify_release */
-       group = fsnotify_alloc_user_group(&fanotify_fsnotify_ops);
+       group = fsnotify_alloc_group(&fanotify_fsnotify_ops,
+                                    FSNOTIFY_GROUP_USER);
        if (IS_ERR(group)) {
                return PTR_ERR(group);
        }

diff --git a/fs/notify/group.c b/fs/notify/group.c
index b7d4d64..18446b7 100644 (file)
--- a/fs/notify/group.c
+++ b/fs/notify/group.c
@@ -112,7 +112,8 @@ void fsnotify_put_group(struct fsnotify_group *group)
 EXPORT_SYMBOL_GPL(fsnotify_put_group);
 
 static struct fsnotify_group *__fsnotify_alloc_group(
-                               const struct fsnotify_ops *ops, gfp_t gfp)
+                               const struct fsnotify_ops *ops,
+                               int flags, gfp_t gfp)
 {
        struct fsnotify_group *group;
 
@@ -133,6 +134,7 @@ static struct fsnotify_group *__fsnotify_alloc_group(
        INIT_LIST_HEAD(&group->marks_list);
 
        group->ops = ops;
+       group->flags = flags;
 
        return group;
 }
@@ -140,20 +142,15 @@ static struct fsnotify_group *__fsnotify_alloc_group(
 /*
  * Create a new fsnotify_group and hold a reference for the group returned.
  */
-struct fsnotify_group *fsnotify_alloc_group(const struct fsnotify_ops *ops)
+struct fsnotify_group *fsnotify_alloc_group(const struct fsnotify_ops *ops,
+                                           int flags)
 {
-       return __fsnotify_alloc_group(ops, GFP_KERNEL);
-}
-EXPORT_SYMBOL_GPL(fsnotify_alloc_group);
+       gfp_t gfp = (flags & FSNOTIFY_GROUP_USER) ? GFP_KERNEL_ACCOUNT :
+                                                   GFP_KERNEL;
 
-/*
- * Create a new fsnotify_group and hold a reference for the group returned.
- */
-struct fsnotify_group *fsnotify_alloc_user_group(const struct fsnotify_ops *ops)
-{
-       return __fsnotify_alloc_group(ops, GFP_KERNEL_ACCOUNT);
+       return __fsnotify_alloc_group(ops, flags, gfp);
 }
-EXPORT_SYMBOL_GPL(fsnotify_alloc_user_group);
+EXPORT_SYMBOL_GPL(fsnotify_alloc_group);
 
 int fsnotify_fasync(int fd, struct file *file, int on)
 {

diff --git a/fs/notify/inotify/inotify_user.c b/fs/notify/inotify/inotify_user.c
index d8907d3..146890e 100644 (file)
--- a/fs/notify/inotify/inotify_user.c
+++ b/fs/notify/inotify/inotify_user.c
@@ -656,7 +656,8 @@ static struct fsnotify_group *inotify_new_group(unsigned int max_events)
        struct fsnotify_group *group;
        struct inotify_event_info *oevent;
 
-       group = fsnotify_alloc_user_group(&inotify_fsnotify_ops);
+       group = fsnotify_alloc_group(&inotify_fsnotify_ops,
+                                    FSNOTIFY_GROUP_USER);
        if (IS_ERR(group))
                return group;
 

diff --git a/include/linux/fsnotify_backend.h b/include/linux/fsnotify_backend.h
index b1c72ed..f0bf557 100644 (file)
--- a/include/linux/fsnotify_backend.h
+++ b/include/linux/fsnotify_backend.h
@@ -210,6 +210,9 @@ struct fsnotify_group {
        unsigned int priority;
        bool shutdown;          /* group is being shut down, don't queue more events */
 
+#define FSNOTIFY_GROUP_USER    0x01 /* user allocated group */
+       int flags;
+
        /* stores all fastpath marks assoc with this group so they can be cleaned on unregister */
        struct mutex mark_mutex;        /* protect marks_list */
        atomic_t user_waits;            /* Number of tasks waiting for user
@@ -543,8 +546,9 @@ static inline void fsnotify_update_flags(struct dentry *dentry)
 /* called from fsnotify listeners, such as fanotify or dnotify */
 
 /* create a new group */
-extern struct fsnotify_group *fsnotify_alloc_group(const struct fsnotify_ops *ops);
-extern struct fsnotify_group *fsnotify_alloc_user_group(const struct fsnotify_ops *ops);
+extern struct fsnotify_group *fsnotify_alloc_group(
+                               const struct fsnotify_ops *ops,
+                               int flags);
 /* get reference to a group */
 extern void fsnotify_get_group(struct fsnotify_group *group);
 /* drop reference on a group from fsnotify_alloc_group */

diff --git a/kernel/audit_fsnotify.c b/kernel/audit_fsnotify.c
index 02348b4..35fe149 100644 (file)
--- a/kernel/audit_fsnotify.c
+++ b/kernel/audit_fsnotify.c
@@ -181,7 +181,8 @@ static const struct fsnotify_ops audit_mark_fsnotify_ops = {
 
 static int __init audit_fsnotify_init(void)
 {
-       audit_fsnotify_group = fsnotify_alloc_group(&audit_mark_fsnotify_ops);
+       audit_fsnotify_group = fsnotify_alloc_group(&audit_mark_fsnotify_ops,
+                                                   0);
        if (IS_ERR(audit_fsnotify_group)) {
                audit_fsnotify_group = NULL;
                audit_panic("cannot create audit fsnotify group");

diff --git a/kernel/audit_tree.c b/kernel/audit_tree.c
index e7315d4..b5c02f8 100644 (file)
--- a/kernel/audit_tree.c
+++ b/kernel/audit_tree.c
@@ -1074,7 +1074,7 @@ static int __init audit_tree_init(void)
 
        audit_tree_mark_cachep = KMEM_CACHE(audit_tree_mark, SLAB_PANIC);
 
-       audit_tree_group = fsnotify_alloc_group(&audit_tree_ops);
+       audit_tree_group = fsnotify_alloc_group(&audit_tree_ops, 0);
        if (IS_ERR(audit_tree_group))
                audit_panic("cannot initialize fsnotify group for rectree watches");
 

diff --git a/kernel/audit_watch.c b/kernel/audit_watch.c
index 713b256..4b0957a 100644 (file)
--- a/kernel/audit_watch.c
+++ b/kernel/audit_watch.c
@@ -493,7 +493,7 @@ static const struct fsnotify_ops audit_watch_fsnotify_ops = {
 
 static int __init audit_watch_init(void)
 {
-       audit_watch_group = fsnotify_alloc_group(&audit_watch_fsnotify_ops);
+       audit_watch_group = fsnotify_alloc_group(&audit_watch_fsnotify_ops, 0);
        if (IS_ERR(audit_watch_group)) {
                audit_watch_group = NULL;
                audit_panic("cannot create audit fsnotify group");