fsnotify: Do not share events between notification groups
Subsystems (6)
Jan Kara
maintainerv3 cover fsnotify: Do not share events between notification groups
Hello,
this is the third 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/4 for more details).
Since v2, I have added Reviewed-by tags and cleaned up some smaller things Christoph pointed out.
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 v3 1/4 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
maintainerPATCH v3 2/4 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 (~400 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 | 206 +++++++++++---------- 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 | 334 +++-------------------------------- include/linux/fsnotify_backend.h | 114 +++--------- kernel/audit_tree.c | 8 +- kernel/audit_watch.c | 14 +- 13 files changed, 314 insertions(+), 707 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 *inode,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 +100 -106
276 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 *inode, +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 +28 -306
422 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
Jan Kara
maintainerPATCH v3 3/4 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 (inode->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 *inode, -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 inode=%p inode_mark=%p vfsmnt_mark=%p " -"mask=%x data=%p data_type=%d\n" , __func__, group, inode, - 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 inode=%p mask=%x\n" , __func__, group, inode, 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 *inode, 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
Jan Kara
maintainerPATCH v3 4/4 fsnotify: Remove pointless NULL initializers
In reply to Jan KaraWe usually rely on the fact that struct members not specified in the initializer are set to NULL. So do that with fsnotify function pointers as well.
--- fs/notify/dnotify/dnotify.c | 3 --- fs/notify/fanotify/fanotify.c | 1 - kernel/audit_tree.c | 2 -- kernel/audit_watch.c | 3 --- 4 files changed, 9 deletions(-)
fs/notify/dnotify/dnotify.c +0 -3
@@ -138,9 +138,6 @@ static void dnotify_free_mark(struct fsnotify_mark *fsn_mark)static struct fsnotify_ops dnotify_fsnotify_ops = { .handle_event = dnotify_handle_event, - .free_group_priv =NULL , - .freeing_mark =NULL , - .free_event =NULL , };/*
fs/notify/fanotify/fanotify.c +0 -1
@@ -227,5 +227,4 @@ const struct fsnotify_ops fanotify_fsnotify_ops = { .handle_event = fanotify_handle_event, .free_group_priv = fanotify_free_group_priv, .free_event = fanotify_free_event, - .freeing_mark = NULL, };
kernel/audit_tree.c +0 -2
@@ -936,8 +936,6 @@ static void audit_tree_freeing_mark(struct fsnotify_mark *entry, struct fsnotifystatic const struct fsnotify_ops audit_tree_ops = { .handle_event = audit_tree_handle_event, - .free_group_priv =NULL , - .free_event =NULL , .freeing_mark = audit_tree_freeing_mark, };
kernel/audit_watch.c +0 -3
@@ -505,9 +505,6 @@ static int audit_watch_handle_event(struct fsnotify_group *group,static const struct fsnotify_ops audit_watch_fsnotify_ops = { .handle_event = audit_watch_handle_event, - .free_group_priv =NULL , - .freeing_mark =NULL , - .free_event =NULL , };static int __init audit_watch_init (void )
Signature · 1 line
1.8.1.4
Re: [PATCH 4/4] fsnotify: Remove pointless NULL initializers
Quoted 5 lines · Jan Kara
We usually rely on the fact that struct members not specified in the initializer are set to NULL. So do that with fsnotify function pointers as well.
Signed-off-by Jan Kara <[email protected]>
Looks good,