fsnotify: Rearrange fast path to minimise overhead when there is no watcher
Subsystems (8)
Amir Goldstein
reviewerPATCH v3 1/20 fsnotify: Rearrange fast path to minimise overhead when there is no watcher
From: Mel Gorman <[email protected]>
The fsnotify paths are trivial to hit even when there are no watchers and they are surprisingly expensive. For example, every successful vfs_write() hits fsnotify_modify which calls both fsnotify_parent and fsnotify unless FMODE_NONOTIFY is set which is an internal flag invisible to userspace. As it stands, fsnotify_parent is a guaranteed functional call even if there are no watchers and fsnotify() does a substantial amount of unnecessary work before it checks if there are any watchers. A perf profile showed that applying mnt->mnt_fsnotify_mask in fnotify() was almost half of the total samples taken in that function during a test. This patch rearranges the fast paths to reduce the amount of work done when there are no watchers.
The test motivating this was "perf bench sched messaging --pipe". Despite the fact the pipes are anonymous, fsnotify is still called a lot and the overhead is noticeable even though it's completely pointless. It's likely the overhead is negligible for real IO so this is an extreme example. This is a comparison of hackbench using processes and pipes on a 1-socket machine with 8 CPU threads without fanotify watchers.
5.7.0 5.7.0
vanilla fastfsnotify-v1r1
Amean 1 0.4837 ( 0.00%) 0.4630 * 4.27%*
Amean 3 1.5447 ( 0.00%) 1.4557 ( 5.76%)
Amean 5 2.6037 ( 0.00%) 2.4363 ( 6.43%)
Amean 7 3.5987 ( 0.00%) 3.4757 ( 3.42%)
Amean 12 5.8267 ( 0.00%) 5.6983 ( 2.20%)
Amean 18 8.4400 ( 0.00%) 8.1327 ( 3.64%)
Amean 24 11.0187 ( 0.00%) 10.0290 * 8.98%*
Amean 30 13.1013 ( 0.00%) 12.8510 ( 1.91%)
Amean 32 13.9190 ( 0.00%) 13.2410 ( 4.87%) 5.7.0 5.7.0
vanilla fastfsnotify-v1r1Duration User 157.05 152.79
Duration System 1279.98 1219.32
Duration Elapsed 182.81 174.52
This is showing that the latencies are improved by roughly 2-9%. The variability is not shown but some of these results are within the noise as this workload heavily overloads the machine. That said, the system CPU usage is reduced by quite a bit so it makes sense to avoid the overhead even if it is a bit tricky to detect at times. A perf profile of just 1 group of tasks showed that 5.14% of samples taken were in either fsnotify() or fsnotify_parent(). With the patch, 2.8% of samples were in fsnotify, mostly function entry and the initial check for watchers. The check for watchers is complicated enough that inlining it may be controversial.
[Amir] Slightly simplify with mnt_or_sb_mask => marks_mask
--- fs/notify/fsnotify.c | 27 +++++++++++++++------------ include/linux/fsnotify.h | 10 ++++++++++ include/linux/fsnotify_backend.h | 4 ++-- 3 files changed, 27 insertions(+), 14 deletions(-)
fs/notify/fsnotify.c +15 -12
@@ -143,7 +143,7 @@ void __fsnotify_update_child_dentry_flags(struct inode *inode) }/* Notify this dentry's parent about a child's events. */ -int fsnotify_parent (struct dentry *dentry,__u32 mask,const void *data, +int __fsnotify_parent (struct dentry *dentry,__u32 mask,const void *data,int data_type) {struct dentry *parent;
@@ -174,7 +174,7 @@ int fsnotify_parent(struct dentry *dentry, __u32 mask, const void *data,return ret; } -EXPORT_SYMBOL_GPL (fsnotify_parent); +EXPORT_SYMBOL_GPL (__fsnotify_parent); static int send_to_group(struct inode *to_tell, __u32 mask, const void *data,
@@ -315,17 +315,11 @@ int fsnotify(struct inode *to_tell, __u32 mask, const void *data, int data_is,struct fsnotify_iter_info iter_info = {};struct super_block *sb = to_tell->i_sb;struct mount *mnt =NULL ; -__u32 mnt_or_sb_mask = sb->s_fsnotify_mask;int ret =0 ; -__u32 test_mask = (mask &ALL_FSNOTIFY_EVENTS ); +__u32 test_mask, marks_mask; -if (path) { +if (path) mnt =real_mount (path->mnt); - mnt_or_sb_mask |= mnt->mnt_fsnotify_mask; - } -/* An event "on child" is not intended for a mount/sb mark */ -if (mask &FS_EVENT_ON_CHILD ) - mnt_or_sb_mask =0 ;/* * Optimization: srcu_read_lock() has a memory barrier which can
@@ -337,13 +331,22 @@ int fsnotify(struct inode *to_tell, __u32 mask, const void *data, int data_is,if (!to_tell->i_fsnotify_marks && !sb->s_fsnotify_marks && (!mnt || !mnt->mnt_fsnotify_marks))return 0 ; + +/* An event "on child" is not intended for a mount/sb mark */ + marks_mask = to_tell->i_fsnotify_mask; +if (!(mask &FS_EVENT_ON_CHILD )) { + marks_mask |= sb->s_fsnotify_mask; +if (mnt) + marks_mask |= mnt->mnt_fsnotify_mask; + } +/* * if this is a modify event we may need to clear the ignored masks * otherwise return if neither the inode nor the vfsmount/sb care about * this type of event. */ -if (!(mask &FS_MODIFY ) && - !(test_mask & (to_tell->i_fsnotify_mask | mnt_or_sb_mask))) + test_mask = (mask &ALL_FSNOTIFY_EVENTS ); +if (!(mask &FS_MODIFY ) && !(test_mask & marks_mask))return 0 ; iter_info.srcu_idx =srcu_read_lock (&fsnotify_mark_srcu);
include/linux/fsnotify.h +10 -0
@@ -44,6 +44,16 @@ static inline void fsnotify_dirent(struct inode *dir, struct dentry *dentry,fsnotify_name (dir, mask,d_inode (dentry), &dentry->d_name,0 ); } +/* Notify this dentry's parent about a child's events. */ +static inline int fsnotify_parent (struct dentry *dentry,__u32 mask, +const void *data,int data_type) +{ +if (!(dentry->d_flags &DCACHE_FSNOTIFY_PARENT_WATCHED )) +return 0 ; + +return __fsnotify_parent (dentry, mask, data, data_type); +} +/* * Simple wrappers to consolidate calls fsnotify_parent()/fsnotify() when * an event is on a file/dentry.
include/linux/fsnotify_backend.h +2 -2
@@ -379,7 +379,7 @@ struct fsnotify_mark {/* main fsnotify call to send events */ extern int fsnotify (struct inode *to_tell,__u32 mask,const void *data,int data_type,const struct qstr *name,u32 cookie); -extern int fsnotify_parent (struct dentry *dentry,__u32 mask,const void *data, +extern int __fsnotify_parent (struct dentry *dentry,__u32 mask,const void *data,int data_type);extern void __fsnotify_inode_delete (struct inode *inode);extern void __fsnotify_vfsmount_delete (struct vfsmount *mnt);
@@ -541,7 +541,7 @@ static inline int fsnotify(struct inode *to_tell, __u32 mask, const void *data,return 0 ; } -static inline int fsnotify_parent (struct dentry *dentry,__u32 mask, +static inline int __fsnotify_parent (struct dentry *dentry,__u32 mask,const void *data,int data_type) {return 0 ;
Signature · 1 line
2.17.1
Amir Goldstein
reviewerPATCH v3 2/20 fsnotify: fold fsnotify() call into fsnotify_parent()
All (two) callers of fsnotify_parent() also call fsnotify() to notify the child inode. Move the second fsnotify() call into fsnotify_parent().
This will allow more flexibility in making decisions about which of the two event falvors should be sent.
Using 'goto notify_child' in the inline helper seems a bit strange, but it mimics the code in __fsnotify_parent() for clarity and the goto pattern will become less strage after following patches are applied.
--- fs/notify/fsnotify.c | 27 ++++++++++++++++++--------- include/linux/fsnotify.h | 33 +++++++++++++-------------------- 2 files changed, 31 insertions(+), 29 deletions(-)
fs/notify/fsnotify.c +18 -9
@@ -142,16 +142,20 @@ void __fsnotify_update_child_dentry_flags(struct inode *inode)spin_unlock (&inode->i_lock); } -/* Notify this dentry's parent about a child's events. */ +/* +* Notify this dentry's parent about a child's events with child name info +* if parent is watching. +* Notify also the child without name info if child inode is watching. +*/ int __fsnotify_parent (struct dentry *dentry,__u32 mask,const void *data, -int data_type) +int data_type) {struct dentry *parent;struct inode *p_inode;int ret =0 ;if (!(dentry->d_flags &DCACHE_FSNOTIFY_PARENT_WATCHED )) -return 0 ; + goto notify_child; parent =dget_parent (dentry); p_inode = parent->d_inode;
@@ -161,18 +165,23 @@ int __fsnotify_parent(struct dentry *dentry, __u32 mask, const void *data, }else if (p_inode->i_fsnotify_mask & mask &ALL_FSNOTIFY_EVENTS ) {struct name_snapshot name; -/* we are notifying a parent so come up with the new mask which -* specifies these are events which came from a child. */ - mask |=FS_EVENT_ON_CHILD ; - +/* +* We are notifying a parent, so set a flag in mask to inform +* backend that event has information about a child entry. +*/ take_dentry_name_snapshot (&name, dentry); - ret =fsnotify (p_inode, mask, data, data_type, &name.name,0 ); + ret =fsnotify (p_inode, mask |FS_EVENT_ON_CHILD , data, + data_type, &name.name,0 );release_dentry_name_snapshot (&name); }dput (parent); -return ret; +if (ret) +return ret; + +notify_child: +return fsnotify (d_inode (dentry), mask, data, data_type,NULL ,0 ); }EXPORT_SYMBOL_GPL (__fsnotify_parent);
include/linux/fsnotify.h +13 -20
@@ -48,44 +48,37 @@ static inline void fsnotify_dirent(struct inode *dir, struct dentry *dentry,static inline int fsnotify_parent (struct dentry *dentry,__u32 mask,const void *data,int data_type) { +struct inode *inode =d_inode (dentry); + +if (S_ISDIR (inode->i_mode)) + mask |=FS_ISDIR ; +if (!(dentry->d_flags &DCACHE_FSNOTIFY_PARENT_WATCHED )) -return 0 ; + goto notify_child;return __fsnotify_parent (dentry, mask, data, data_type); + +notify_child: +return fsnotify (inode, mask, data, data_type,NULL ,0 ); }/* -* Simple wrappers to consolidate calls fsnotify_parent()/fsnotify() when -* an event is on a file/dentry. +* Simple wrappers to consolidate calls to fsnotify_parent() when an event +* is on a file/dentry. */ static inline void fsnotify_dentry (struct dentry *dentry,__u32 mask) { -struct inode *inode =d_inode (dentry); - -if (S_ISDIR (inode->i_mode)) - mask |=FS_ISDIR ; - -fsnotify_parent (dentry, mask, inode,FSNOTIFY_EVENT_INODE ); -fsnotify (inode, mask, inode,FSNOTIFY_EVENT_INODE ,NULL ,0 ); +fsnotify_parent (dentry, mask,d_inode (dentry),FSNOTIFY_EVENT_INODE ); }static inline int fsnotify_file (struct file *file,__u32 mask) {const struct path *path = &file->f_path; -struct inode *inode =file_inode (file); -int ret;if (file->f_mode &FMODE_NONOTIFY )return 0 ; -if (S_ISDIR (inode->i_mode)) - mask |=FS_ISDIR ; - - ret =fsnotify_parent (path->dentry, mask, path,FSNOTIFY_EVENT_PATH ); -if (ret) -return ret; - -return fsnotify (inode, mask, path,FSNOTIFY_EVENT_PATH ,NULL ,0 ); +return fsnotify_parent (path->dentry, mask, path,FSNOTIFY_EVENT_PATH ); }/* Simple call site for access decisions */
Signature · 1 line
2.17.1
Amir Goldstein
reviewerPATCH v3 3/20 fsnotify: return non const from fsnotify_data_inode()
In reply to Amir GoldsteinReturn non const inode pointer from fsnotify_data_inode(). None of the fsnotify hooks pass const inode pointer as data and callers often need to cast to a non const pointer.
--- fs/notify/fanotify/fanotify.c | 2 +- include/linux/fsnotify_backend.h | 5 ++--- 2 files changed, 3 insertions(+), 4 deletions(-)
fs/notify/fanotify/fanotify.c +1 -1
@@ -341,7 +341,7 @@ static struct inode *fanotify_fid_inode(struct inode *to_tell, u32 event_mask,if (event_mask &ALL_FSNOTIFY_DIRENT_EVENTS )return to_tell; -return (struct inode *)fsnotify_data_inode (data, data_type); +return fsnotify_data_inode (data, data_type); } struct fanotify_event *fanotify_alloc_event(struct fsnotify_group *group,
include/linux/fsnotify_backend.h +2 -3
@@ -220,12 +220,11 @@ enum fsnotify_data_type { FSNOTIFY_EVENT_INODE, }; -static inline const struct inode *fsnotify_data_inode (const void *data, -int data_type) +static inline struct inode *fsnotify_data_inode (const void *data,int data_type) {switch (data_type) {case FSNOTIFY_EVENT_INODE : -return data; +return (struct inode *)data;case FSNOTIFY_EVENT_PATH :return d_inode (((const struct path *)data)->dentry);default :
Signature · 1 line
2.17.1
Amir Goldstein
reviewerPATCH v3 4/20 nfsd: use fsnotify_data_inode() to get the unlinked inode
In reply to Amir GoldsteinThe inode argument to handle_event() is about to become obsolete.
--- fs/nfsd/filecache.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
fs/nfsd/filecache.c +3 -1
@@ -599,11 +599,13 @@ static struct notifier_block nfsd_file_lease_notifier = {static int nfsd_file_fsnotify_handle_event (struct fsnotify_group *group, -struct inode *inode, +struct inode *to_tell,u32 mask,const void *data,int data_type,const struct qstr *file_name,u32 cookie,struct fsnotify_iter_info *iter_info) { +struct inode *inode =fsnotify_data_inode (data, data_type); +trace_nfsd_file_fsnotify_handle_event (inode, mask);/* Should be no marks on non-regular files */
Signature · 1 line
2.17.1
Amir Goldstein
reviewerPATCH v3 5/20 kernfs: do not call fsnotify() with name without a parent
In reply to Amir GoldsteinWhen creating an FS_MODIFY event on inode itself (not on parent) the file_name argument should be NULL.
The change to send a non NULL name to inode itself was done on purpuse as part of another commit, as Tejun writes: "...While at it, supply the target file name to fsnotify() from kernfs_node->name.".
But this is wrong practice and inconsistent with inotify behavior when watching a single file. When a child is being watched (as opposed to the parent directory) the inotify event should contain the watch descriptor, but not the file name.
--- fs/kernfs/file.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
fs/kernfs/file.c +1 -1
@@ -912,7 +912,7 @@ static void kernfs_notify_workfn(struct work_struct *work) }fsnotify (inode,FS_MODIFY , inode,FSNOTIFY_EVENT_INODE , - &name,0 ); +NULL ,0 );iput (inode); }
Signature · 1 line
2.17.1
Amir Goldstein
reviewerPATCH v3 6/20 inotify: do not use objectid when comparing events
In reply to Amir Goldsteininotify's event->wd is the object identifier. Compare that instead of the common fsnotidy event objectid, so we can get rid of the objectid field later.
--- fs/notify/inotify/inotify_fsnotify.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
fs/notify/inotify/inotify_fsnotify.c +2 -2
@@ -39,7 +39,7 @@ static bool event_compare(struct fsnotify_event *old_fsn,if (old->mask &FS_IN_IGNORED )return false;if ((old->mask == new->mask) && - (old_fsn->objectid == new_fsn->objectid) && + (old->wd == new->wd) && (old->name_len == new->name_len) && (!old->name_len || !strcmp (old->name, new->name)))return true;
@@ -116,7 +116,7 @@ int inotify_handle_event(struct fsnotify_group *group, mask &= ~IN_ISDIR ; fsn_event = &event->fse; -fsnotify_init_event (fsn_event, (unsigned long )inode); +fsnotify_init_event (fsn_event,0 ); event->mask = mask; event->wd = i_mark->wd; event->sync_cookie = cookie;
Signature · 1 line
2.17.1
Amir Goldstein
reviewerPATCH v3 7/20 fanotify: create overflow event type
In reply to Amir GoldsteinThe special overflow event is allocated as struct fanotify_path_event, but with a null path.
Use a special event type to identify the overflow event, so the helper fanotify_has_event_path() will always indicate a non null path.
Allocating the overflow event doesn't need any of the fancy stuff in fanotify_alloc_event(), so create a simplified helper for allocating the overflow event.
There is also no need to store and report the pid with an overflow event.
--- fs/notify/fanotify/fanotify.c | 27 +++++++++++---------------- fs/notify/fanotify/fanotify.h | 15 +++++++++------ fs/notify/fanotify/fanotify_user.c | 21 ++++++++++++++++----- 3 files changed, 36 insertions(+), 27 deletions(-)
fs/notify/fanotify/fanotify.c +11 -16
@@ -344,11 +344,11 @@ static struct inode *fanotify_fid_inode(struct inode *to_tell, u32 event_mask,return fsnotify_data_inode (data, data_type); } -struct fanotify_event *fanotify_alloc_event (struct fsnotify_group *group, -struct inode *inode,u32 mask, -const void *data,int data_type, -const struct qstr *file_name, -__kernel_fsid_t *fsid) +static struct fanotify_event *fanotify_alloc_event (struct fsnotify_group *group, +struct inode *inode,u32 mask, +const void *data,int data_type, +const struct qstr *file_name, +__kernel_fsid_t *fsid) {struct fanotify_event *event =NULL ;struct fanotify_fid_event *ffe =NULL ;
@@ -426,8 +426,7 @@ struct fanotify_event *fanotify_alloc_event(struct fsnotify_group *group,* event queue, so event reported on parent is merged with event * reported on child when both directory and child watches exist. */ -fsnotify_init_event (&event->fse, (unsigned long )id); - event->mask = mask; +fanotify_init_event (event, (unsigned long )id, mask);if (FAN_GROUP_FLAG (group,FAN_REPORT_TID )) event->pid =get_pid (task_pid (current));else
@@ -443,15 +442,8 @@ struct fanotify_event *fanotify_alloc_event(struct fsnotify_group *group,fanotify_encode_fh (fanotify_event_dir_fh (event), id, gfp);if (fanotify_event_has_path (event)) { -struct path *p =fanotify_event_path (event); - -if (path) { - *p = *path; -path_get (path); - }else { - p->mnt =NULL ; - p->dentry =NULL ; - } + *fanotify_event_path (event) = *path; +path_get (path); } out:memalloc_unuse_memcg ();
@@ -640,6 +632,9 @@ static void fanotify_free_event(struct fsnotify_event *fsn_event)case FANOTIFY_EVENT_TYPE_FID_NAME :fanotify_free_name_event (event);break ; +case FANOTIFY_EVENT_TYPE_OVERFLOW : +kfree (event); +break ;default :WARN_ON_ONCE (1 ); }
fs/notify/fanotify/fanotify.h +9 -6
@@ -63,6 +63,7 @@ enum fanotify_event_type {FANOTIFY_EVENT_TYPE_FID_NAME ,/* variable length */ FANOTIFY_EVENT_TYPE_PATH ,FANOTIFY_EVENT_TYPE_PATH_PERM , + FANOTIFY_EVENT_TYPE_OVERFLOW, /* struct fanotify_event */ }; struct fanotify_event {
@@ -72,6 +73,14 @@ struct fanotify_event {struct pid *pid; }; +static inline void fanotify_init_event (struct fanotify_event *event, +unsigned long id,u32 mask) +{ +fsnotify_init_event (&event->fse, id); + event->mask = mask; + event->pid =NULL ; +} +struct fanotify_fid_event {struct fanotify_event fae;__kernel_fsid_t fsid;
@@ -202,9 +211,3 @@ static inline struct path *fanotify_event_path(struct fanotify_event *event)else return NULL ; } - -struct fanotify_event *fanotify_alloc_event (struct fsnotify_group *group, -struct inode *inode,u32 mask, -const void *data,int data_type, -const struct qstr *file_name, -__kernel_fsid_t *fsid);
fs/notify/fanotify/fanotify_user.c +16 -5
@@ -831,13 +831,26 @@ static int fanotify_add_inode_mark(struct fsnotify_group *group, FSNOTIFY_OBJ_TYPE_INODE, mask, flags, fsid); } +static struct fsnotify_event *fanotify_alloc_overflow_event (void ) +{ +struct fanotify_event *oevent; + + oevent =kmalloc (sizeof (*oevent),GFP_KERNEL_ACCOUNT ); +if (!oevent) +return NULL ; + +fanotify_init_event (oevent,0 ,FS_Q_OVERFLOW ); + oevent->type =FANOTIFY_EVENT_TYPE_OVERFLOW ; + +return &oevent->fse; +} +/* fanotify syscalls */ SYSCALL_DEFINE2(fanotify_init, unsigned int, flags, unsigned int, event_f_flags) {struct fsnotify_group *group;int f_flags, fd;struct user_struct *user; -struct fanotify_event *oevent;pr_debug ("%s: flags=%x event_f_flags=%x\n" , __func__, flags, event_f_flags);
@@ -892,13 +905,11 @@ SYSCALL_DEFINE2(fanotify_init, unsigned int, flags, unsigned int, event_f_flags)atomic_inc (&user->fanotify_listeners); group->memcg =get_mem_cgroup_from_mm (current->mm); - oevent =fanotify_alloc_event (group,NULL ,FS_Q_OVERFLOW ,NULL , -FSNOTIFY_EVENT_NONE ,NULL ,NULL ); -if (unlikely (!oevent)) { + group->overflow_event =fanotify_alloc_overflow_event (); +if (unlikely (!group->overflow_event)) { fd = -ENOMEM ; goto out_destroy_group; } - group->overflow_event = &oevent->fse;if (force_o_largefile ()) event_f_flags |=O_LARGEFILE ;
Signature · 1 line
2.17.1
Amir Goldstein
reviewerPATCH v3 8/20 fanotify: break up fanotify_alloc_event()
In reply to Amir GoldsteinBreak up fanotify_alloc_event() into helpers by event struct type.
--- fs/notify/fanotify/fanotify.c | 146 ++++++++++++++++++++-------------- 1 file changed, 85 insertions(+), 61 deletions(-)
fs/notify/fanotify/fanotify.c +85 -61
@@ -344,6 +344,77 @@ static struct inode *fanotify_fid_inode(struct inode *to_tell, u32 event_mask,return fsnotify_data_inode (data, data_type); } +struct fanotify_event *fanotify_alloc_path_event (const struct path *path, +gfp_t gfp) +{ +struct fanotify_path_event *pevent; + + pevent =kmem_cache_alloc (fanotify_path_event_cachep, gfp); +if (!pevent) +return NULL ; + + pevent->fae.type =FANOTIFY_EVENT_TYPE_PATH ; + pevent->path = *path; +path_get (path); + +return &pevent->fae; +} + +struct fanotify_event *fanotify_alloc_perm_event (const struct path *path, +gfp_t gfp) +{ +struct fanotify_perm_event *pevent; + + pevent =kmem_cache_alloc (fanotify_perm_event_cachep, gfp); +if (!pevent) +return NULL ; + + pevent->fae.type =FANOTIFY_EVENT_TYPE_PATH_PERM ; + pevent->response =0 ; + pevent->state =FAN_EVENT_INIT ; + pevent->path = *path; +path_get (path); + +return &pevent->fae; +} + +struct fanotify_event *fanotify_alloc_fid_event (struct inode *id, +__kernel_fsid_t *fsid, +gfp_t gfp) +{ +struct fanotify_fid_event *ffe; + + ffe =kmem_cache_alloc (fanotify_fid_event_cachep, gfp); +if (!ffe) +return NULL ; + + ffe->fae.type =FANOTIFY_EVENT_TYPE_FID ; + ffe->fsid = *fsid; +fanotify_encode_fh (&ffe->object_fh, id, gfp); + +return &ffe->fae; +} + +struct fanotify_event *fanotify_alloc_name_event (struct inode *id, +__kernel_fsid_t *fsid, +const struct qstr *file_name, +gfp_t gfp) +{ +struct fanotify_name_event *fne; + + fne =kmalloc (sizeof (*fne) + file_name->len +1 , gfp); +if (!fne) +return NULL ; + + fne->fae.type =FANOTIFY_EVENT_TYPE_FID_NAME ; + fne->fsid = *fsid; +fanotify_encode_fh (&fne->dir_fh, id, gfp); + fne->name_len = file_name->len; +strcpy (fne->name, file_name->name); + +return &fne->fae; +} + static struct fanotify_event *fanotify_alloc_event(struct fsnotify_group *group, struct inode *inode, u32 mask, const void *data, int data_type,
@@ -351,8 +422,6 @@ static struct fanotify_event *fanotify_alloc_event(struct fsnotify_group *group, __kernel_fsid_t *fsid) {struct fanotify_event *event =NULL ; -struct fanotify_fid_event *ffe =NULL ; -struct fanotify_name_event *fne =NULL ;gfp_t gfp =GFP_KERNEL_ACCOUNT ;struct inode *id =fanotify_fid_inode (inode, mask, data, data_type);const struct path *path =fsnotify_data_path (data, data_type);
@@ -372,55 +441,23 @@ static struct fanotify_event *fanotify_alloc_event(struct fsnotify_group *group,memalloc_use_memcg (group->memcg);if (fanotify_is_perm_event (mask)) { -struct fanotify_perm_event *pevent; - - pevent =kmem_cache_alloc (fanotify_perm_event_cachep, gfp); -if (!pevent) - goto out; - - event = &pevent->fae; - event->type =FANOTIFY_EVENT_TYPE_PATH_PERM ; - pevent->response =0 ; - pevent->state =FAN_EVENT_INIT ; - goto init; - } - -/* -* For FAN_DIR_MODIFY event, we report the fid of the directory and -* the name of the modified entry. -* Allocate an fanotify_name_event struct and copy the name. -*/ -if (mask &FAN_DIR_MODIFY && !(WARN_ON_ONCE (!file_name))) { - fne =kmalloc (sizeof (*fne) + file_name->len +1 , gfp); -if (!fne) - goto out; - - event = &fne->fae; - event->type =FANOTIFY_EVENT_TYPE_FID_NAME ; - fne->name_len = file_name->len; -strcpy (fne->name, file_name->name); - goto init; - } - -if (FAN_GROUP_FLAG (group,FAN_REPORT_FID )) { - ffe =kmem_cache_alloc (fanotify_fid_event_cachep, gfp); -if (!ffe) - goto out; - - event = &ffe->fae; - event->type =FANOTIFY_EVENT_TYPE_FID ; + event =fanotify_alloc_perm_event (path, gfp); + }else if (mask &FAN_DIR_MODIFY && !(WARN_ON_ONCE (!file_name))) { +/* +* For FAN_DIR_MODIFY event, we report the fid of the directory +* and the name of the modified entry. +* Allocate an fanotify_name_event struct and copy the name. +*/ + event =fanotify_alloc_name_event (id, fsid, file_name, gfp); + }else if (FAN_GROUP_FLAG (group,FAN_REPORT_FID )) { + event =fanotify_alloc_fid_event (id, fsid, gfp); }else { -struct fanotify_path_event *pevent; - - pevent =kmem_cache_alloc (fanotify_path_event_cachep, gfp); -if (!pevent) - goto out; - - event = &pevent->fae; - event->type =FANOTIFY_EVENT_TYPE_PATH ; + event =fanotify_alloc_path_event (path, gfp); } -init: +if (!event) + goto out; +/* * Use the victim inode instead of the watching inode as the id for * event queue, so event reported on parent is merged with event
@@ -432,19 +469,6 @@ static struct fanotify_event *fanotify_alloc_event(struct fsnotify_group *group,else event->pid =get_pid (task_tgid (current)); -if (fsid &&fanotify_event_fsid (event)) - *fanotify_event_fsid (event) = *fsid; - -if (fanotify_event_object_fh (event)) -fanotify_encode_fh (fanotify_event_object_fh (event), id, gfp); - -if (fanotify_event_dir_fh (event)) -fanotify_encode_fh (fanotify_event_dir_fh (event), id, gfp); - -if (fanotify_event_has_path (event)) { - *fanotify_event_path (event) = *path; -path_get (path); - } out:memalloc_unuse_memcg ();return event;
Signature · 1 line
2.17.1
kernel test robot
build botRe: [PATCH v3 08/20] fanotify: break up fanotify_alloc_event()
I love your patch! Perhaps something to improve:
Hi Amir,
I love your patch! Perhaps something to improve:
[auto build test WARNING on ext3/fsnotify]
[also build test WARNING on nfsd/nfsd-next driver-core/driver-core-testing linus/master v5.8-rc4 next-20200707] [If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use as documented in
https://git-scm.com/docs/git-format-patch]
url: https://github.com/0day-ci/linux/commits/Amir-Goldstein/fsnotify-Rearrange-fast-path-to-minimise-overhead-when-there-is-no-watcher/20200708-191525 base: https://git.kernel.org/pub/scm/linux/kernel/git/jack/linux-fs.git fsnotify config: i386-randconfig-r015-20200708 (attached as .config) compiler: gcc-9 (Debian 9.3.0-14) 9.3.0 reproduce (this is a W=1 build): # save the attached .config to linux build tree make W=1 ARCH=i386
If you fix the issue, kindly add following tag as appropriate
All warnings (new ones prefixed by >>):
>> fs/notify/fanotify/fanotify.c:347:24: warning: no previous prototype for 'fanotify_alloc_path_event' [-Wmissing-prototypes]
347 | struct fanotify_event *fanotify_alloc_path_event(const struct path *path,
| ^~~~~~~~~~~~~~~~~~~~~~~~~
>> fs/notify/fanotify/fanotify.c:363:24: warning: no previous prototype for 'fanotify_alloc_perm_event' [-Wmissing-prototypes]
363 | struct fanotify_event *fanotify_alloc_perm_event(const struct path *path,
| ^~~~~~~~~~~~~~~~~~~~~~~~~
>> fs/notify/fanotify/fanotify.c:381:24: warning: no previous prototype for 'fanotify_alloc_fid_event' [-Wmissing-prototypes]
381 | struct fanotify_event *fanotify_alloc_fid_event(struct inode *id,
| ^~~~~~~~~~~~~~~~~~~~~~~~
>> fs/notify/fanotify/fanotify.c:398:24: warning: no previous prototype for 'fanotify_alloc_name_event' [-Wmissing-prototypes] 398 | struct fanotify_event *fanotify_alloc_name_event(struct inode *id,
| ^~~~~~~~~~~~~~~~~~~~~~~~~
vim +/fanotify_alloc_path_event +347 fs/notify/fanotify/fanotify.c
346
> 347 struct fanotify_event *fanotify_alloc_path_event(const struct path *path,
348 gfp_t gfp)
349 {
350 struct fanotify_path_event *pevent;
351
352 pevent = kmem_cache_alloc(fanotify_path_event_cachep, gfp);
353 if (!pevent)
354 return NULL;
355
356 pevent->fae.type = FANOTIFY_EVENT_TYPE_PATH;
357 pevent->path = *path;
358 path_get(path);
359
360 return &pevent->fae;
361 }
362
> 363 struct fanotify_event *fanotify_alloc_perm_event(const struct path *path,
364 gfp_t gfp)
365 {
366 struct fanotify_perm_event *pevent;
367
368 pevent = kmem_cache_alloc(fanotify_perm_event_cachep, gfp);
369 if (!pevent)
370 return NULL;
371
372 pevent->fae.type = FANOTIFY_EVENT_TYPE_PATH_PERM;
373 pevent->response = 0;
374 pevent->state = FAN_EVENT_INIT;
375 pevent->path = *path;
376 path_get(path);
377
378 return &pevent->fae;
379 }
380
> 381 struct fanotify_event *fanotify_alloc_fid_event(struct inode *id,
382 __kernel_fsid_t *fsid,
383 gfp_t gfp)
384 {
385 struct fanotify_fid_event *ffe;
386
387 ffe = kmem_cache_alloc(fanotify_fid_event_cachep, gfp);
388 if (!ffe)
389 return NULL;
390
391 ffe->fae.type = FANOTIFY_EVENT_TYPE_FID;
392 ffe->fsid = *fsid;
393 fanotify_encode_fh(&ffe->object_fh, id, gfp);
394
395 return &ffe->fae;
396 }
397
> 398 struct fanotify_event *fanotify_alloc_name_event(struct inode *id, 399 __kernel_fsid_t *fsid,
400 const struct qstr *file_name,
401 gfp_t gfp)
402 {
403 struct fanotify_name_event *fne;
404
405 fne = kmalloc(sizeof(*fne) + file_name->len + 1, gfp);
406 if (!fne)
407 return NULL;
408
409 fne->fae.type = FANOTIFY_EVENT_TYPE_FID_NAME;
410 fne->fsid = *fsid;
411 fanotify_encode_fh(&fne->dir_fh, id, gfp);
412 fne->name_len = file_name->len;
413 strcpy(fne->name, file_name->name);
414
415 return &fne->fae;
416 }
417
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org
kernel test robot
build botRe: [PATCH v3 08/20] fanotify: break up fanotify_alloc_event()
In reply to Amir GoldsteinI love your patch! Perhaps something to improve:
Hi Amir,
I love your patch! Perhaps something to improve:
[auto build test WARNING on ext3/fsnotify]
[also build test WARNING on nfsd/nfsd-next driver-core/driver-core-testing linus/master v5.8-rc4 next-20200708] [If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use as documented in
https://git-scm.com/docs/git-format-patch]
url: https://github.com/0day-ci/linux/commits/Amir-Goldstein/fsnotify-Rearrange-fast-path-to-minimise-overhead-when-there-is-no-watcher/20200708-191525 base: https://git.kernel.org/pub/scm/linux/kernel/git/jack/linux-fs.git fsnotify config: x86_64-allyesconfig (attached as .config) compiler: clang version 11.0.0 (https://github.com/llvm/llvm-project 02946de3802d3bc65bc9f2eb9b8d4969b5a7add8)
reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# install x86_64 cross compiling tool for clang build
# apt-get install binutils-x86-64-linux-gnu
# save the attached .config to linux build tree
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross ARCH=x86_64
If you fix the issue, kindly add following tag as appropriate
All warnings (new ones prefixed by >>):
>> fs/notify/fanotify/fanotify.c:347:24: warning: no previous prototype for function 'fanotify_alloc_path_event' [-Wmissing-prototypes]
struct fanotify_event *fanotify_alloc_path_event(const struct path *path,
^
fs/notify/fanotify/fanotify.c:347:1: note: declare 'static' if the function is not intended to be used outside of this translation unit
struct fanotify_event *fanotify_alloc_path_event(const struct path *path,
^
static
>> fs/notify/fanotify/fanotify.c:363:24: warning: no previous prototype for function 'fanotify_alloc_perm_event' [-Wmissing-prototypes]
struct fanotify_event *fanotify_alloc_perm_event(const struct path *path,
^
fs/notify/fanotify/fanotify.c:363:1: note: declare 'static' if the function is not intended to be used outside of this translation unit
struct fanotify_event *fanotify_alloc_perm_event(const struct path *path,
^
static
>> fs/notify/fanotify/fanotify.c:381:24: warning: no previous prototype for function 'fanotify_alloc_fid_event' [-Wmissing-prototypes]
struct fanotify_event *fanotify_alloc_fid_event(struct inode *id,
^
fs/notify/fanotify/fanotify.c:381:1: note: declare 'static' if the function is not intended to be used outside of this translation unit
struct fanotify_event *fanotify_alloc_fid_event(struct inode *id,
^
static
>> fs/notify/fanotify/fanotify.c:398:24: warning: no previous prototype for function 'fanotify_alloc_name_event' [-Wmissing-prototypes]
struct fanotify_event *fanotify_alloc_name_event(struct inode *id,
^ fs/notify/fanotify/fanotify.c:398:1: note: declare 'static' if the function is not intended to be used outside of this translation unit struct fanotify_event *fanotify_alloc_name_event(struct inode *id,
^
static
4 warnings generated.
vim +/fanotify_alloc_path_event +347 fs/notify/fanotify/fanotify.c
346
> 347 struct fanotify_event *fanotify_alloc_path_event(const struct path *path,
348 gfp_t gfp)
349 {
350 struct fanotify_path_event *pevent;
351
352 pevent = kmem_cache_alloc(fanotify_path_event_cachep, gfp);
353 if (!pevent)
354 return NULL;
355
356 pevent->fae.type = FANOTIFY_EVENT_TYPE_PATH;
357 pevent->path = *path;
358 path_get(path);
359
360 return &pevent->fae;
361 }
362
> 363 struct fanotify_event *fanotify_alloc_perm_event(const struct path *path,
364 gfp_t gfp)
365 {
366 struct fanotify_perm_event *pevent;
367
368 pevent = kmem_cache_alloc(fanotify_perm_event_cachep, gfp);
369 if (!pevent)
370 return NULL;
371
372 pevent->fae.type = FANOTIFY_EVENT_TYPE_PATH_PERM;
373 pevent->response = 0;
374 pevent->state = FAN_EVENT_INIT;
375 pevent->path = *path;
376 path_get(path);
377
378 return &pevent->fae;
379 }
380
> 381 struct fanotify_event *fanotify_alloc_fid_event(struct inode *id,
382 __kernel_fsid_t *fsid,
383 gfp_t gfp)
384 {
385 struct fanotify_fid_event *ffe;
386
387 ffe = kmem_cache_alloc(fanotify_fid_event_cachep, gfp);
388 if (!ffe)
389 return NULL;
390
391 ffe->fae.type = FANOTIFY_EVENT_TYPE_FID;
392 ffe->fsid = *fsid;
393 fanotify_encode_fh(&ffe->object_fh, id, gfp);
394
395 return &ffe->fae;
396 }
397
> 398 struct fanotify_event *fanotify_alloc_name_event(struct inode *id, 399 __kernel_fsid_t *fsid,
400 const struct qstr *file_name,
401 gfp_t gfp)
402 {
403 struct fanotify_name_event *fne;
404
405 fne = kmalloc(sizeof(*fne) + file_name->len + 1, gfp);
406 if (!fne)
407 return NULL;
408
409 fne->fae.type = FANOTIFY_EVENT_TYPE_FID_NAME;
410 fne->fsid = *fsid;
411 fanotify_encode_fh(&fne->dir_fh, id, gfp);
412 fne->name_len = file_name->len;
413 strcpy(fne->name, file_name->name);
414
415 return &fne->fae;
416 }
417
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org
Amir Goldstein
reviewerRe: [PATCH v3 08/20] fanotify: break up fanotify_alloc_event()
Quoted 49 lines · kernel test robot
Hi Amir,
I love your patch! Perhaps something to improve:
[auto build test WARNING on ext3/fsnotify]
[also build test WARNING on nfsd/nfsd-next driver-core/driver-core-testing linus/master v5.8-rc4 next-20200708] [If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use as documented in
https://git-scm.com/docs/git-format-patch]url: https://github.com/0day-ci/linux/commits/Amir-Goldstein/fsnotify-Rearrange-fast-path-to-minimise-overhead-when-there-is-no-watcher/20200708-191525 base: https://git.kernel.org/pub/scm/linux/kernel/git/jack/linux-fs.git fsnotify config: x86_64-allyesconfig (attached as .config) compiler: clang version 11.0.0 (https://github.com/llvm/llvm-project 02946de3802d3bc65bc9f2eb9b8d4969b5a7add8)reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# installx86_64cross compiling tool for clang build
# apt-get install binutils-x86-64-linux-gnu
# save the attached .config to linux build tree
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross ARCH=x86_64If you fix the issue, kindly add following tag as appropriate
Reported-by kernel test robot <[email protected]>All warnings (new ones prefixed by >>):
Quoted 1 line
Quoted 1 line
fs/notify/fanotify/fanotify.c:347:24: warning: no previous prototype for function 'fanotify_alloc_path_event' [-Wmissing-prototypes]struct
fanotify_event*fanotify_alloc_path_event(const struct path *path,^
fs/notify/fanotify/fanotify.c:347:1: note: declare 'static' if the function is not intended to be used outside of this translation unit structfanotify_event*fanotify_alloc_path_event(const struct path *path,
^
staticQuoted 1 line
Quoted 1 line
fs/notify/fanotify/fanotify.c:363:24: warning: no previous prototype for function 'fanotify_alloc_perm_event' [-Wmissing-prototypes]struct
fanotify_event*fanotify_alloc_perm_event(const struct path *path,^
fs/notify/fanotify/fanotify.c:363:1: note: declare 'static' if the function is not intended to be used outside of this translation unit structfanotify_event*fanotify_alloc_perm_event(const struct path *path,
^
staticQuoted 1 line
Quoted 1 line
fs/notify/fanotify/fanotify.c:381:24: warning: no previous prototype for function 'fanotify_alloc_fid_event' [-Wmissing-prototypes]struct
fanotify_event*fanotify_alloc_fid_event(struct inode *id,^
fs/notify/fanotify/fanotify.c:381:1: note: declare 'static' if the function is not intended to be used outside of this translation unit structfanotify_event*fanotify_alloc_fid_event(struct inode *id,
^
static
Quoted 8 lines
Quoted 1 line
Quoted 1 line
fs/notify/fanotify/fanotify.c:398:24: warning: no previous prototype for function 'fanotify_alloc_name_event' [-Wmissing-prototypes]struct
fanotify_event*fanotify_alloc_name_event(struct inode *id,^
fs/notify/fanotify/fanotify.c:398:1: note: declare 'static' if the function is not intended to be used outside of this translation unit structfanotify_event*fanotify_alloc_name_event(struct inode *id,
^
static
4 warnings generated.
Jan,
I add 'static' rebased and pushed to fanotify_prep branch Rebase had minor conflict in following patch (pass dir argument ...) Also rebased and pushed fanotify_name_fid
Thanks,
Amir.
Amir Goldstein
reviewerPATCH v3 9/20 fsnotify: pass dir argument to handle_event() callback
In reply to Amir GoldsteinThe 'inode' argument to handle_event(), sometimes referred to as 'to_tell' is somewhat obsolete.
It is a remnant from the times when a group could only have an inode mark associated with an event.
We now pass an iter_info array to the callback, with all marks associated with an event.
Most backends ignore this argument, with two exceptions:
1. dnotify uses it for sanity check that event is on directory
2. fanotify uses it to report fid of directory on directory entry modification events
Remove the 'inode' argument and add a 'dir' argument. The callback function signature is deliberately changed, because the meaning of the argument has changed and the arguments have been documented.
The 'dir' argument is NULL when "sending" to a non-dir inode. When 'file_name' argument is non NULL, 'dir' is always referring to the directory that the 'file_name' entry belongs to.
--- fs/nfsd/filecache.c | 6 +++--- fs/notify/dnotify/dnotify.c | 8 ++++---- fs/notify/fanotify/fanotify.c | 23 +++++++++++------------ fs/notify/fsnotify.c | 26 ++++++++++++-------------- fs/notify/inotify/inotify.h | 6 +++--- fs/notify/inotify/inotify_fsnotify.c | 7 +++---- fs/notify/inotify/inotify_user.c | 4 ++-- include/linux/fsnotify_backend.h | 18 +++++++++++++++--- kernel/audit_fsnotify.c | 10 +++++----- kernel/audit_tree.c | 6 +++--- kernel/audit_watch.c | 6 +++--- 11 files changed, 64 insertions(+), 56 deletions(-)
fs/nfsd/filecache.c +3 -3
@@ -598,9 +598,9 @@ static struct notifier_block nfsd_file_lease_notifier = { };static int -nfsd_file_fsnotify_handle_event (struct fsnotify_group *group, -struct inode *to_tell, -u32 mask,const void *data,int data_type, +nfsd_file_fsnotify_handle_event (struct fsnotify_group *group,u32 mask, +const void *data,int data_type, +struct inode *dir,const struct qstr *file_name,u32 cookie,struct fsnotify_iter_info *iter_info) {
fs/notify/dnotify/dnotify.c +4 -4
@@ -70,9 +70,9 @@ static void dnotify_recalc_inode_mask(struct fsnotify_mark *fsn_mark)* destroy the dnotify struct if it was not registered to receive multiple * events. */ -static int dnotify_handle_event (struct fsnotify_group *group, -struct inode *inode, -u32 mask,const void *data,int data_type, +static int dnotify_handle_event (struct fsnotify_group *group,u32 mask, +const void *data,int data_type, +struct inode *dir,const struct qstr *file_name,u32 cookie,struct fsnotify_iter_info *iter_info) {
@@ -84,7 +84,7 @@ static int dnotify_handle_event(struct fsnotify_group *group,__u32 test_mask = mask & ~FS_EVENT_ON_CHILD ;/* not a dir, dnotify doesn't care */ -if (!S_ISDIR (inode->i_mode)) +if (!dir)return 0 ;if (WARN_ON (fsnotify_iter_vfsmount_mark (iter_info)))
fs/notify/fanotify/fanotify.c +11 -12
@@ -335,11 +335,11 @@ static void fanotify_encode_fh(struct fanotify_fh *fh, struct inode *inode,* FS_ATTRIB reports the child inode even if reported on a watched parent. * FS_CREATE reports the modified dir inode and not the created inode. */ -static struct inode *fanotify_fid_inode (struct inode *to_tell,u32 event_mask, -const void *data,int data_type) +static struct inode *fanotify_fid_inode (u32 event_mask,const void *data, +int data_type,struct inode *dir) {if (event_mask &ALL_FSNOTIFY_DIRENT_EVENTS ) -return to_tell; +return dir;return fsnotify_data_inode (data, data_type); }
@@ -416,14 +416,14 @@ struct fanotify_event *fanotify_alloc_name_event(struct inode *id, }static struct fanotify_event *fanotify_alloc_event (struct fsnotify_group *group, -struct inode *inode,u32 mask, -const void *data,int data_type, +u32 mask,const void *data, +int data_type,struct inode *dir,const struct qstr *file_name,__kernel_fsid_t *fsid) {struct fanotify_event *event =NULL ;gfp_t gfp =GFP_KERNEL_ACCOUNT ; -struct inode *id =fanotify_fid_inode (inode, mask, data, data_type); +struct inode *id =fanotify_fid_inode (mask, data, data_type, dir);const struct path *path =fsnotify_data_path (data, data_type);/*
@@ -507,9 +507,9 @@ static __kernel_fsid_t fanotify_get_fsid(struct fsnotify_iter_info *iter_info)return fsid; } -static int fanotify_handle_event (struct fsnotify_group *group, -struct inode *inode, -u32 mask,const void *data,int data_type, +static int fanotify_handle_event (struct fsnotify_group *group,u32 mask, +const void *data,int data_type, +struct inode *dir,const struct qstr *file_name,u32 cookie,struct fsnotify_iter_info *iter_info) {
@@ -546,8 +546,7 @@ static int fanotify_handle_event(struct fsnotify_group *group,if (!mask)return 0 ; -pr_debug ("%s: group=%p inode=%p mask=%x\n" , __func__, group, inode, - mask); +pr_debug ("%s: group=%p mask=%x\n" , __func__, group, mask);if (fanotify_is_perm_event (mask)) {/*
@@ -565,7 +564,7 @@ static int fanotify_handle_event(struct fsnotify_group *group,return 0 ; } - event =fanotify_alloc_event (group, inode, mask, data, data_type, + event =fanotify_alloc_event (group, mask, data, data_type, dir, file_name, &fsid); ret = -ENOMEM ;if (unlikely (!event)) {
fs/notify/fsnotify.c +12 -14
@@ -185,11 +185,9 @@ int __fsnotify_parent(struct dentry *dentry, __u32 mask, const void *data, }EXPORT_SYMBOL_GPL (__fsnotify_parent); -static int send_to_group (struct inode *to_tell, -__u32 mask,const void *data, -int data_is,u32 cookie, -const struct qstr *file_name, -struct fsnotify_iter_info *iter_info) +static int send_to_group (__u32 mask,const void *data,int data_type, +struct inode *dir,const struct qstr *file_name, +u32 cookie,struct fsnotify_iter_info *iter_info) {struct fsnotify_group *group =NULL ;__u32 test_mask = (mask &ALL_FSNOTIFY_EVENTS );
@@ -225,15 +223,14 @@ static int send_to_group(struct inode *to_tell, } } -pr_debug ("%s: group=%p to_tell=%p mask=%x marks_mask=%x marks_ignored_mask=%x" -" data=%p data_is=%d cookie=%d\n" , - __func__, group, to_tell, mask, marks_mask, marks_ignored_mask, - data, data_is, cookie); +pr_debug ("%s: group=%p mask=%x marks_mask=%x marks_ignored_mask=%x data=%p data_type=%d dir=%p cookie=%d\n" , + __func__, group, mask, marks_mask, marks_ignored_mask, + data, data_type, dir, cookie);if (!(test_mask & marks_mask & ~marks_ignored_mask))return 0 ; -return group->ops->handle_event (group, to_tell, mask, data, data_is, +return group->ops->handle_event (group, mask, data, data_type, dir, file_name, cookie, iter_info); }
@@ -317,12 +314,13 @@ static void fsnotify_iter_next(struct fsnotify_iter_info *iter_info)* out to all of the registered fsnotify_group. Those groups can then use the * notification event in whatever means they feel necessary. */ -int fsnotify (struct inode *to_tell,__u32 mask,const void *data,int data_is, +int fsnotify (struct inode *to_tell,__u32 mask,const void *data,int data_type,const struct qstr *file_name,u32 cookie) { -const struct path *path =fsnotify_data_path (data, data_is); +const struct path *path =fsnotify_data_path (data, data_type);struct fsnotify_iter_info iter_info = {};struct super_block *sb = to_tell->i_sb; +struct inode *dir =S_ISDIR (to_tell->i_mode) ? to_tell :NULL ;struct mount *mnt =NULL ;int ret =0 ;__u32 test_mask, marks_mask;
@@ -375,8 +373,8 @@ int fsnotify(struct inode *to_tell, __u32 mask, const void *data, int data_is,* That's why this traversal is so complicated... */ while (fsnotify_iter_select_report_types (&iter_info)) { - ret =send_to_group (to_tell, mask, data, data_is, cookie, - file_name, &iter_info); + ret =send_to_group (mask, data, data_type, dir, file_name, + cookie, &iter_info);if (ret && (mask &ALL_FSNOTIFY_PERM_EVENTS )) goto out;
fs/notify/inotify/inotify.h +3 -3
@@ -24,9 +24,9 @@ static inline struct inotify_event_info *INOTIFY_E(struct fsnotify_event *fse)extern void inotify_ignored_and_remove_idr (struct fsnotify_mark *fsn_mark,struct fsnotify_group *group); -extern int inotify_handle_event (struct fsnotify_group *group, -struct inode *inode, -u32 mask,const void *data,int data_type, +extern int inotify_handle_event (struct fsnotify_group *group,u32 mask, +const void *data,int data_type, +struct inode *dir,const struct qstr *file_name,u32 cookie,struct fsnotify_iter_info *iter_info);
fs/notify/inotify/inotify_fsnotify.c +3 -4
@@ -55,9 +55,8 @@ static int inotify_merge(struct list_head *list,return event_compare (last_event, event); } -int inotify_handle_event (struct fsnotify_group *group, -struct inode *inode, -u32 mask,const void *data,int data_type, +int inotify_handle_event (struct fsnotify_group *group,u32 mask, +const void *data,int data_type,struct inode *dir,const struct qstr *file_name,u32 cookie,struct fsnotify_iter_info *iter_info) {
@@ -82,7 +81,7 @@ int inotify_handle_event(struct fsnotify_group *group, alloc_len += len +1 ; } -pr_debug ("%s: group=%p inode=%p mask=%x\n" , __func__, group, inode, +pr_debug ("%s: group=%p mark=%p mask=%x\n" , __func__, group, inode_mark, mask); i_mark = container_of(inode_mark, struct inotify_inode_mark,
fs/notify/inotify/inotify_user.c +2 -2
@@ -490,8 +490,8 @@ void inotify_ignored_and_remove_idr(struct fsnotify_mark *fsn_mark, fsn_mark);/* Queue ignore event for the watch */ -inotify_handle_event (group,NULL ,FS_IN_IGNORED ,NULL , -FSNOTIFY_EVENT_NONE ,NULL ,0 , &iter_info); +inotify_handle_event (group,FS_IN_IGNORED ,NULL ,FSNOTIFY_EVENT_NONE , +NULL ,NULL ,0 , &iter_info); i_mark = container_of(fsn_mark, struct inotify_inode_mark, fsn_mark);/* remove this mark from the idr */
include/linux/fsnotify_backend.h +15 -3
@@ -108,6 +108,19 @@ struct mem_cgroup;* these operations for each relevant group. * * handle_event - main call for a group to handle an fs event +* @group: group to notify +* @mask: event type and flags +* @data: object that event happened on +* @data_type: type of object for fanotify_data_XXX() accessors +* @dir: optional directory associated with event - +* if @file_name is not NULL, this is the directory that +* @file_name is relative to. Otherwise, @dir is the object +* inode if event happened on directory and NULL if event +* happenned on a non-directory. +* @file_name: optional file name associated with event +* @cookie: inotify rename cookie +* @iter_info: array of marks from this group that are interested in the event +* * free_group_priv - called when a group refcnt hits 0 to clean up the private union * freeing_mark - called when a mark is being destroyed for some reason. The group * MUST be holding a reference on each mark and that reference must be
@@ -115,9 +128,8 @@ struct mem_cgroup;* userspace messages that marks have been removed. */ struct fsnotify_ops { -int (*handle_event)(struct fsnotify_group *group, -struct inode *inode, -u32 mask,const void *data,int data_type, +int (*handle_event)(struct fsnotify_group *group,u32 mask, +const void *data,int data_type,struct inode *dir,const struct qstr *file_name,u32 cookie,struct fsnotify_iter_info *iter_info);void (*free_group_priv)(struct fsnotify_group *group);
kernel/audit_fsnotify.c +5 -5
@@ -152,11 +152,11 @@ static void audit_autoremove_mark_rule(struct audit_fsnotify_mark *audit_mark) }/* Update mark data in audit rules based on fsnotify events. */ -static int audit_mark_handle_event (struct fsnotify_group *group, -struct inode *to_tell, -u32 mask,const void *data,int data_type, -const struct qstr *dname,u32 cookie, -struct fsnotify_iter_info *iter_info) +static int audit_mark_handle_event (struct fsnotify_group *group,u32 mask, +const void *data,int data_type, +struct inode *dir, +const struct qstr *dname,u32 cookie, +struct fsnotify_iter_info *iter_info) {struct fsnotify_mark *inode_mark =fsnotify_iter_inode_mark (iter_info);struct audit_fsnotify_mark *audit_mark;
kernel/audit_tree.c +3 -3
@@ -1037,9 +1037,9 @@ static void evict_chunk(struct audit_chunk *chunk)audit_schedule_prune (); } -static int audit_tree_handle_event (struct fsnotify_group *group, -struct inode *to_tell, -u32 mask,const void *data,int data_type, +static int audit_tree_handle_event (struct fsnotify_group *group,u32 mask, +const void *data,int data_type, +struct inode *dir,const struct qstr *file_name,u32 cookie,struct fsnotify_iter_info *iter_info) {
kernel/audit_watch.c +3 -3
@@ -464,9 +464,9 @@ void audit_remove_watch_rule(struct audit_krule *krule) }/* Update watch data in audit rules based on fsnotify events. */ -static int audit_watch_handle_event (struct fsnotify_group *group, -struct inode *to_tell, -u32 mask,const void *data,int data_type, +static int audit_watch_handle_event (struct fsnotify_group *group,u32 mask, +const void *data,int data_type, +struct inode *dir,const struct qstr *dname,u32 cookie,struct fsnotify_iter_info *iter_info) {
Signature · 1 line
2.17.1
Amir Goldstein
reviewerPATCH v3 10/20 fanotify: generalize the handling of extra event flags
In reply to Amir GoldsteinIn fanotify_group_event_mask() there is logic in place to make sure we are not going to handle an event with no type and just FAN_ONDIR flag. Generalize this logic to any FANOTIFY_EVENT_FLAGS.
There is only one more flag in this group at the moment - FAN_EVENT_ON_CHILD. We never report it to user, but we do pass it in to fanotify_alloc_event() when group is reporting fid as indication that event happened on child. We will have use for this indication later on.
--- fs/notify/fanotify/fanotify.c | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-)
fs/notify/fanotify/fanotify.c +10 -5
@@ -211,7 +211,8 @@ static u32 fanotify_group_event_mask(struct fsnotify_group *group, int data_type) {__u32 marks_mask =0 , marks_ignored_mask =0 ; -__u32 test_mask, user_mask =FANOTIFY_OUTGOING_EVENTS ; +__u32 test_mask, user_mask =FANOTIFY_OUTGOING_EVENTS | +FANOTIFY_EVENT_FLAGS ;const struct path *path =fsnotify_data_path (data, data_type);struct fsnotify_mark *mark;int type;
@@ -264,14 +265,18 @@ static u32 fanotify_group_event_mask(struct fsnotify_group *group,* * For backward compatibility and consistency, do not report FAN_ONDIR * to user in legacy fanotify mode (reporting fd) and report FAN_ONDIR -* to user in FAN_REPORT_FID mode for all event types. +* to user in fid mode for all event types. +* +* We never report FAN_EVENT_ON_CHILD to user, but we do pass it in to +* fanotify_alloc_event() when group is reporting fid as indication +* that event happened on child. */ if (FAN_GROUP_FLAG (group,FAN_REPORT_FID )) { -/* Do not report FAN_ONDIR without any event */ -if (!(test_mask & ~FAN_ONDIR )) +/* Do not report event flags without any event */ +if (!(test_mask & ~FANOTIFY_EVENT_FLAGS ))return 0 ; }else { - user_mask &= ~FAN_ONDIR ; + user_mask &= ~FANOTIFY_EVENT_FLAGS ; }return test_mask & user_mask;
Signature · 1 line
2.17.1
Amir Goldstein
reviewerPATCH v3 11/20 fanotify: generalize merge logic of events on dir
In reply to Amir GoldsteinAn event on directory should never be merged with an event on non-directory regardless of the event struct type.
This change has no visible effect, because currently, with struct fanotify_path_event, the relevant events will not be merged because event path of dir will be different than event path of non-dir.
--- fs/notify/fanotify/fanotify.c | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-)
fs/notify/fanotify/fanotify.c +11 -11
@@ -83,22 +83,22 @@ static bool fanotify_should_merge(struct fsnotify_event *old_fsn, old->type != new->type || old->pid != new->pid)return false; +/* +* We want to merge many dirent events in the same dir (i.e. +* creates/unlinks/renames), but we do not want to merge dirent +* events referring to subdirs with dirent events referring to +* non subdirs, otherwise, user won't be able to tell from a +* mask FAN_CREATE|FAN_DELETE|FAN_ONDIR if it describes mkdir+ +* unlink pair or rmdir+create pair of events. +*/ +if ((old->mask &FS_ISDIR ) != (new->mask &FS_ISDIR )) +return false; +switch (old->type) {case FANOTIFY_EVENT_TYPE_PATH :return fanotify_path_equal (fanotify_event_path (old),fanotify_event_path (new));case FANOTIFY_EVENT_TYPE_FID : -/* -* We want to merge many dirent events in the same dir (i.e. -* creates/unlinks/renames), but we do not want to merge dirent -* events referring to subdirs with dirent events referring to -* non subdirs, otherwise, user won't be able to tell from a -* mask FAN_CREATE|FAN_DELETE|FAN_ONDIR if it describes mkdir+ -* unlink pair or rmdir+create pair of events. -*/ -if ((old->mask &FS_ISDIR ) != (new->mask &FS_ISDIR )) -return false; -return fanotify_fid_event_equal (FANOTIFY_FE (old),FANOTIFY_FE (new));case FANOTIFY_EVENT_TYPE_FID_NAME :
Signature · 1 line
2.17.1
Amir Goldstein
reviewerPATCH v3 12/20 fanotify: distinguish between fid encode error and null fid
In reply to Amir GoldsteinIn fanotify_encode_fh(), both cases of NULL inode and failure to encode ended up with fh type FILEID_INVALID.
Distiguish the case of NULL inode, by setting fh type to FILEID_ROOT. This is just a semantic difference at this point.
Remove stale comment and unneeded check from fid event compare helpers.
--- fs/notify/fanotify/fanotify.c | 14 ++++---------- 1 file changed, 4 insertions(+), 10 deletions(-)
fs/notify/fanotify/fanotify.c +4 -10
@@ -34,10 +34,6 @@ static bool fanotify_fh_equal(struct fanotify_fh *fh1,if (fh1->type != fh2->type || fh1->len != fh2->len)return false; -/* Do not merge events if we failed to encode fh */ -if (fh1->type ==FILEID_INVALID ) -return false; -return !fh1->len || !memcmp (fanotify_fh_buf (fh1),fanotify_fh_buf (fh2), fh1->len); }
@@ -56,10 +52,7 @@ static bool fanotify_fid_event_equal(struct fanotify_fid_event *ffe1,static bool fanotify_name_event_equal (struct fanotify_name_event *fne1,struct fanotify_name_event *fne2) { -/* -* Do not merge name events without dir fh. -* FAN_DIR_MODIFY does not encode object fh, so it may be empty. -*/ +/* Do not merge name events without dir fh */ if (!fne1->dir_fh.len)return false;
@@ -290,8 +283,10 @@ static void fanotify_encode_fh(struct fanotify_fh *fh, struct inode *inode,void *buf = fh->buf;int err; + fh->type =FILEID_ROOT ; + fh->len =0 ;if (!inode) - goto out; +return ; dwords =0 ; err = -ENOENT ;
@@ -326,7 +321,6 @@ static void fanotify_encode_fh(struct fanotify_fh *fh, struct inode *inode, type, bytes, err);kfree (ext_buf); *fanotify_fh_ext_buf_ptr (fh) =NULL ; -out:/* Report the event without a file identifier on encode error */ fh->type =FILEID_INVALID ; fh->len =0 ;
Signature · 1 line
2.17.1
Amir Goldstein
reviewerPATCH v3 13/20 fanotify: generalize test for FAN_REPORT_FID
In reply to Amir GoldsteinAs preparation to new flags that report fids, define a bit set of flags for a group reporting fids, currently containing the only bit FAN_REPORT_FID.
--- fs/notify/fanotify/fanotify.c | 10 ++++++---- fs/notify/fanotify/fanotify_user.c | 12 ++++++------ include/linux/fanotify.h | 6 ++++-- 3 files changed, 16 insertions(+), 12 deletions(-)
fs/notify/fanotify/fanotify.c +6 -4
@@ -207,13 +207,14 @@ static u32 fanotify_group_event_mask(struct fsnotify_group *group,__u32 test_mask, user_mask =FANOTIFY_OUTGOING_EVENTS |FANOTIFY_EVENT_FLAGS ;const struct path *path =fsnotify_data_path (data, data_type); +unsigned int fid_mode =FAN_GROUP_FLAG (group,FANOTIFY_FID_BITS );struct fsnotify_mark *mark;int type;pr_debug ("%s: report_mask=%x mask=%x data=%p data_type=%d\n" , __func__, iter_info->report_mask, event_mask, data, data_type); -if (!FAN_GROUP_FLAG (group,FAN_REPORT_FID )) { +if (!fid_mode) {/* Do we have path to open a file descriptor? */ if (!path)return 0 ;
@@ -264,7 +265,7 @@ static u32 fanotify_group_event_mask(struct fsnotify_group *group,* fanotify_alloc_event() when group is reporting fid as indication * that event happened on child. */ -if (FAN_GROUP_FLAG (group,FAN_REPORT_FID )) { +if (fid_mode) {/* Do not report event flags without any event */ if (!(test_mask & ~FANOTIFY_EVENT_FLAGS ))return 0 ;
@@ -424,6 +425,7 @@ static struct fanotify_event *fanotify_alloc_event(struct fsnotify_group *group,gfp_t gfp =GFP_KERNEL_ACCOUNT ;struct inode *id =fanotify_fid_inode (mask, data, data_type, dir);const struct path *path =fsnotify_data_path (data, data_type); +unsigned int fid_mode =FAN_GROUP_FLAG (group,FANOTIFY_FID_BITS );/* * For queues with unlimited length lost events are not expected and
@@ -448,7 +450,7 @@ static struct fanotify_event *fanotify_alloc_event(struct fsnotify_group *group,* Allocate an fanotify_name_event struct and copy the name. */ event =fanotify_alloc_name_event (id, fsid, file_name, gfp); - }else if (FAN_GROUP_FLAG (group,FAN_REPORT_FID )) { + }else if (fid_mode) { event =fanotify_alloc_fid_event (id, fsid, gfp); }else { event =fanotify_alloc_path_event (path, gfp);
@@ -556,7 +558,7 @@ static int fanotify_handle_event(struct fsnotify_group *group, u32 mask,return 0 ; } -if (FAN_GROUP_FLAG (group,FAN_REPORT_FID )) { +if (FAN_GROUP_FLAG (group,FANOTIFY_FID_BITS )) { fsid =fanotify_get_fsid (iter_info);/* Racing with mark destruction or creation? */ if (!fsid.val[0 ] && !fsid.val[1 ])
fs/notify/fanotify/fanotify_user.c +6 -6
@@ -100,7 +100,7 @@ static struct fanotify_event *get_one_event(struct fsnotify_group *group,if (fsnotify_notify_queue_is_empty (group)) goto out; -if (FAN_GROUP_FLAG (group,FAN_REPORT_FID )) { +if (FAN_GROUP_FLAG (group,FANOTIFY_FID_BITS )) { event_size +=fanotify_event_info_len (FANOTIFY_E (fsnotify_peek_first_event (group))); }
@@ -877,7 +877,7 @@ SYSCALL_DEFINE2(fanotify_init, unsigned int, flags, unsigned int, event_f_flags)return -EINVAL ; } -if ((flags &FAN_REPORT_FID ) && +if ((flags &FANOTIFY_FID_BITS ) && (flags &FANOTIFY_CLASS_BITS ) !=FAN_CLASS_NOTIF )return -EINVAL ;
@@ -1035,7 +1035,7 @@ static int do_fanotify_mark(int fanotify_fd, unsigned int flags, __u64 mask,__kernel_fsid_t __fsid, *fsid =NULL ;u32 valid_mask =FANOTIFY_EVENTS |FANOTIFY_EVENT_FLAGS ;unsigned int mark_type = flags &FANOTIFY_MARK_TYPE_BITS ; -unsigned int obj_type; +unsigned int obj_type, fid_mode;int ret; pr_debug("%s: fanotify_fd=%d flags=%x dfd=%d pathname=%p mask=%llx\n",
@@ -1108,9 +1108,9 @@ static int do_fanotify_mark(int fanotify_fd, unsigned int flags, __u64 mask,* inode events are not supported on a mount mark, because they do not * carry enough information (i.e. path) to be filtered by mount point. */ + fid_mode =FAN_GROUP_FLAG (group,FANOTIFY_FID_BITS );if (mask &FANOTIFY_INODE_EVENTS && - (!FAN_GROUP_FLAG (group,FAN_REPORT_FID ) || - mark_type ==FAN_MARK_MOUNT )) + (!fid_mode || mark_type ==FAN_MARK_MOUNT )) goto fput_and_out;if (flags &FAN_MARK_FLUSH ) {
@@ -1135,7 +1135,7 @@ static int do_fanotify_mark(int fanotify_fd, unsigned int flags, __u64 mask, goto path_put_and_out; } -if (FAN_GROUP_FLAG (group,FAN_REPORT_FID )) { +if (fid_mode) { ret =fanotify_test_fid (&path, &__fsid);if (ret) goto path_put_and_out;
include/linux/fanotify.h +4 -2
@@ -18,8 +18,10 @@#define FANOTIFY_CLASS_BITS (FAN_CLASS_NOTIF | FAN_CLASS_CONTENT | \ FAN_CLASS_PRE_CONTENT) -#define FANOTIFY_INIT_FLAGS (FANOTIFY_CLASS_BITS | \ - FAN_REPORT_TID | FAN_REPORT_FID | \ +#define FANOTIFY_FID_BITS (FAN_REPORT_FID) + +#define FANOTIFY_INIT_FLAGS (FANOTIFY_CLASS_BITS | FANOTIFY_FID_BITS | \ + FAN_REPORT_TID | \ FAN_CLOEXEC | FAN_NONBLOCK | \ FAN_UNLIMITED_QUEUE | FAN_UNLIMITED_MARKS)
Signature · 1 line
2.17.1
Amir Goldstein
reviewerPATCH v3 14/20 fanotify: mask out special event flags from ignored mask
In reply to Amir GoldsteinThe special event flags (FAN_ONDIR, FAN_EVENT_ON_CHILD) never had any meaning in ignored mask. Mask them out explicitly.
--- fs/notify/fanotify/fanotify_user.c | 5 +++++ 1 file changed, 5 insertions(+)
fs/notify/fanotify/fanotify_user.c +5 -0
@@ -1035,6 +1035,7 @@ static int do_fanotify_mark(int fanotify_fd, unsigned int flags, __u64 mask,__kernel_fsid_t __fsid, *fsid =NULL ;u32 valid_mask =FANOTIFY_EVENTS |FANOTIFY_EVENT_FLAGS ;unsigned int mark_type = flags &FANOTIFY_MARK_TYPE_BITS ; +bool ignored = flags &FAN_MARK_IGNORED_MASK ;unsigned int obj_type, fid_mode;int ret;
@@ -1082,6 +1083,10 @@ static int do_fanotify_mark(int fanotify_fd, unsigned int flags, __u64 mask,if (mask & ~valid_mask)return -EINVAL ; +/* Event flags (ONDIR, ON_CHILD) are meaningless in ignored mask */ +if (ignored) + mask &= ~FANOTIFY_EVENT_FLAGS ; + f =fdget (fanotify_fd);if (unlikely (!f.file))return -EBADF ;
Signature · 1 line
2.17.1
Amir Goldstein
reviewerPATCH v3 15/20 fanotify: prepare for implicit event flags in mark mask
In reply to Amir GoldsteinSo far, all flags that can be set in an fanotify mark mask can be set explicitly by a call to fanotify_mark(2).
Prepare for defining implicit event flags that cannot be set by user with fanotify_mark(2), similar to how inotify/dnotify implicitly set the FS_EVENT_ON_CHILD flag.
Implicit event flags cannot be removed by user and mark gets destroyed when only implicit event flags remain in the mask.
--- fs/notify/fanotify/fanotify_user.c | 40 ++++++++++++++++++------------ 1 file changed, 24 insertions(+), 16 deletions(-)
fs/notify/fanotify/fanotify_user.c +24 -16
@@ -651,12 +651,13 @@ static int fanotify_find_path(int dfd, const char __user *filename, }static __u32 fanotify_mark_remove_from_mask (struct fsnotify_mark *fsn_mark, -__u32 mask, -unsigned int flags, -int *destroy) +__u32 mask,unsigned int flags, +__u32 umask,int *destroy) {__u32 oldmask =0 ; +/* umask bits cannot be removed by user */ + mask &= ~umask;spin_lock (&fsn_mark->lock);if (!(flags &FAN_MARK_IGNORED_MASK )) { oldmask = fsn_mark->mask;
@@ -664,7 +665,13 @@ static __u32 fanotify_mark_remove_from_mask(struct fsnotify_mark *fsn_mark, }else { fsn_mark->ignored_mask &= ~mask; } - *destroy = !(fsn_mark->mask | fsn_mark->ignored_mask); +/* +* We need to keep the mark around even if remaining mask cannot +* result in any events (e.g. mask == FAN_ONDIR) to support incremenal +* changes to the mask. +* Destroy mark when only umask bits remain. +*/ + *destroy = !((fsn_mark->mask | fsn_mark->ignored_mask) & ~umask);spin_unlock (&fsn_mark->lock);return mask & oldmask;
@@ -672,7 +679,7 @@ static __u32 fanotify_mark_remove_from_mask(struct fsnotify_mark *fsn_mark,static int fanotify_remove_mark (struct fsnotify_group *group,fsnotify_connp_t *connp,__u32 mask, -unsigned int flags) +unsigned int flags,__u32 umask) {struct fsnotify_mark *fsn_mark =NULL ;__u32 removed;
@@ -686,7 +693,7 @@ static int fanotify_remove_mark(struct fsnotify_group *group, } removed =fanotify_mark_remove_from_mask (fsn_mark, mask, flags, - &destroy_mark); + umask, &destroy_mark);if (removed &fsnotify_conn_mask (fsn_mark->connector))fsnotify_recalc_mask (fsn_mark->connector);if (destroy_mark)
@@ -702,25 +709,26 @@ static int fanotify_remove_mark(struct fsnotify_group *group,static int fanotify_remove_vfsmount_mark (struct fsnotify_group *group,struct vfsmount *mnt,__u32 mask, -unsigned int flags) +unsigned int flags,__u32 umask) {return fanotify_remove_mark (group, &real_mount (mnt)->mnt_fsnotify_marks, - mask, flags); + mask, flags, umask); }static int fanotify_remove_sb_mark (struct fsnotify_group *group, -struct super_block *sb,__u32 mask, -unsigned int flags) +struct super_block *sb,__u32 mask, +unsigned int flags,__u32 umask) { -return fanotify_remove_mark (group, &sb->s_fsnotify_marks, mask, flags); +return fanotify_remove_mark (group, &sb->s_fsnotify_marks, mask, + flags, umask); }static int fanotify_remove_inode_mark (struct fsnotify_group *group,struct inode *inode,__u32 mask, -unsigned int flags) +unsigned int flags,__u32 umask) {return fanotify_remove_mark (group, &inode->i_fsnotify_marks, mask, - flags); + flags, umask); } static __u32 fanotify_mark_add_to_mask(struct fsnotify_mark *fsn_mark,
@@ -1170,13 +1178,13 @@ static int do_fanotify_mark(int fanotify_fd, unsigned int flags, __u64 mask,case FAN_MARK_REMOVE :if (mark_type ==FAN_MARK_MOUNT ) ret =fanotify_remove_vfsmount_mark (group, mnt, mask, - flags); + flags,0 );else if (mark_type ==FAN_MARK_FILESYSTEM ) ret =fanotify_remove_sb_mark (group, mnt->mnt_sb, mask, - flags); + flags,0 );else ret =fanotify_remove_inode_mark (group, inode, mask, - flags); + flags,0 );break ;default : ret = -EINVAL ;
Signature · 1 line
2.17.1
Amir Goldstein
reviewerPATCH v3 16/20 fanotify: use FAN_EVENT_ON_CHILD as implicit flag on sb/mount/non-dir marks
In reply to Amir GoldsteinUp to now, fanotify allowed to set the FAN_EVENT_ON_CHILD flag on sb/mount marks and non-directory inode mask, but the flag was ignored.
Mask out the flag if it is provided by user on sb/mount/non-dir marks and define it as an implicit flag that cannot be removed by user.
This flag is going to be used internally to request for events with parent and name info.
--- fs/notify/fanotify/fanotify_user.c | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-)
fs/notify/fanotify/fanotify_user.c +10 -3
@@ -1045,6 +1045,7 @@ static int do_fanotify_mark(int fanotify_fd, unsigned int flags, __u64 mask,unsigned int mark_type = flags &FANOTIFY_MARK_TYPE_BITS ;bool ignored = flags &FAN_MARK_IGNORED_MASK ;unsigned int obj_type, fid_mode; +u32 umask =0 ;int ret; pr_debug("%s: fanotify_fd=%d flags=%x dfd=%d pathname=%p mask=%llx\n",
@@ -1162,6 +1163,12 @@ static int do_fanotify_mark(int fanotify_fd, unsigned int flags, __u64 mask,else mnt = path.mnt; +/* Mask out FAN_EVENT_ON_CHILD flag for sb/mount/non-dir marks */ +if (mnt || !S_ISDIR (inode->i_mode)) { + mask &= ~FAN_EVENT_ON_CHILD ; + umask =FAN_EVENT_ON_CHILD ; + } +/* create/update an inode mark */ switch (flags & (FAN_MARK_ADD |FAN_MARK_REMOVE )) {case FAN_MARK_ADD :
@@ -1178,13 +1185,13 @@ static int do_fanotify_mark(int fanotify_fd, unsigned int flags, __u64 mask,case FAN_MARK_REMOVE :if (mark_type ==FAN_MARK_MOUNT ) ret =fanotify_remove_vfsmount_mark (group, mnt, mask, - flags,0 ); + flags, umask);else if (mark_type ==FAN_MARK_FILESYSTEM ) ret =fanotify_remove_sb_mark (group, mnt->mnt_sb, mask, - flags,0 ); + flags, umask);else ret =fanotify_remove_inode_mark (group, inode, mask, - flags,0 ); + flags, umask);break ;default : ret = -EINVAL ;
Signature · 1 line
2.17.1
Amir Goldstein
reviewerPATCH v3 17/20 fanotify: remove event FAN_DIR_MODIFY
In reply to Amir GoldsteinIt was never enabled in uapi and its functionality is about to be superseded by events FAN_CREATE, FAN_DETELE, FAN_MOVE with group flag FAN_REPORT_NAME.
Keep a place holder variable name_event instead of removing the name recording code.
--- fs/notify/fanotify/fanotify.c | 9 ++------- fs/notify/fsnotify.c | 2 +- include/linux/fsnotify.h | 6 ------ include/linux/fsnotify_backend.h | 4 +--- include/uapi/linux/fanotify.h | 1 - 5 files changed, 4 insertions(+), 18 deletions(-)
fs/notify/fanotify/fanotify.c +2 -7
@@ -426,6 +426,7 @@ static struct fanotify_event *fanotify_alloc_event(struct fsnotify_group *group,struct inode *id =fanotify_fid_inode (mask, data, data_type, dir);const struct path *path =fsnotify_data_path (data, data_type);unsigned int fid_mode =FAN_GROUP_FLAG (group,FANOTIFY_FID_BITS ); +bool name_event = false;/* * For queues with unlimited length lost events are not expected and
@@ -443,12 +444,7 @@ static struct fanotify_event *fanotify_alloc_event(struct fsnotify_group *group,if (fanotify_is_perm_event (mask)) { event =fanotify_alloc_perm_event (path, gfp); - }else if (mask &FAN_DIR_MODIFY && !(WARN_ON_ONCE (!file_name))) { -/* -* For FAN_DIR_MODIFY event, we report the fid of the directory -* and the name of the modified entry. -* Allocate an fanotify_name_event struct and copy the name. -*/ + }else if (name_event && file_name) { event =fanotify_alloc_name_event (id, fsid, file_name, gfp); }else if (fid_mode) { event =fanotify_alloc_fid_event (id, fsid, gfp);
@@ -529,7 +525,6 @@ static int fanotify_handle_event(struct fsnotify_group *group, u32 mask,BUILD_BUG_ON (FAN_MOVED_FROM !=FS_MOVED_FROM );BUILD_BUG_ON (FAN_CREATE !=FS_CREATE );BUILD_BUG_ON (FAN_DELETE !=FS_DELETE ); -BUILD_BUG_ON (FAN_DIR_MODIFY !=FS_DIR_MODIFY );BUILD_BUG_ON (FAN_DELETE_SELF !=FS_DELETE_SELF );BUILD_BUG_ON (FAN_MOVE_SELF !=FS_MOVE_SELF );BUILD_BUG_ON (FAN_EVENT_ON_CHILD !=FS_EVENT_ON_CHILD );
fs/notify/fsnotify.c +1 -1
@@ -393,7 +393,7 @@ static __init int fsnotify_init(void) {int ret; -BUILD_BUG_ON (HWEIGHT32 (ALL_FSNOTIFY_BITS ) !=26 ); +BUILD_BUG_ON (HWEIGHT32 (ALL_FSNOTIFY_BITS ) !=25 ); ret =init_srcu_struct (&fsnotify_mark_srcu);if (ret)
include/linux/fsnotify.h +0 -6
@@ -30,12 +30,6 @@ static inline void fsnotify_name(struct inode *dir, __u32 mask, const struct qstr *name, u32 cookie) {fsnotify (dir ,mask ,child ,FSNOTIFY_EVENT_INODE ,name ,cookie ); -/* -* Send another flavor of the event without child inode data and -* without the specific event type (e.g. FS_CREATE|FS_IS_DIR). -* The name is relative to the dir inode the event is reported to. -*/ -fsnotify (dir,FS_DIR_MODIFY , dir,FSNOTIFY_EVENT_INODE , name,0 ); } static inline void fsnotify_dirent(struct inode *dir, struct dentry *dentry,
include/linux/fsnotify_backend.h +1 -3
@@ -47,7 +47,6 @@#define FS_OPEN_PERM 0x00010000/* open event in an permission hook */ #define FS_ACCESS_PERM 0x00020000/* access event in a permissions hook */ #define FS_OPEN_EXEC_PERM 0x00040000/* open/exec event in a permission hook */ -#define FS_DIR_MODIFY 0x00080000/* Directory entry was modified */ #define FS_EXCL_UNLINK 0x04000000/* do not send events if object is unlinked */ /* This inode cares about things that happen to its children. Always set for
@@ -67,8 +66,7 @@* The watching parent may get an FS_ATTRIB|FS_EVENT_ON_CHILD event * when a directory entry inside a child subdir changes. */ -#define ALL_FSNOTIFY_DIRENT_EVENTS (FS_CREATE | FS_DELETE | FS_MOVE | \ - FS_DIR_MODIFY) +#define ALL_FSNOTIFY_DIRENT_EVENTS (FS_CREATE | FS_DELETE | FS_MOVE)#define ALL_FSNOTIFY_PERM_EVENTS (FS_OPEN_PERM | FS_ACCESS_PERM | \ FS_OPEN_EXEC_PERM)
include/uapi/linux/fanotify.h +0 -1
@@ -24,7 +24,6 @@#define FAN_OPEN_PERM 0x00010000/* File open in perm check */ #define FAN_ACCESS_PERM 0x00020000/* File accessed in perm check */ #define FAN_OPEN_EXEC_PERM 0x00040000/* File open/exec in perm check */ -#define FAN_DIR_MODIFY 0x00080000/* Directory entry was modified */ #define FAN_EVENT_ON_CHILD 0x08000000/* Interested in child events */
Signature · 1 line
2.17.1
Amir Goldstein
reviewerPATCH v3 18/20 fsnotify: add object type "child" to object type iterator
In reply to Amir GoldsteinThe object type iterator is used to collect all the marks of a specific group that have interest in an event.
It is used by fanotify to get a single handle_event callback when an event has a match to either of inode/sb/mount marks of the group.
The nature of fsnotify events is that they are associated with at most one sb at most one mount and at most one inode.
When a parent and child are both watching, two events are sent to backend, one associated to parent inode and one associated to the child inode.
This results in duplicate events in fanotify, which usually get merged before user reads them, but this is sub-optimal.
It would be better if the same event is sent to backend with an object type iterator that has both the child inode and its parent, and let the backend decide if the event should be reported once (fanotify) or twice (inotify).
--- include/linux/fsnotify_backend.h | 3 +++ 1 file changed, 3 insertions(+)
include/linux/fsnotify_backend.h +3 -0
@@ -255,6 +255,7 @@ static inline const struct path *fsnotify_data_path(const void *data,enum fsnotify_obj_type {FSNOTIFY_OBJ_TYPE_INODE , +FSNOTIFY_OBJ_TYPE_CHILD ,FSNOTIFY_OBJ_TYPE_VFSMOUNT ,FSNOTIFY_OBJ_TYPE_SB ,FSNOTIFY_OBJ_TYPE_COUNT ,
@@ -262,6 +263,7 @@ enum fsnotify_obj_type { };#define FSNOTIFY_OBJ_TYPE_INODE_FL (1U << FSNOTIFY_OBJ_TYPE_INODE) +#define FSNOTIFY_OBJ_TYPE_CHILD_FL (1U << FSNOTIFY_OBJ_TYPE_CHILD)#define FSNOTIFY_OBJ_TYPE_VFSMOUNT_FL (1U << FSNOTIFY_OBJ_TYPE_VFSMOUNT)#define FSNOTIFY_OBJ_TYPE_SB_FL (1U << FSNOTIFY_OBJ_TYPE_SB)#define FSNOTIFY_OBJ_ALL_TYPES_MASK ((1U << FSNOTIFY_OBJ_TYPE_COUNT) - 1)
@@ -306,6 +308,7 @@ static inline struct fsnotify_mark *fsnotify_iter_##name##_mark( \ } FSNOTIFY_ITER_FUNCS(inode, INODE) +FSNOTIFY_ITER_FUNCS(child, CHILD) FSNOTIFY_ITER_FUNCS(vfsmount, VFSMOUNT)FSNOTIFY_ITER_FUNCS (sb,SB )
Signature · 1 line
2.17.1
Amir Goldstein
reviewerPATCH v3 19/20 fanotify: use struct fanotify_info to parcel the variable size buffer
In reply to Amir GoldsteinAn fanotify event name is always recorded relative to a dir fh. Encapsulate the name_len member of fanotify_name_event in a new struct fanotify_info, which describes the parceling of the variable size buffer of an fanotify_name_event.
The dir_fh member of fanotify_name_event is renamed to _dir_fh and is not accessed directly, but via the fanotify_info_dir_fh() accessor. Although the dir_fh len information is already available in struct fanotify_fh, we store it also in dif_fh_totlen member of fanotify_info, including the size of fanotify_fh header, so we know the offset of the name in the buffer without looking inside the dir_fh.
We also add a file_fh_totlen member to allow packing another file handle in the variable size buffer after the dir_fh and before the name. We are going to use that space to store the child fid.
--- fs/notify/fanotify/fanotify.c | 66 ++++++++++++++++------ fs/notify/fanotify/fanotify.h | 91 +++++++++++++++++++++++++----- fs/notify/fanotify/fanotify_user.c | 25 ++++---- 3 files changed, 139 insertions(+), 43 deletions(-)
fs/notify/fanotify/fanotify.c +50 -16
@@ -49,22 +49,44 @@ static bool fanotify_fid_event_equal(struct fanotify_fid_event *ffe1,fanotify_fh_equal (&ffe1->object_fh, &ffe2->object_fh); } +static bool fanotify_info_equal (struct fanotify_info *info1, +struct fanotify_info *info2) +{ +if (info1->dir_fh_totlen != info2->dir_fh_totlen || + info1->file_fh_totlen != info2->file_fh_totlen || + info1->name_len != info2->name_len) +return false; + +if (info1->dir_fh_totlen && + !fanotify_fh_equal (fanotify_info_dir_fh (info1), +fanotify_info_dir_fh (info2))) +return false; + +if (info1->file_fh_totlen && + !fanotify_fh_equal (fanotify_info_file_fh (info1), +fanotify_info_file_fh (info2))) +return false; + +return !info1->name_len || + !memcmp (fanotify_info_name (info1),fanotify_info_name (info2), + info1->name_len); +} +static bool fanotify_name_event_equal (struct fanotify_name_event *fne1,struct fanotify_name_event *fne2) { -/* Do not merge name events without dir fh */ -if (!fne1->dir_fh.len) -return false; +struct fanotify_info *info1 = &fne1->info; +struct fanotify_info *info2 = &fne2->info; -if (fne1->name_len != fne2->name_len || - !fanotify_fh_equal (&fne1->dir_fh, &fne2->dir_fh)) +/* Do not merge name events without dir fh */ +if (!info1->dir_fh_totlen)return false; -return !memcmp (fne1->name, fne2->name, fne1->name_len); +return fanotify_info_equal (info1, info2); }static bool fanotify_should_merge (struct fsnotify_event *old_fsn, -struct fsnotify_event *new_fsn) +struct fsnotify_event *new_fsn) {struct fanotify_event *old, *new;
@@ -276,8 +298,14 @@ static u32 fanotify_group_event_mask(struct fsnotify_group *group,return test_mask & user_mask; } -static void fanotify_encode_fh (struct fanotify_fh *fh,struct inode *inode, -gfp_t gfp) +/* +* Encode fanotify_fh. +* +* Return total size of encoded fh including fanotify_fh header. +* Return 0 on failure to encode. +*/ +static int fanotify_encode_fh (struct fanotify_fh *fh,struct inode *inode, +gfp_t gfp) {int dwords, type, bytes =0 ;char *ext_buf =NULL ;
@@ -287,7 +315,7 @@ static void fanotify_encode_fh(struct fanotify_fh *fh, struct inode *inode, fh->type =FILEID_ROOT ; fh->len =0 ;if (!inode) -return ; +return 0 ; dwords =0 ; err = -ENOENT ;
@@ -315,7 +343,7 @@ static void fanotify_encode_fh(struct fanotify_fh *fh, struct inode *inode, fh->type = type; fh->len = bytes; -return ; +return FANOTIFY_FH_HDR_LEN + bytes; out_err: pr_warn_ratelimited("fanotify: failed to encode fid (type=%d, len=%d, err=%i)\n",
@@ -325,6 +353,7 @@ static void fanotify_encode_fh(struct fanotify_fh *fh, struct inode *inode,/* Report the event without a file identifier on encode error */ fh->type =FILEID_INVALID ; fh->len =0 ; +return 0 ; }/*
@@ -401,6 +430,8 @@ struct fanotify_event *fanotify_alloc_name_event(struct inode *id, gfp_t gfp) {struct fanotify_name_event *fne; +struct fanotify_info *info; +struct fanotify_fh *dfh; fne =kmalloc (sizeof (*fne) + file_name->len +1 , gfp);if (!fne)
@@ -408,9 +439,11 @@ struct fanotify_event *fanotify_alloc_name_event(struct inode *id, fne->fae.type =FANOTIFY_EVENT_TYPE_FID_NAME ; fne->fsid = *fsid; -fanotify_encode_fh (&fne->dir_fh, id, gfp); - fne->name_len = file_name->len; -strcpy (fne->name, file_name->name); + info = &fne->info; +fanotify_info_init (info); + dfh =fanotify_info_dir_fh (info); + info->dir_fh_totlen =fanotify_encode_fh (dfh, id, gfp); +fanotify_info_copy_name (info, file_name);return &fne->fae; }
@@ -626,9 +659,10 @@ static void fanotify_free_fid_event(struct fanotify_event *event)static void fanotify_free_name_event (struct fanotify_event *event) {struct fanotify_name_event *fne =FANOTIFY_NE (event); +struct fanotify_fh *dfh =fanotify_info_dir_fh (&fne->info); -if (fanotify_fh_has_ext_buf (&fne->dir_fh)) -kfree (fanotify_fh_ext_buf (&fne->dir_fh)); +if (fanotify_fh_has_ext_buf (dfh)) +kfree (fanotify_fh_ext_buf (dfh));kfree (fne); }
fs/notify/fanotify/fanotify.h +78 -13
136 lines not on this page · raw message
fs/notify/fanotify/fanotify_user.c +11 -14
@@ -66,19 +66,17 @@ static int fanotify_fid_info_len(int fh_len, int name_len)static int fanotify_event_info_len (struct fanotify_event *event) { -int info_len =0 ; +struct fanotify_info *info =fanotify_event_info (event); +int dir_fh_len =fanotify_event_dir_fh_len (event);int fh_len =fanotify_event_object_fh_len (event); +int info_len =0 ; + +if (dir_fh_len) + info_len +=fanotify_fid_info_len (dir_fh_len, info->name_len);if (fh_len) info_len +=fanotify_fid_info_len (fh_len,0 ); -if (fanotify_event_name_len (event)) { -struct fanotify_name_event *fne =FANOTIFY_NE (event); - - info_len +=fanotify_fid_info_len (fne->dir_fh.len, - fne->name_len); - } -return info_len; }
@@ -305,6 +303,7 @@ static ssize_t copy_event_to_user(struct fsnotify_group *group, {struct fanotify_event_metadata metadata;struct path *path =fanotify_event_path (event); +struct fanotify_info *info =fanotify_event_info (event);struct file *f =NULL ;int ret, fd =FAN_NOFD ;
@@ -346,13 +345,11 @@ static ssize_t copy_event_to_user(struct fsnotify_group *group,fd_install (fd, f);/* Event info records order is: dir fid + name, child fid */ -if (fanotify_event_name_len (event)) { -struct fanotify_name_event *fne =FANOTIFY_NE (event); - +if (fanotify_event_dir_fh_len (event)) { ret =copy_info_to_user (fanotify_event_fsid (event), -fanotify_event_dir_fh (event), - fne->name, fne->name_len, - buf, count); +fanotify_info_dir_fh (info), +fanotify_info_name (info), + info->name_len, buf, count);if (ret <0 )return ret;
Signature · 1 line
2.17.1
Amir Goldstein
reviewerPATCH v3 20/20 fanotify: no external fh buffer in fanotify_name_event
In reply to Amir GoldsteinThe fanotify_fh struct has an inline buffer of size 12 which is enough to store the most common local filesystem file handles (e.g. ext4, xfs). For file handles that do not fit in the inline buffer (e.g. btrfs), an external buffer is allocated to store the file handle.
When allocating a variable size fanotify_name_event, there is no point in allocating also an external fh buffer when file handle does not fit in the inline buffer.
Check required size for encoding fh, preallocate an event buffer sufficient to contain both file handle and name and store the name after the file handle.
At this time, when not reporting name in event, we still allocate the fixed size fanotify_fid_event and an external buffer for large file handles, but fanotify_alloc_name_event() has already been prepared to accept a NULL file_name.
--- fs/notify/fanotify/fanotify.c | 68 +++++++++++++++++++++++++---------- fs/notify/fanotify/fanotify.h | 12 ++++--- 2 files changed, 57 insertions(+), 23 deletions(-)
fs/notify/fanotify/fanotify.c +50 -18
@@ -298,6 +298,24 @@ static u32 fanotify_group_event_mask(struct fsnotify_group *group,return test_mask & user_mask; } +/* +* Check size needed to encode fanotify_fh. +* +* Return size of encoded fh without fanotify_fh header. +* Return 0 on failure to encode. +*/ +static int fanotify_encode_fh_len (struct inode *inode) +{ +int dwords =0 ; + +if (!inode) +return 0 ; + +exportfs_encode_inode_fh (inode,NULL , &dwords,NULL ); + +return dwords <<2 ; +} +/* * Encode fanotify_fh. *
@@ -305,27 +323,34 @@ static u32 fanotify_group_event_mask(struct fsnotify_group *group,* Return 0 on failure to encode. */ static int fanotify_encode_fh (struct fanotify_fh *fh,struct inode *inode, -gfp_t gfp) +unsigned int fh_len,gfp_t gfp) { -int dwords, type, bytes =0 ; +int dwords, bytes, type =0 ;char *ext_buf =NULL ;void *buf = fh->buf;int err; fh->type =FILEID_ROOT ; fh->len =0 ; + fh->flags =0 ;if (!inode)return 0 ; - dwords =0 ; +/* +* !gpf means preallocated variable size fh, but fh_len could +* be zero in that case if encoding fh len failed. +*/ err = -ENOENT ; - type =exportfs_encode_inode_fh (inode,NULL , &dwords,NULL ); -if (!dwords) +if (!gfp) + bytes = fh_len; +else + bytes =fanotify_encode_fh_len (inode); +if (bytes <4 ||WARN_ON_ONCE (bytes %4 )) goto out_err; - bytes = dwords <<2 ; -if (bytes >FANOTIFY_INLINE_FH_LEN ) { -/* Treat failure to allocate fh as failure to allocate event */ +/* No external buffer in a variable size allocated fh */ +if (gfp && bytes >FANOTIFY_INLINE_FH_LEN ) { +/* Treat failure to allocate fh as failure to encode fh */ err = -ENOMEM ; ext_buf =kmalloc (bytes, gfp);if (!ext_buf)
@@ -333,8 +358,10 @@ static int fanotify_encode_fh(struct fanotify_fh *fh, struct inode *inode, *fanotify_fh_ext_buf_ptr (fh) = ext_buf; buf = ext_buf; + fh->flags |=FANOTIFY_FH_FLAG_EXT_BUF ; } + dwords = bytes >>2 ; type =exportfs_encode_inode_fh (inode, buf, &dwords,NULL ); err = -EINVAL ;if (!type || type ==FILEID_INVALID || bytes != dwords <<2 )
@@ -419,7 +446,7 @@ struct fanotify_event *fanotify_alloc_fid_event(struct inode *id, ffe->fae.type =FANOTIFY_EVENT_TYPE_FID ; ffe->fsid = *fsid; -fanotify_encode_fh (&ffe->object_fh, id, gfp); +fanotify_encode_fh (&ffe->object_fh, id,0 , gfp);return &ffe->fae; }
@@ -432,8 +459,13 @@ struct fanotify_event *fanotify_alloc_name_event(struct inode *id,struct fanotify_name_event *fne;struct fanotify_info *info;struct fanotify_fh *dfh; +unsigned int dir_fh_len =fanotify_encode_fh_len (id); +unsigned int size; - fne =kmalloc (sizeof (*fne) + file_name->len +1 , gfp); + size =sizeof (*fne) +FANOTIFY_FH_HDR_LEN + dir_fh_len; +if (file_name) + size += file_name->len +1 ; + fne =kmalloc (size, gfp);if (!fne)return NULL ;
@@ -442,8 +474,13 @@ struct fanotify_event *fanotify_alloc_name_event(struct inode *id, info = &fne->info;fanotify_info_init (info); dfh =fanotify_info_dir_fh (info); - info->dir_fh_totlen =fanotify_encode_fh (dfh, id, gfp); -fanotify_info_copy_name (info, file_name); + info->dir_fh_totlen =fanotify_encode_fh (dfh, id, dir_fh_len,0 ); +if (file_name) +fanotify_info_copy_name (info, file_name); + +pr_debug ("%s: ino=%lu size=%u dir_fh_len=%u name_len=%u name='%.*s'\n" , + __func__, id->i_ino, size, dir_fh_len, + info->name_len, info->name_len,fanotify_info_name (info));return &fne->fae; }
@@ -658,12 +695,7 @@ static void fanotify_free_fid_event(struct fanotify_event *event)static void fanotify_free_name_event (struct fanotify_event *event) { -struct fanotify_name_event *fne =FANOTIFY_NE (event); -struct fanotify_fh *dfh =fanotify_info_dir_fh (&fne->info); - -if (fanotify_fh_has_ext_buf (dfh)) -kfree (fanotify_fh_ext_buf (dfh)); -kfree (fne); +kfree (FANOTIFY_NE (event)); }static void fanotify_free_event (struct fsnotify_event *fsn_event)
fs/notify/fanotify/fanotify.h +7 -5
@@ -29,8 +29,10 @@ enum {struct fanotify_fh {u8 type;u8 len; -u8 pad[2 ]; -unsigned char buf[FANOTIFY_INLINE_FH_LEN ]; +#define FANOTIFY_FH_FLAG_EXT_BUF 1 +u8 flags; +u8 pad; +unsigned char buf[]; }__aligned(4) ;/* Variable size struct for dir file handle + child file handle + name */
@@ -50,7 +52,7 @@ struct fanotify_info {static inline bool fanotify_fh_has_ext_buf (struct fanotify_fh *fh) { -return fh->len >FANOTIFY_INLINE_FH_LEN ; +return (fh->flags &FANOTIFY_FH_FLAG_EXT_BUF ); }static inline char **fanotify_fh_ext_buf_ptr (struct fanotify_fh *fh)
@@ -154,6 +156,8 @@ struct fanotify_fid_event {struct fanotify_event fae;__kernel_fsid_t fsid;struct fanotify_fh object_fh; +/* Reserve space in object_fh.buf[] - access with fanotify_fh_buf() */ +unsigned char _inline_fh_buf[FANOTIFY_INLINE_FH_LEN ]; }; static inline struct fanotify_fid_event *
@@ -166,8 +170,6 @@ struct fanotify_name_event {struct fanotify_event fae;__kernel_fsid_t fsid;struct fanotify_info info; -/* Reserve space in info.buf[] - access with fanotify_info_dir_fh() */ -struct fanotify_fh _dir_fh; }; static inline struct fanotify_name_event *
Signature · 1 line
2.17.1
Jan Kara
maintainerRe: [PATCH v3 20/20] fanotify: no external fh buffer in fanotify_name_event
Quoted 13 lines · Amir Goldstein
The
fanotify_fhstruct has an inline buffer of size 12 which is enough to store the most common local filesystem file handles (e.g. ext4, xfs). For file handles that do not fit in the inline buffer (e.g. btrfs), an external buffer is allocated to store the file handle.When allocating a variable size
fanotify_name_event, there is no point in allocating also an external fh buffer when file handle does not fit in the inline buffer.Check required size for encoding fh, preallocate an event buffer sufficient to contain both file handle and name and store the name after the file handle.
Quoted 6 lines
At this time, when not reporting name in event, we still allocate the fixed size
fanotify_fid_eventand an external buffer for large file handles, butfanotify_alloc_name_event()has already been prepared to accept a NULLfile_name.Signed-off-by Amir Goldstein <[email protected]>
Just one tiny nit below:
Quoted 21 lines
fs/notify/fanotify/fanotify.c +4
-3@@ -305,27 +323,34 @@ static u32 fanotify_group_event_mask(struct fsnotify_group *group,* Return 0 on failure to encode. */ static int fanotify_encode_fh (struct fanotify_fh *fh,struct inode *inode, -gfp_t gfp) +unsigned int fh_len,gfp_t gfp) { -int dwords, type, bytes =0 ; +int dwords, bytes, type =0 ;char *ext_buf =NULL ;void *buf = fh->buf;int err; fh->type =FILEID_ROOT ; fh->len =0 ; + fh->flags =0 ;if (!inode)return 0 ; - dwords =0 ; +/*
fs/notify/fanotify/fanotify.c static u32 fanotify_group_event_mask(struct fsnotify_group *group, · line 347
Quoted 10 lines
fs/notify/fanotify/fanotify.c +7
-2+* !gpf means preallocated variable size fh, but fh_len could +* be zero in that case if encoding fh len failed. +*/ err = -ENOENT ; - type =exportfs_encode_inode_fh (inode,NULL , &dwords,NULL ); -if (!dwords) +if (!gfp) + bytes = fh_len; +else + bytes =fanotify_encode_fh_len (inode);
Any reason why proper fh len is not passed in by both callers? We could then get rid of this 'if' and 'bytes' variable.
Honza
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Amir Goldstein
reviewerRe: [PATCH v3 20/20] fanotify: no external fh buffer in fanotify_name_event
Quoted 43 lines · Jan Kara
Quoted 13 lines · Amir Goldstein
The
fanotify_fhstruct has an inline buffer of size 12 which is enough to store the most common local filesystem file handles (e.g. ext4, xfs). For file handles that do not fit in the inline buffer (e.g. btrfs), an external buffer is allocated to store the file handle.When allocating a variable size
fanotify_name_event, there is no point in allocating also an external fh buffer when file handle does not fit in the inline buffer.Check required size for encoding fh, preallocate an event buffer sufficient to contain both file handle and name and store the name after the file handle.
Quoted 6 lines
At this time, when not reporting name in event, we still allocate the fixed size
fanotify_fid_eventand an external buffer for large file handles, butfanotify_alloc_name_event()has already been prepared to accept a NULLfile_name.Signed-off-by Amir Goldstein <[email protected]>Just one tiny nit below:
Quoted 19 lines
fs/notify/fanotify/fanotify.c +3
-2@@ -305,27 +323,34 @@ static u32 fanotify_group_event_mask(struct fsnotify_group *group,* Return 0 on failure to encode. */ static int fanotify_encode_fh (struct fanotify_fh *fh,struct inode *inode, -gfp_t gfp) +unsigned int fh_len,gfp_t gfp) { -int dwords, type, bytes =0 ; +int dwords, bytes, type =0 ;char *ext_buf =NULL ;void *buf = fh->buf;int err; fh->type =FILEID_ROOT ; fh->len =0 ; + fh->flags =0 ;if (!inode)return 0 ;
Quoted 14 lines
fs/notify/fanotify/fanotify.c static u32 fanotify_group_event_mask(struct fsnotify_group *group, · line 347
Quoted 12 lines
fs/notify/fanotify/fanotify.c +8
-3- dwords =0 ; +/* +* !gpf means preallocated variable size fh, but fh_len could +* be zero in that case if encoding fh len failed. +*/ err = -ENOENT ; - type =exportfs_encode_inode_fh (inode,NULL , &dwords,NULL ); -if (!dwords) +if (!gfp) + bytes = fh_len; +else + bytes =fanotify_encode_fh_len (inode);Any reason why proper fh len is not passed in by both callers?
No good reason.
It's just how the function evolved and I missed this simplification.
Quoted 1 line
We could then get rid of this 'if' and 'bytes' variable.
Yap. sounds good.
I will test and push the branches.
Let me know if you want me to re-post anything.
Thanks,
Amir.
Amir Goldstein
reviewerRe: [PATCH v3 20/20] fanotify: no external fh buffer in fanotify_name_event
Quoted 11 lines
Quoted 1 line
Any reason why proper fh len is not passed in by both callers?
No good reason.
It's just how the function evolved and I missed this simplification.Quoted 1 line
We could then get rid of this 'if' and 'bytes' variable.
Yap. sounds good.
I will test and push the branches.
Let me know if you want me to re-post anything.
Pushed this nit fix to prep series branch fanotify_prep and complete tested series to branch fanotify_name_fid.
Thanks,
Amir.
Jan Kara
maintainerRe: [PATCH v3 20/20] fanotify: no external fh buffer in fanotify_name_event
In reply to Amir GoldsteinQuoted 59 lines · Amir Goldstein
Quoted 43 lines · Jan Kara
Quoted 13 lines · Amir Goldstein
The
fanotify_fhstruct has an inline buffer of size 12 which is enough to store the most common local filesystem file handles (e.g. ext4, xfs). For file handles that do not fit in the inline buffer (e.g. btrfs), an external buffer is allocated to store the file handle.When allocating a variable size
fanotify_name_event, there is no point in allocating also an external fh buffer when file handle does not fit in the inline buffer.Check required size for encoding fh, preallocate an event buffer sufficient to contain both file handle and name and store the name after the file handle.
Quoted 6 lines
At this time, when not reporting name in event, we still allocate the fixed size
fanotify_fid_eventand an external buffer for large file handles, butfanotify_alloc_name_event()has already been prepared to accept a NULLfile_name.Signed-off-by Amir Goldstein <[email protected]>Just one tiny nit below:
Quoted 19 lines
fs/notify/fanotify/fanotify.c +3
-2@@ -305,27 +323,34 @@ static u32 fanotify_group_event_mask(struct fsnotify_group *group,* Return 0 on failure to encode. */ static int fanotify_encode_fh (struct fanotify_fh *fh,struct inode *inode, -gfp_t gfp) +unsigned int fh_len,gfp_t gfp) { -int dwords, type, bytes =0 ; +int dwords, bytes, type =0 ;char *ext_buf =NULL ;void *buf = fh->buf;int err; fh->type =FILEID_ROOT ; fh->len =0 ; + fh->flags =0 ;if (!inode)return 0 ;Quoted 14 lines
fs/notify/fanotify/fanotify.c static u32 fanotify_group_event_mask(struct fsnotify_group *group, · line 347
Quoted 12 lines
fs/notify/fanotify/fanotify.c +8
-3- dwords =0 ; +/* +* !gpf means preallocated variable size fh, but fh_len could +* be zero in that case if encoding fh len failed. +*/ err = -ENOENT ; - type =exportfs_encode_inode_fh (inode,NULL , &dwords,NULL ); -if (!dwords) +if (!gfp) + bytes = fh_len; +else + bytes =fanotify_encode_fh_len (inode);Any reason why proper fh len is not passed in by both callers?
Quoted 8 lines
No good reason.
It's just how the function evolved and I missed this simplification.Quoted 1 line
We could then get rid of this 'if' and 'bytes' variable.
Yap. sounds good.
I will test and push the branches.
Let me know if you want me to re-post anything.
So I've just picked up patches 1-9 (I took patches 8 and 9 from your git) and 17 to my fsnotify branch because they are completely stand-alone cleanups and I didn't see a reason to delay them further. All the other patches in this series look fine to me but I didn't pick them up yet because they are more tightly related to the name event series and could possibly change. So I'll pick them up once I feel name event series is more stable...
Honza
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Amir Goldstein
reviewerRe: [PATCH v3 20/20] fanotify: no external fh buffer in fanotify_name_event
Quoted 4 lines
Quoted 3 lines
Yap. sounds good.
I will test and push the branches.
Let me know if you want me to re-post anything.
Quoted 8 lines
So I've just picked up patches 1-9 (I took patches 8 and 9 from your git) and 17 to my fsnotify branch because they are completely stand-alone cleanups and I didn't see a reason to delay them further. All the other patches in this series look fine to me but I didn't pick them up yet because they are more tightly related to the name event series and could possibly change. So I'll pick them up once I feel name event series is more stable...
Fair enough.
I rebased on top of your branch tested and pushed
fanotify_prep/fanotify_name_fid.
Thanks,
Amir.
Amir Goldstein
reviewerv3 cover Prep work for fanotify events with name info
In reply to Amir GoldsteinHi Jan,
Following patches address your review comments on v2 [1]. Branch is avalable at [2] and test branch of complete work of the moment is available at [3].
Thanks,
Amir.
Changes sinve v2:
- Re-parcel variable size buffer using struct fanotify_info
- Move space reservation of _inline_fh_buf to struct fanotify_fid_event
- Add Acks on kernfs patch
[1] https://lore.kernel.org/linux-fsdevel/[email protected]/
[2] https://github.com/amir73il/linux/commits/fanotify_prep-v3
[3] https://github.com/amir73il/linux/commits/fanotify_name_fid
Amir Goldstein (19):
fsnotify: fold fsnotify() call into fsnotify_parent()
fsnotify: return non const from fsnotify_data_inode()
nfsd: use fsnotify_data_inode() to get the unlinked inode
kernfs: do not call fsnotify() with name without a parent
inotify: do not use objectid when comparing events
fanotify: create overflow event type
fanotify: break up fanotify_alloc_event()
fsnotify: pass dir argument to handle_event() callback
fanotify: generalize the handling of extra event flags
fanotify: generalize merge logic of events on dir
fanotify: distinguish between fid encode error and null fid
fanotify: generalize test for FAN_REPORT_FID
fanotify: mask out special event flags from ignored mask
fanotify: prepare for implicit event flags in mark mask
fanotify: use FAN_EVENT_ON_CHILD as implicit flag on sb/mount/non-dir
marks
fanotify: remove event FAN_DIR_MODIFY
fsnotify: add object type "child" to object type iterator
fanotify: use struct fanotify_info to parcel the variable size buffer
fanotify: no external fh buffer in fanotify_name_event
Mel Gorman (1):
fsnotify: Rearrange fast path to minimise overhead when there is no
watcher
fs/kernfs/file.c | 2 +- fs/nfsd/filecache.c | 8 +- fs/notify/dnotify/dnotify.c | 8 +- fs/notify/fanotify/fanotify.c | 354 ++++++++++++++++----------- fs/notify/fanotify/fanotify.h | 110 +++++++-- fs/notify/fanotify/fanotify_user.c | 110 +++++---- fs/notify/fsnotify.c | 82 ++++--- fs/notify/inotify/inotify.h | 6 +- fs/notify/inotify/inotify_fsnotify.c | 11 +- fs/notify/inotify/inotify_user.c | 4 +- include/linux/fanotify.h | 6 +- include/linux/fsnotify.h | 43 ++-- include/linux/fsnotify_backend.h | 34 ++- include/uapi/linux/fanotify.h | 1 - kernel/audit_fsnotify.c | 10 +- kernel/audit_tree.c | 6 +- kernel/audit_watch.c | 6 +- 17 files changed, 500 insertions(+), 301 deletions(-)
Signature · 1 line
2.17.1