fsnotify: Do not share events between notification groups
Subsystems (6)
Jan Kara
maintainerv2 cover fsnotify: Do not share events between notification groups
Hello,
this is the second version of my patchset to change fsnotify framework
so that events are not shared between different notification groups - it significantly simplifies the code, saves some memory in common cases, and fixes a problem with outstanding inotify events unnecessarily preventing umount (see patch 2/3 for more details).
Since v1, I have fixed a couple of bugs found during testing (I have added a decent coverage of fanotify syscalls into LTP) and separated at least two logically unrelated changes into separate patches. Still the main patch is rather huge but I don't know how to make it any smaller given we change how the core data structure works...
Honza
Jan Kara
maintainerPATCH v2 1/3 inotify: Provide function for name length rounding
Rounding of name length when passing it to userspace was done in several places. Provide a function to do it and use it in all places.
--- fs/notify/inotify/inotify_user.c | 41 ++++++++++++++++++++-------------------- 1 file changed, 21 insertions(+), 20 deletions(-)
fs/notify/inotify/inotify_user.c +21 -20
@@ -124,6 +124,13 @@ static unsigned int inotify_poll(struct file *file, poll_table *wait)return ret; } +static int round_event_name_len (struct fsnotify_event *event) +{ +if (!event->name_len) +return 0 ; +return roundup (event->name_len +1 ,sizeof (struct inotify_event )); +} +/* * Get an inotify_kernel_event if one exists and is small * enough to fit in "count". Return an error pointer if
@@ -144,9 +151,7 @@ static struct fsnotify_event *get_one_event(struct fsnotify_group *group,pr_debug ("%s: group=%p event=%p\n" , __func__, group, event); -if (event->name_len) - event_size +=roundup (event->name_len +1 , event_size); - + event_size +=round_event_name_len (event);if (event_size > count)return ERR_PTR (-EINVAL );
@@ -171,7 +176,8 @@ static ssize_t copy_event_to_user(struct fsnotify_group *group,struct fsnotify_event_private_data *fsn_priv;struct inotify_event_private_data *priv;size_t event_size =sizeof (struct inotify_event ); -size_t name_len =0 ; +size_t name_len; +size_t pad_name_len;pr_debug ("%s: group=%p event=%p\n" , __func__, group, event);
@@ -189,14 +195,13 @@ static ssize_t copy_event_to_user(struct fsnotify_group *group,inotify_free_event_priv (fsn_priv); } + name_len = event->name_len;/* -* round up event->name_len so it is a multiple of event_size +* round up name length so it is a multiple of event_size * plus an extra byte for the terminating '\0'. */ -if (event->name_len) - name_len =roundup (event->name_len +1 , event_size); - inotify_event.len = name_len; - + pad_name_len =round_event_name_len (event); + inotify_event.len = pad_name_len; inotify_event.mask =inotify_mask_to_arg (event->mask); inotify_event.cookie = event->sync_cookie;
@@ -209,20 +214,18 @@ static ssize_t copy_event_to_user(struct fsnotify_group *group,/* * fsnotify only stores the pathname, so here we have to send the pathname * and then pad that pathname out to a multiple of sizeof(inotify_event) -* with zeros. I get my zeros from the nul_inotify_event. +* with zeros. */ -if (name_len) { -unsigned int len_to_zero = name_len - event->name_len; +if (pad_name_len) {/* copy the path name */ -if (copy_to_user (buf, event->file_name, event->name_len)) +if (copy_to_user (buf, event->file_name, name_len))return -EFAULT ; - buf += event->name_len; + buf += name_len;/* fill userspace with 0's */ -if (clear_user (buf, len_to_zero)) +if (clear_user (buf, pad_name_len - name_len))return -EFAULT ; - buf += len_to_zero; - event_size += name_len; + event_size += pad_name_len; }return event_size;
@@ -314,9 +317,7 @@ static long inotify_ioctl(struct file *file, unsigned int cmd,list_for_each_entry (holder, &group->notification_list, event_list) { event = holder->event; send_len +=sizeof (struct inotify_event ); -if (event->name_len) - send_len +=roundup (event->name_len +1 , -sizeof (struct inotify_event )); + send_len +=round_event_name_len (event); }mutex_unlock (&group->notification_mutex); ret =put_user (send_len, (int __user *) p);
Signature · 1 line
1.8.1.4
Jan Kara
maintainerRe: [PATCH 1/3] inotify: Provide function for name length rounding
Quoted 4 lines · Jan Kara
Rounding of name length when passing it to userspace was done in several places. Provide a function to do it and use it in all places.
Signed-off-by Jan Kara <[email protected]>
Ping? Any opinion on this patchset?
Honza
Quoted 103 lines
--- fs/notify/inotify/inotify_user.c | 41 ++++++++++++++++++++-------------------- 1 file changed, 21 insertions(+), 20 deletions(-)fs/notify/inotify/inotify_user.c +21
-20@@ -124,6 +124,13 @@ static unsigned int inotify_poll(struct file *file, poll_table *wait)return ret; } +static int round_event_name_len (struct fsnotify_event *event) +{ +if (!event->name_len) +return 0 ; +return roundup (event->name_len +1 ,sizeof (struct inotify_event )); +} +/* * Get an inotify_kernel_event if one exists and is small * enough to fit in "count". Return an error pointer if @@ -144,9 +151,7 @@ static struct fsnotify_event *get_one_event(struct fsnotify_group *group,pr_debug ("%s: group=%p event=%p\n" , __func__, group, event); -if (event->name_len) - event_size +=roundup (event->name_len +1 , event_size); - + event_size +=round_event_name_len (event);if (event_size > count)return ERR_PTR (-EINVAL );@@ -171,7 +176,8 @@ static ssize_t copy_event_to_user(struct fsnotify_group *group,struct fsnotify_event_private_data *fsn_priv;struct inotify_event_private_data *priv;size_t event_size =sizeof (struct inotify_event ); -size_t name_len =0 ; +size_t name_len; +size_t pad_name_len;pr_debug ("%s: group=%p event=%p\n" , __func__, group, event);@@ -189,14 +195,13 @@ static ssize_t copy_event_to_user(struct fsnotify_group *group,inotify_free_event_priv (fsn_priv); } + name_len = event->name_len;/* -* round up event->name_len so it is a multiple of event_size +* round up name length so it is a multiple of event_size * plus an extra byte for the terminating '\0'. */ -if (event->name_len) - name_len =roundup (event->name_len +1 , event_size); - inotify_event.len = name_len; - + pad_name_len =round_event_name_len (event); + inotify_event.len = pad_name_len; inotify_event.mask =inotify_mask_to_arg (event->mask); inotify_event.cookie = event->sync_cookie;@@ -209,20 +214,18 @@ static ssize_t copy_event_to_user(struct fsnotify_group *group,/* * fsnotify only stores the pathname, so here we have to send the pathname * and then pad that pathname out to a multiple of sizeof(inotify_event) -* with zeros. I get my zeros from the nul_inotify_event. +* with zeros. */ -if (name_len) { -unsigned int len_to_zero = name_len - event->name_len; +if (pad_name_len) {/* copy the path name */ -if (copy_to_user (buf, event->file_name, event->name_len)) +if (copy_to_user (buf, event->file_name, name_len))return -EFAULT ; - buf += event->name_len; + buf += name_len;/* fill userspace with 0's */ -if (clear_user (buf, len_to_zero)) +if (clear_user (buf, pad_name_len - name_len))return -EFAULT ; - buf += len_to_zero; - event_size += name_len; + event_size += pad_name_len; }return event_size;@@ -314,9 +317,7 @@ static long inotify_ioctl(struct file *file, unsigned int cmd,list_for_each_entry (holder, &group->notification_list, event_list) { event = holder->event; send_len +=sizeof (struct inotify_event ); -if (event->name_len) - send_len +=roundup (event->name_len +1 , -sizeof (struct inotify_event )); + send_len +=round_event_name_len (event); }mutex_unlock (&group->notification_mutex); ret =put_user (send_len, (int __user *) p);Signature · 1 line
1.8.1.4
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Re: [PATCH 1/3] inotify: Provide function for name length rounding
In reply to Jan KaraQuoted 4 lines · Jan Kara
Rounding of name length when passing it to userspace was done in several places. Provide a function to do it and use it in all places.
Signed-off-by Jan Kara <[email protected]>
Looks good,
BTw, I hadn't noticed kernel.h has a roundup() in addition to round_up(). And XFS also has roundup64 which isn't needed as far as I can see.. None of them are documented in the slightest way either, ugh..
Jan Kara
maintainerRe: [PATCH 1/3] inotify: Provide function for name length rounding
Quoted 9 lines · Christoph Hellwig
Quoted 4 lines · Jan Kara
Rounding of name length when passing it to userspace was done in several places. Provide a function to do it and use it in all places.
Signed-off-by Jan Kara <[email protected]>Looks good,
Reviewed-by Christoph Hellwig <[email protected]>
Thanks!
Quoted 4 lines
BTw, I hadn't noticed
kernel.hhas aroundup()in addition toround_up(). And XFS also has roundup64 which isn't needed as far as I can see.. None of them are documented in the slightest way either, ugh..
Yeah... There should be a note somewhere that round_up() works only for
y being a power of 2.
Honza
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Jan Kara
maintainerPATCH v2 2/3 fsnotify: Do not share events between notification groups
In reply to Jan KaraCurrently fsnotify framework creates one event structure for each notification event and links this event into all interested notification groups. This is done so that we save memory when several notification groups are interested in the event. However the need for event structure shared between inotify & fanotify bloats the event structure so the result is often higher memory consumption.
Another problem is that fsnotify framework keeps path references with outstanding events so that fanotify can return open file descriptors with its events. This has the undesirable effect that filesystem cannot be unmounted while there are outstanding events - a regression for inotify compared to a situation before it was converted to fsnotify framework. For fanotify this problem is hard to avoid and users of fanotify should kind of expect this behavior when they ask for file descriptors from notified files.
This patch changes fsnotify and its users to create separate event structure for each group. This allows for much simpler code (~450 lines removed by this patch) and also smaller event structures. For example on 64-bit system original struct fsnotify_event consumes 120 bytes, plus additional space for file name, additional 24 bytes for second and each subsequent group linking the event, and additional 32 bytes for each inotify group for private data. After the conversion inotify event consumes 48 bytes plus space for file name which is considerably less memory unless file names are long and there are several groups interested in the events (both of which are uncommon). Fanotify event fits in 56 bytes after the conversion (fanotify doesn't care about file names so its events don't have to have it allocated). A win unless there are four or more fanotify groups interested in the event.
The conversion also solves the problem with unmount when only inotify is used as we don't have to grab path references for inotify events.
--- fs/notify/dnotify/dnotify.c | 11 +- fs/notify/fanotify/fanotify.c | 200 ++++++++++----------- fs/notify/fanotify/fanotify.h | 23 +++ fs/notify/fanotify/fanotify_user.c | 41 +++-- fs/notify/fsnotify.c | 37 ++-- fs/notify/group.c | 1 + fs/notify/inotify/inotify.h | 21 ++- fs/notify/inotify/inotify_fsnotify.c | 125 ++++++------- fs/notify/inotify/inotify_user.c | 86 +++------ fs/notify/notification.c | 330 +++-------------------------------- include/linux/fsnotify_backend.h | 114 +++--------- kernel/audit_tree.c | 8 +- kernel/audit_watch.c | 14 +- 13 files changed, 309 insertions(+), 702 deletions(-) create mode 100644 fs/notify/fanotify/fanotify.h
fs/notify/dnotify/dnotify.c +5 -6
@@ -82,21 +82,20 @@ static void dnotify_recalc_inode_mask(struct fsnotify_mark *fsn_mark)* events. */ static int dnotify_handle_event (struct fsnotify_group *group, +struct inode *to_tell,struct fsnotify_mark *inode_mark,struct fsnotify_mark *vfsmount_mark, -struct fsnotify_event *event) +u32 mask,void *data,int data_type, +const unsigned char *file_name) {struct dnotify_mark *dn_mark; -struct inode *to_tell;struct dnotify_struct *dn;struct dnotify_struct **prev;struct fown_struct *fown; -__u32 test_mask = event->mask & ~FS_EVENT_ON_CHILD ; +__u32 test_mask = mask & ~FS_EVENT_ON_CHILD ;BUG_ON (vfsmount_mark); - to_tell = event->to_tell; - dn_mark = container_of(inode_mark, struct dnotify_mark, fsn_mark);spin_lock (&inode_mark->lock);
@@ -155,7 +154,7 @@ static struct fsnotify_ops dnotify_fsnotify_ops = { .should_send_event = dnotify_should_send_event, .free_group_priv = NULL, .freeing_mark = NULL, - .free_event_priv = NULL, + .free_event = NULL, };/*
fs/notify/fanotify/fanotify.c +97 -103
263 lines not on this page · raw message
fs/notify/fanotify/fanotify.h new file +23 -0
@@ -0,0 +1,23 @@ +#include <linux/fsnotify_backend.h> +#include <linux/path.h> +#include <linux/slab.h> + +extern struct kmem_cache *fanotify_event_cachep; + +struct fanotify_event_info { +struct fsnotify_event fse; +/* +* We hold ref to this path so it may be dereferenced at any point +* during this object's lifetime +*/ +struct path path; +struct pid *tgid; +#ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS +u32 response;/* userspace answer to question */ +#endif +}; + +static inline struct fanotify_event_info *FANOTIFY_E (struct fsnotify_event *fse) +{ + return container_of(fse, struct fanotify_event_info, fse); +}
fs/notify/fanotify/fanotify_user.c +20 -21
128 lines not on this page · raw message
fs/notify/fsnotify.c +12 -25
@@ -128,8 +128,7 @@ static int send_to_group(struct inode *to_tell,struct fsnotify_mark *vfsmount_mark, __u32 mask, void *data, int data_is, u32 cookie, - const unsigned char *file_name, - struct fsnotify_event **event) + const unsigned char *file_name) { struct fsnotify_group *group = NULL;__u32 inode_test_mask =0 ;
@@ -170,10 +169,10 @@ static int send_to_group(struct inode *to_tell,pr_debug ("%s: group=%p to_tell=%p mask=%x inode_mark=%p" " inode_test_mask=%x vfsmount_mark=%p vfsmount_test_mask=%x" -" data=%p data_is=%d cookie=%d event=%p\n" , +" data=%p data_is=%d cookie=%d\n" , __func__, group, to_tell, mask, inode_mark, inode_test_mask, vfsmount_mark, vfsmount_test_mask, data, - data_is, cookie, *event); + data_is, cookie);if (!inode_test_mask && !vfsmount_test_mask)return 0 ;
@@ -183,14 +182,9 @@ static int send_to_group(struct inode *to_tell, data_is) == false)return 0 ; -if (!*event) { - *event =fsnotify_create_event (to_tell, mask, data, - data_is, file_name, - cookie,GFP_KERNEL ); -if (!*event) -return -ENOMEM ; - } -return group->ops->handle_event (group, inode_mark, vfsmount_mark, *event); +return group->ops->handle_event (group, to_tell, inode_mark, + vfsmount_mark, mask, data, data_is, + file_name); }/*
@@ -205,7 +199,6 @@ int fsnotify(struct inode *to_tell, __u32 mask, void *data, int data_is,struct hlist_node *inode_node =NULL , *vfsmount_node =NULL ;struct fsnotify_mark *inode_mark =NULL , *vfsmount_mark =NULL ;struct fsnotify_group *inode_group, *vfsmount_group; -struct fsnotify_event *event =NULL ;struct mount *mnt;int idx, ret =0 ;/* global tests shouldn't care about events on child only the specific event */
@@ -258,18 +251,18 @@ int fsnotify(struct inode *to_tell, __u32 mask, void *data, int data_is,if (inode_group > vfsmount_group) {/* handle inode */ - ret =send_to_group (to_tell, inode_mark,NULL , mask, data, - data_is, cookie, file_name, &event); + ret =send_to_group (to_tell, inode_mark,NULL , mask, + data, data_is, cookie, file_name);/* we didn't use the vfsmount_mark */ vfsmount_group =NULL ; }else if (vfsmount_group > inode_group) { - ret =send_to_group (to_tell,NULL , vfsmount_mark, mask, data, - data_is, cookie, file_name, &event); + ret =send_to_group (to_tell,NULL , vfsmount_mark, mask, + data, data_is, cookie, file_name); inode_group =NULL ; }else { ret =send_to_group (to_tell, inode_mark, vfsmount_mark, - mask, data, data_is, cookie, file_name, - &event); + mask, data, data_is, cookie, + file_name); }if (ret && (mask &ALL_FSNOTIFY_PERM_EVENTS ))
@@ -285,12 +278,6 @@ int fsnotify(struct inode *to_tell, __u32 mask, void *data, int data_is, ret =0 ; out:srcu_read_unlock (&fsnotify_mark_srcu, idx); -/* -* fsnotify_create_event() took a reference so the event can't be cleaned -* up while we are still trying to add it to lists, drop that one. -*/ -if (event) -fsnotify_put_event (event);return ret; }
fs/notify/group.c +1 -0
@@ -99,6 +99,7 @@ struct fsnotify_group *fsnotify_alloc_group(const struct fsnotify_ops *ops)INIT_LIST_HEAD (&group->marks_list); group->ops = ops; +fsnotify_init_event (&group->overflow_event,NULL ,FS_Q_OVERFLOW );return group; }
fs/notify/inotify/inotify.h +16 -5
@@ -2,11 +2,12 @@#include <linux/inotify.h> #include <linux/slab.h> /* struct kmem_cache */ -extern struct kmem_cache *event_priv_cachep; - -struct inotify_event_private_data { -struct fsnotify_event_private_data fsnotify_event_priv_data; +struct inotify_event_info { +struct fsnotify_event fse;int wd; +u32 sync_cookie; +int name_len; +char name[]; };struct inotify_inode_mark {
@@ -14,8 +15,18 @@ struct inotify_inode_mark {int wd; }; +static inline struct inotify_event_info *INOTIFY_E (struct fsnotify_event *fse) +{ + return container_of(fse, struct inotify_event_info, fse); +} +extern void inotify_ignored_and_remove_idr (struct fsnotify_mark *fsn_mark,struct fsnotify_group *group); -extern void inotify_free_event_priv (struct fsnotify_event_private_data *event_priv); +extern int inotify_handle_event (struct fsnotify_group *group, +struct inode *to_tell, +struct fsnotify_mark *inode_mark, +struct fsnotify_mark *vfsmount_mark, +u32 mask,void *data,int data_type, +const unsigned char *file_name);extern const struct fsnotify_ops inotify_fsnotify_ops;
fs/notify/inotify/inotify_fsnotify.c +49 -76
171 lines not on this page · raw message
fs/notify/inotify/inotify_user.c +21 -65
158 lines not on this page · raw message
fs/notify/notification.c +26 -304
414 lines not on this page · raw message
include/linux/fsnotify_backend.h +27 -87
167 lines not on this page · raw message
kernel/audit_tree.c +5 -3
@@ -912,9 +912,11 @@ static void evict_chunk(struct audit_chunk *chunk) }static int audit_tree_handle_event (struct fsnotify_group *group, +struct inode *to_tell,struct fsnotify_mark *inode_mark, -struct fsnotify_mark *vfsmonut_mark, -struct fsnotify_event *event) +struct fsnotify_mark *vfsmount_mark, +u32 mask,void *data,int data_type, +const unsigned char *file_name) {BUG ();return -EOPNOTSUPP ;
@@ -945,7 +947,7 @@ static const struct fsnotify_ops audit_tree_ops = { .handle_event = audit_tree_handle_event, .should_send_event = audit_tree_send_event, .free_group_priv = NULL, - .free_event_priv = NULL, + .free_event = NULL, .freeing_mark = audit_tree_freeing_mark, };
kernel/audit_watch.c +7 -7
@@ -475,25 +475,25 @@ static bool audit_watch_should_send_event(struct fsnotify_group *group, struct i/* Update watch data in audit rules based on fsnotify events. */ static int audit_watch_handle_event (struct fsnotify_group *group, +struct inode *to_tell,struct fsnotify_mark *inode_mark,struct fsnotify_mark *vfsmount_mark, -struct fsnotify_event *event) +u32 mask,void *data,int data_type, +const unsigned char *dname) {struct inode *inode; -__u32 mask = event->mask; -const char *dname = event->file_name;struct audit_parent *parent; parent = container_of(inode_mark, struct audit_parent, mark);BUG_ON (group != audit_watch_group); -switch (event->data_type) { +switch (data_type) {case (FSNOTIFY_EVENT_PATH ): - inode = event->path.dentry->d_inode; + inode = ((struct path *)data)->dentry->d_inode;break ;case (FSNOTIFY_EVENT_INODE ): - inode = event->inode; + inode = (struct inode *)data;break ;default :BUG ();
@@ -516,7 +516,7 @@ static const struct fsnotify_ops audit_watch_fsnotify_ops = { .handle_event = audit_watch_handle_event, .free_group_priv = NULL, .freeing_mark = NULL, - .free_event_priv = NULL, + .free_event = NULL, };static int __init audit_watch_init (void )
Signature · 1 line
1.8.1.4
Review
Quoted 2 lines
static int dnotify_handle_event(struct
fsnotify_group*group,(quoted diff) +1
-0+ struct inode *to_tell,
Can we just call this variable inode? :)
fs/notify/dnotify/dnotify.c static struct fsnotify_ops dnotify_fsnotify_ops = { · line 158
Quoted 7 lines
fs/notify/dnotify/dnotify.c +1
-1@@ -155,7 +154,7 @@ static struct fsnotify_ops dnotify_fsnotify_ops = { .should_send_event = dnotify_should_send_event, .free_group_priv = NULL, .freeing_mark = NULL, - .free_event_priv = NULL, + .free_event = NULL, };
Please also drop all thee pointless NULL method initializations.
include/linux/fsnotify_backend.h struct fsnotify_ops { · line 120
Quoted 4 lines
include/linux/fsnotify_backend.h +4
-0+struct fsnotify_event { +struct list_head list; +/* to_tell may ONLY be dereferenced during handle_event(). */ +struct inode *to_tell;/* either the inode the event happened to or its parent */
Again, I'd just call this member inode.
Looks good except for the minor nitpicks,
Jan Kara
maintainerQuoted 4 lines · Christoph Hellwig
Review
Quoted 2 lines
static int dnotify_handle_event(struct
fsnotify_group*group,(quoted diff) +1
-0+ struct inode *to_tell,Can we just call this variable inode? :)
OK, done.
Quoted 9 lines
fs/notify/dnotify/dnotify.c static struct fsnotify_ops dnotify_fsnotify_ops = { · line 158
Quoted 7 lines
fs/notify/dnotify/dnotify.c +1
-1@@ -155,7 +154,7 @@ static struct fsnotify_ops dnotify_fsnotify_ops = { .should_send_event = dnotify_should_send_event, .free_group_priv = NULL, .freeing_mark = NULL, - .free_event_priv = NULL, + .free_event = NULL, };Please also drop all thee pointless NULL method initializations.
OK, I did this for all notification users as a separate patch.
Quoted 10 lines
include/linux/fsnotify_backend.h struct fsnotify_ops { · line 120
Quoted 4 lines
include/linux/fsnotify_backend.h +4
-0+struct fsnotify_event { +struct list_head list; +/* to_tell may ONLY be dereferenced during handle_event(). */ +struct inode *to_tell;/* either the inode the event happened to or its parent */ Again, I'd just call this member inode.
Looks good except for the minor nitpicks,
Reviewed-by Christoph Hellwig <[email protected]>
Honza
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Jan Kara
maintainerPATCH v2 3/3 fsnotify: Remove .should_send_event callback
In reply to Jan KaraAfter removing event structure creation from the generic layer there is no reason for separate .should_send_event and .handle_event callbacks. So just remove the first one.
--- fs/notify/dnotify/dnotify.c | 22 ++++------------------ fs/notify/fanotify/fanotify.c | 18 ++++++++++-------- fs/notify/fsnotify.c | 5 ----- fs/notify/inotify/inotify_fsnotify.c | 24 +++++++----------------- include/linux/fsnotify_backend.h | 4 ---- kernel/audit_tree.c | 12 +----------- kernel/audit_watch.c | 9 --------- 7 files changed, 22 insertions(+), 72 deletions(-)
fs/notify/dnotify/dnotify.c +4 -18
@@ -94,6 +94,10 @@ static int dnotify_handle_event(struct fsnotify_group *group,struct fown_struct *fown;__u32 test_mask = mask & ~FS_EVENT_ON_CHILD ; +/* not a dir, dnotify doesn't care */ +if (!S_ISDIR (to_tell->i_mode)) +return 0 ; +BUG_ON (vfsmount_mark); dn_mark = container_of(inode_mark, struct dnotify_mark, fsn_mark);
@@ -121,23 +125,6 @@ static int dnotify_handle_event(struct fsnotify_group *group,return 0 ; } -/* -* Given an inode and mask determine if dnotify would be interested in sending -* userspace notification for that pair. -*/ -static bool dnotify_should_send_event (struct fsnotify_group *group, -struct inode *inode, -struct fsnotify_mark *inode_mark, -struct fsnotify_mark *vfsmount_mark, -__u32 mask,void *data,int data_type) -{ -/* not a dir, dnotify doesn't care */ -if (!S_ISDIR (inode->i_mode)) -return false; - -return true; -} -static void dnotify_free_mark (struct fsnotify_mark *fsn_mark) { struct dnotify_mark *dn_mark = container_of(fsn_mark,
@@ -151,7 +138,6 @@ static void dnotify_free_mark(struct fsnotify_mark *fsn_mark)static struct fsnotify_ops dnotify_fsnotify_ops = { .handle_event = dnotify_handle_event, - .should_send_event = dnotify_should_send_event, .free_group_priv =NULL , .freeing_mark =NULL , .free_event =NULL ,
fs/notify/fanotify/fanotify.c +10 -8
@@ -85,18 +85,17 @@ static int fanotify_get_response_from_access(struct fsnotify_group *group, }#endif -static bool fanotify_should_send_event (struct fsnotify_group *group, -struct inode *to_tell, -struct fsnotify_mark *inode_mark, +static bool fanotify_should_send_event (struct fsnotify_mark *inode_mark,struct fsnotify_mark *vfsmnt_mark, -__u32 event_mask,void *data,int data_type) +u32 event_mask, +void *data,int data_type) {__u32 marks_mask, marks_ignored_mask;struct path *path = data; -pr_debug ("%s: group=%p to_tell=%p inode_mark=%p vfsmnt_mark=%p " -"mask=%x data=%p data_type=%d\n" , __func__, group, to_tell, - inode_mark, vfsmnt_mark, event_mask, data, data_type); +pr_debug ("%s: inode_mark=%p vfsmnt_mark=%p mask=%x data=%p" +" data_type=%d\n" , __func__, inode_mark, vfsmnt_mark, + event_mask, data, data_type);/* if we don't have enough info to send an event to userspace say no */ if (data_type !=FSNOTIFY_EVENT_PATH )
@@ -160,6 +159,10 @@ static int fanotify_handle_event(struct fsnotify_group *group,BUILD_BUG_ON (FAN_ACCESS_PERM !=FS_ACCESS_PERM );BUILD_BUG_ON (FAN_ONDIR !=FS_ISDIR ); +if (!fanotify_should_send_event (inode_mark, fanotify_mark, mask, data, + data_type)) +return 0 ; +pr_debug ("%s: group=%p to_tell=%p mask=%x\n" , __func__, group, to_tell, mask);
@@ -222,7 +225,6 @@ static void fanotify_free_event(struct fsnotify_event *fsn_event)const struct fsnotify_ops fanotify_fsnotify_ops = { .handle_event = fanotify_handle_event, - .should_send_event = fanotify_should_send_event, .free_group_priv = fanotify_free_group_priv, .free_event = fanotify_free_event, .freeing_mark =NULL ,
fs/notify/fsnotify.c +0 -5
@@ -177,11 +177,6 @@ static int send_to_group(struct inode *to_tell,if (!inode_test_mask && !vfsmount_test_mask)return 0 ; -if (group->ops->should_send_event (group, to_tell, inode_mark, - vfsmount_mark, mask, data, - data_is) == false) -return 0 ; -return group->ops->handle_event (group, to_tell, inode_mark, vfsmount_mark, mask, data, data_is, file_name);
fs/notify/inotify/inotify_fsnotify.c +7 -17
@@ -81,6 +81,13 @@ int inotify_handle_event(struct fsnotify_group *group,BUG_ON (vfsmount_mark); +if ((inode_mark->mask &FS_EXCL_UNLINK ) && + (data_type ==FSNOTIFY_EVENT_PATH )) { +struct path *path = data; + +if (d_unlinked (path->dentry)) +return 0 ; + }if (file_name) { len =strlen (file_name); alloc_len += len +1 ;
@@ -122,22 +129,6 @@ static void inotify_freeing_mark(struct fsnotify_mark *fsn_mark, struct fsnotifyinotify_ignored_and_remove_idr (fsn_mark, group); } -static bool inotify_should_send_event (struct fsnotify_group *group,struct inode *inode, -struct fsnotify_mark *inode_mark, -struct fsnotify_mark *vfsmount_mark, -__u32 mask,void *data,int data_type) -{ -if ((inode_mark->mask &FS_EXCL_UNLINK ) && - (data_type ==FSNOTIFY_EVENT_PATH )) { -struct path *path = data; - -if (d_unlinked (path->dentry)) -return false; - } - -return true; -} -/* * This is NEVER supposed to be called. Inotify marks should either have been * removed from the idr when the watch was removed or in the
@@ -189,7 +180,6 @@ static void inotify_free_event(struct fsnotify_event *fsn_event)const struct fsnotify_ops inotify_fsnotify_ops = { .handle_event = inotify_handle_event, - .should_send_event = inotify_should_send_event, .free_group_priv = inotify_free_group_priv, .free_event = inotify_free_event, .freeing_mark = inotify_freeing_mark,
include/linux/fsnotify_backend.h +0 -4
@@ -94,10 +94,6 @@ struct fsnotify_fname;* userspace messages that marks have been removed. */ struct fsnotify_ops { -bool (*should_send_event)(struct fsnotify_group *group,struct inode *inode, -struct fsnotify_mark *inode_mark, -struct fsnotify_mark *vfsmount_mark, -__u32 mask,void *data,int data_type); int (*handle_event)(struct fsnotify_group *group, struct inode *to_tell, struct fsnotify_mark *inode_mark,
kernel/audit_tree.c +1 -11
@@ -918,8 +918,7 @@ static int audit_tree_handle_event(struct fsnotify_group *group, u32 mask, void *data, int data_type, const unsigned char *file_name) { -BUG (); -return -EOPNOTSUPP ; + return 0; }static void audit_tree_freeing_mark (struct fsnotify_mark *entry,struct fsnotify_group *group)
@@ -935,17 +934,8 @@ static void audit_tree_freeing_mark(struct fsnotify_mark *entry, struct fsnotifyBUG_ON (atomic_read (&entry->refcnt) <1 ); } -static bool audit_tree_send_event (struct fsnotify_group *group,struct inode *inode, -struct fsnotify_mark *inode_mark, -struct fsnotify_mark *vfsmount_mark, -__u32 mask,void *data,int data_type) -{ -return false; -} -static const struct fsnotify_ops audit_tree_ops = { .handle_event = audit_tree_handle_event, - .should_send_event = audit_tree_send_event, .free_group_priv =NULL , .free_event =NULL , .freeing_mark = audit_tree_freeing_mark,
kernel/audit_watch.c +0 -9
@@ -465,14 +465,6 @@ void audit_remove_watch_rule(struct audit_krule *krule) } } -static bool audit_watch_should_send_event (struct fsnotify_group *group,struct inode *inode, -struct fsnotify_mark *inode_mark, -struct fsnotify_mark *vfsmount_mark, -__u32 mask,void *data,int data_type) -{ -return true; -} -/* Update watch data in audit rules based on fsnotify events. */ static int audit_watch_handle_event(struct fsnotify_group *group, struct inode *to_tell,
@@ -512,7 +504,6 @@ static int audit_watch_handle_event(struct fsnotify_group *group, }static const struct fsnotify_ops audit_watch_fsnotify_ops = { - .should_send_event = audit_watch_should_send_event, .handle_event = audit_watch_handle_event, .free_group_priv =NULL , .freeing_mark =NULL ,
Signature · 1 line
1.8.1.4
Re: [PATCH 3/3] fsnotify: Remove .should_send_event callback
Looks good,