fanotify super block marks
Subsystems (3)
Amir Goldstein
reviewerv4 cover fanotify super block marks
Jan,
The following patches implement the new mark type FAN_MARK_FILESYSTEM to enable monitoring of filesystem events on all filesystem objects regardless of the mount where event was generated.
These patches are available on my github [1] along with LTP tests [2] and man-pages update [3].
Thanks,
Amir.
[1] https://github.com/amir73il/linux/commits/fanotify_sb
[2] https://github.com/amir73il/ltp/commits/fanotify_sb
[3] https://github.com/amir73il/man-pages/commits/fanotify_sb
Changes since v3:
- Rebase on top of ignore mask fix patch
- Address "semantic" review comments on FAN_MARK_FILESYSTEM flag
Changes since v2:
- Rebased on top of merged cleanup patches
- Show super block marks in fanotify_fdinfo()
- Add man pages patch [3]
Amir Goldstein (3):
fsnotify: add super block object type
fsnotify: send path type events to group with super block marks
fanotify: add API to attach/detach super block mark
fs/notify/fanotify/fanotify_user.c | 37 ++++++++++++++++++++++++++---- fs/notify/fdinfo.c | 5 ++++ fs/notify/fsnotify.c | 32 +++++++++++++++++--------- fs/notify/fsnotify.h | 11 +++++++++ fs/notify/mark.c | 4 ++++ fs/super.c | 2 +- include/linux/fs.h | 5 ++++ include/linux/fsnotify_backend.h | 17 +++++++++++--- include/uapi/linux/fanotify.h | 7 +++++- 9 files changed, 99 insertions(+), 21 deletions(-)
Signature · 1 line
2.17.1
Amir Goldstein
reviewerPATCH v4 1/3 fsnotify: add super block object type
Add the infrastructure to attach a mark to a super_block struct and detach all attached marks when super block is destroyed.
This is going to be used by fanotify backend to setup super block marks.
--- fs/notify/fdinfo.c | 5 +++++ fs/notify/fsnotify.c | 8 +++++++- fs/notify/fsnotify.h | 11 +++++++++++ fs/notify/mark.c | 4 ++++ fs/super.c | 2 +- include/linux/fs.h | 5 +++++ include/linux/fsnotify_backend.h | 17 ++++++++++++++--- 7 files changed, 47 insertions(+), 5 deletions(-)
fs/notify/fdinfo.c +5 -0
@@ -131,6 +131,11 @@ static void fanotify_fdinfo(struct seq_file *m, struct fsnotify_mark *mark)seq_printf (m,"fanotify mnt_id:%x mflags:%x mask:%x ignored_mask:%x\n" , mnt->mnt_id, mflags, mark->mask, mark->ignored_mask); + }else if (mark->connector->type ==FSNOTIFY_OBJ_TYPE_SB ) { +struct super_block *sb =fsnotify_conn_sb (mark->connector); + +seq_printf (m,"fanotify sdev:%x mflags:%x mask:%x ignored_mask:%x\n" , + sb->s_dev, mflags, mark->mask, mark->ignored_mask); } }
fs/notify/fsnotify.c +7 -1
@@ -48,7 +48,7 @@ void __fsnotify_vfsmount_delete(struct vfsmount *mnt)* Called during unmount with no locks held, so needs to be safe against * concurrent modifiers. We temporarily drop sb->s_inode_list_lock and CAN block. */ -void fsnotify_unmount_inodes (struct super_block *sb) +static void fsnotify_unmount_inodes (struct super_block *sb) {struct inode *inode, *iput_inode =NULL ;
@@ -98,6 +98,12 @@ void fsnotify_unmount_inodes(struct super_block *sb)iput (iput_inode); } +void fsnotify_sb_delete (struct super_block *sb) +{ +fsnotify_unmount_inodes (sb); +fsnotify_clear_marks_by_sb (sb); +} +/* * Given an inode, first check if we care what happens to our children. Inotify * and dnotify both tell their parents about events. If we care about any event
fs/notify/fsnotify.h +11 -0
@@ -21,6 +21,12 @@ static inline struct mount *fsnotify_conn_mount( return container_of(conn->obj, struct mount, mnt_fsnotify_marks); } +static inline struct super_block *fsnotify_conn_sb ( +struct fsnotify_mark_connector *conn) +{ + return container_of(conn->obj, struct super_block, s_fsnotify_marks); +} +/* destroy all events sitting in this groups notification queue */ extern void fsnotify_flush_notify (struct fsnotify_group *group);
@@ -43,6 +49,11 @@ static inline void fsnotify_clear_marks_by_mount(struct vfsmount *mnt) {fsnotify_destroy_marks (&real_mount (mnt)->mnt_fsnotify_marks); } +/* run the list of all marks associated with sb and destroy them */ +static inline void fsnotify_clear_marks_by_sb (struct super_block *sb) +{ +fsnotify_destroy_marks (&sb->s_fsnotify_marks); +}/* Wait until all marks queued for destruction are destroyed */ extern void fsnotify_wait_marks_destroyed (void );
fs/notify/mark.c +4 -0
@@ -115,6 +115,8 @@ static __u32 *fsnotify_conn_mask_p(struct fsnotify_mark_connector *conn)return &fsnotify_conn_inode (conn)->i_fsnotify_mask; else if (conn->type == FSNOTIFY_OBJ_TYPE_VFSMOUNT) return &fsnotify_conn_mount(conn)->mnt_fsnotify_mask; + else if (conn->type == FSNOTIFY_OBJ_TYPE_SB) + return &fsnotify_conn_sb(conn)->s_fsnotify_mask;return NULL ; }
@@ -192,6 +194,8 @@ static struct inode *fsnotify_detach_connector_from_object( inode->i_fsnotify_mask =0 ; }else if (conn->type ==FSNOTIFY_OBJ_TYPE_VFSMOUNT ) {fsnotify_conn_mount (conn)->mnt_fsnotify_mask =0 ; + }else if (conn->type ==FSNOTIFY_OBJ_TYPE_SB ) { +fsnotify_conn_sb (conn)->s_fsnotify_mask =0 ; }rcu_assign_pointer (*(conn->obj),NULL );
fs/super.c +1 -1
@@ -442,7 +442,7 @@ void generic_shutdown_super(struct super_block *sb)sync_filesystem (sb); sb->s_flags &= ~SB_ACTIVE ; -fsnotify_unmount_inodes (sb); +fsnotify_sb_delete (sb);cgroup_writeback_umount ();evict_inodes (sb);
include/linux/fs.h +5 -0
@@ -1464,6 +1464,11 @@ struct super_block {spinlock_t s_inode_wblist_lock;struct list_head s_inodes_wb;/* writeback inodes */ + +#ifdef CONFIG_FSNOTIFY +__u32 s_fsnotify_mask; +struct fsnotify_mark_connector __rcu *s_fsnotify_marks; +#endif } __randomize_layout;/* Helper functions so that in most cases filesystems will
include/linux/fsnotify_backend.h +14 -3
@@ -206,12 +206,14 @@ struct fsnotify_group {enum fsnotify_obj_type {FSNOTIFY_OBJ_TYPE_INODE ,FSNOTIFY_OBJ_TYPE_VFSMOUNT , +FSNOTIFY_OBJ_TYPE_SB ,FSNOTIFY_OBJ_TYPE_COUNT ,FSNOTIFY_OBJ_TYPE_DETACHED =FSNOTIFY_OBJ_TYPE_COUNT };#define FSNOTIFY_OBJ_TYPE_INODE_FL (1U << FSNOTIFY_OBJ_TYPE_INODE)#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)static inline bool fsnotify_valid_obj_type (unsigned int type)
@@ -255,6 +257,7 @@ static inline struct fsnotify_mark *fsnotify_iter_##name##_mark( \ FSNOTIFY_ITER_FUNCS(inode, INODE) FSNOTIFY_ITER_FUNCS(vfsmount, VFSMOUNT) +FSNOTIFY_ITER_FUNCS(sb, SB)#define fsnotify_foreach_obj_type (type) \ for (type = 0; type < FSNOTIFY_OBJ_TYPE_COUNT; type++)
@@ -267,8 +270,8 @@ struct fsnotify_mark_connector;typedef struct fsnotify_mark_connector __rcu *fsnotify_connp_t ;/* -* Inode / vfsmount point to this structure which tracks all marks attached to -* the inode / vfsmount. The reference to inode / vfsmount is held by this +* Inode/vfsmount/sb point to this structure which tracks all marks attached to +* the inode/vfsmount/sb. The reference to inode/vfsmount/sb is held by this * structure. We destroy this structure when there are no more marks attached * to it. The structure is protected by fsnotify_mark_srcu. */
@@ -335,6 +338,7 @@ extern int fsnotify(struct inode *to_tell, __u32 mask, const void *data, int datextern int __fsnotify_parent (const struct path *path,struct dentry *dentry,__u32 mask);extern void __fsnotify_inode_delete (struct inode *inode);extern void __fsnotify_vfsmount_delete (struct vfsmount *mnt); +extern void fsnotify_sb_delete (struct super_block *sb);extern u32 fsnotify_get_cookie (void );static inline int fsnotify_inode_watches_children (struct inode *inode)
@@ -455,9 +459,13 @@ static inline void fsnotify_clear_inode_marks_by_group(struct fsnotify_group *gr {fsnotify_clear_marks_by_group (group,FSNOTIFY_OBJ_TYPE_INODE_FL ); } +/* run all the marks in a group, and clear all of the sn marks */ +static inline void fsnotify_clear_sb_marks_by_group (struct fsnotify_group *group) +{ +fsnotify_clear_marks_by_group (group,FSNOTIFY_OBJ_TYPE_SB_FL ); +}extern void fsnotify_get_mark (struct fsnotify_mark *mark);extern void fsnotify_put_mark (struct fsnotify_mark *mark); -extern void fsnotify_unmount_inodes (struct super_block *sb);extern void fsnotify_finish_user_wait (struct fsnotify_iter_info *iter_info);extern bool fsnotify_prepare_user_wait (struct fsnotify_iter_info *iter_info);
@@ -484,6 +492,9 @@ static inline void __fsnotify_inode_delete(struct inode *inode)static inline void __fsnotify_vfsmount_delete (struct vfsmount *mnt) {} +static inline void fsnotify_sb_delete (struct super_block *sb) +{} +static inline void fsnotify_update_flags (struct dentry *dentry) {}
Signature · 1 line
2.17.1
Amir Goldstein
reviewerPATCH v4 2/3 fsnotify: send path type events to group with super block marks
In reply to Amir GoldsteinSend events to group if super block mark mask matches the event and unless the same group has an ignore mask on the vfsmount or the inode on which the event occurred.
Soon, fanotify backend is going to support super block marks and fanotify backend only supports path type events.
--- fs/notify/fsnotify.c | 24 ++++++++++++++---------- 1 file changed, 14 insertions(+), 10 deletions(-)
fs/notify/fsnotify.c +14 -10
@@ -325,15 +325,18 @@ int fsnotify(struct inode *to_tell, __u32 mask, const void *data, int data_is, const unsigned char *file_name, u32 cookie) {struct fsnotify_iter_info iter_info = {}; -struct mount *mnt; +struct super_block *sb =NULL ; +struct mount *mnt =NULL ; +__u32 mnt_or_sb_mask =0 ;int ret =0 ;/* global tests shouldn't care about events on child only the specific event */ __u32 test_mask = (mask & ~FS_EVENT_ON_CHILD ); -if (data_is ==FSNOTIFY_EVENT_PATH ) +if (data_is ==FSNOTIFY_EVENT_PATH ) { mnt =real_mount (((const struct path *)data)->mnt); -else - mnt =NULL ; + sb = mnt->mnt.mnt_sb; + mnt_or_sb_mask = mnt->mnt_fsnotify_mask | sb->s_fsnotify_mask; + }/* * Optimization: srcu_read_lock() has a memory barrier which can
@@ -343,16 +346,15 @@ int fsnotify(struct inode *to_tell, __u32 mask, const void *data, int data_is,* need SRCU to keep them "alive". */ if (!to_tell->i_fsnotify_marks && - (!mnt || !mnt->mnt_fsnotify_marks)) + (!mnt || (!mnt->mnt_fsnotify_marks && !sb->s_fsnotify_marks)))return 0 ;/* * if this is a modify event we may need to clear the ignored masks -* otherwise return if neither the inode nor the vfsmount care about +* 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 && test_mask & mnt->mnt_fsnotify_mask)) + !(test_mask & (to_tell->i_fsnotify_mask | mnt_or_sb_mask)))return 0 ; iter_info.srcu_idx =srcu_read_lock (&fsnotify_mark_srcu);
@@ -362,11 +364,13 @@ int fsnotify(struct inode *to_tell, __u32 mask, const void *data, int data_is,if (mnt) { iter_info.marks[FSNOTIFY_OBJ_TYPE_VFSMOUNT ] =fsnotify_first_mark (&mnt->mnt_fsnotify_marks); + iter_info.marks[FSNOTIFY_OBJ_TYPE_SB ] = +fsnotify_first_mark (&sb->s_fsnotify_marks); }/* -* We need to merge inode & vfsmount mark lists so that inode mark -* ignore masks are properly reflected for mount mark notifications. +* We need to merge inode/vfsmount/sb mark lists so that e.g. inode mark +* ignore masks are properly reflected for mount/sb mark notifications. * That's why this traversal is so complicated... */ while (fsnotify_iter_select_report_types (&iter_info)) {
Signature · 1 line
2.17.1
Amir Goldstein
reviewerPATCH v4 3/3 fanotify: add API to attach/detach super block mark
In reply to Amir GoldsteinAdd another mark type flag FAN_MARK_FILESYSTEM for add/remove/flush of super block mark type.
A super block watch gets all events on the filesystem, regardless of the mount from which the mark was added, unless an ignore mask exists on either the inode or the mount where the event was generated.
Only one of FAN_MARK_MOUNT and FAN_MARK_FILESYSTEM mark type flags may be provided to fanotify_mark() or no mark type flag for inode mark.
--- fs/notify/fanotify/fanotify_user.c | 42 ++++++++++++++++++++++++++---- include/uapi/linux/fanotify.h | 12 ++++++--- 2 files changed, 46 insertions(+), 8 deletions(-)
fs/notify/fanotify/fanotify_user.c +37 -5
@@ -563,6 +563,13 @@ static int fanotify_remove_vfsmount_mark(struct fsnotify_group *group, mask, flags); } +static int fanotify_remove_sb_mark (struct fsnotify_group *group, +struct super_block *sb,__u32 mask, +unsigned int flags) +{ +return fanotify_remove_mark (group, &sb->s_fsnotify_marks, mask, flags); +} +static int fanotify_remove_inode_mark (struct fsnotify_group *group,struct inode *inode,__u32 mask,unsigned int flags)
@@ -658,6 +665,14 @@ static int fanotify_add_vfsmount_mark(struct fsnotify_group *group, FSNOTIFY_OBJ_TYPE_VFSMOUNT, mask, flags); } +static int fanotify_add_sb_mark (struct fsnotify_group *group, +struct super_block *sb,__u32 mask, +unsigned int flags) +{ +return fanotify_add_mark (group, &sb->s_fsnotify_marks, +FSNOTIFY_OBJ_TYPE_SB , mask, flags); +} +static int fanotify_add_inode_mark (struct fsnotify_group *group,struct inode *inode,__u32 mask,unsigned int flags)
@@ -806,6 +821,7 @@ static int do_fanotify_mark(int fanotify_fd, unsigned int flags, __u64 mask,struct fd f;struct path path;u32 valid_mask =FAN_ALL_EVENTS |FAN_EVENT_ON_CHILD ; +unsigned int mark_type = flags &FAN_MARK_TYPE_MASK ;int ret; pr_debug("%s: fanotify_fd=%d flags=%x dfd=%d pathname=%p mask=%llx\n",
@@ -817,6 +833,16 @@ static int do_fanotify_mark(int fanotify_fd, unsigned int flags, __u64 mask,if (flags & ~FAN_ALL_MARK_FLAGS )return -EINVAL ; + +switch (mark_type) { +case FAN_MARK_INODE : +case FAN_MARK_MOUNT : +case FAN_MARK_FILESYSTEM : +break ; +default : +return -EINVAL ; + } +switch (flags & (FAN_MARK_ADD |FAN_MARK_REMOVE |FAN_MARK_FLUSH )) {case FAN_MARK_ADD :/* fallthrough */ case FAN_MARK_REMOVE :
@@ -824,7 +850,7 @@ static int do_fanotify_mark(int fanotify_fd, unsigned int flags, __u64 mask,return -EINVAL ;break ;case FAN_MARK_FLUSH : -if (flags & ~(FAN_MARK_MOUNT |FAN_MARK_FLUSH )) +if (flags & ~(FAN_MARK_TYPE_MASK |FAN_MARK_FLUSH ))return -EINVAL ;break ;default :
@@ -863,8 +889,10 @@ static int do_fanotify_mark(int fanotify_fd, unsigned int flags, __u64 mask,if (flags &FAN_MARK_FLUSH ) { ret =0 ; -if (flags &FAN_MARK_MOUNT ) +if (mark_type ==FAN_MARK_MOUNT )fsnotify_clear_vfsmount_marks_by_group (group); +else if (mark_type ==FAN_MARK_FILESYSTEM ) +fsnotify_clear_sb_marks_by_group (group);else fsnotify_clear_inode_marks_by_group (group); goto fput_and_out;
@@ -875,7 +903,7 @@ static int do_fanotify_mark(int fanotify_fd, unsigned int flags, __u64 mask, goto fput_and_out;/* inode held in place by reference to path; group by fget on fd */ -if (!(flags &FAN_MARK_MOUNT )) +if (mark_type ==FAN_MARK_INODE ) inode = path.dentry->d_inode;else mnt = path.mnt;
@@ -883,14 +911,18 @@ static int do_fanotify_mark(int fanotify_fd, unsigned int flags, __u64 mask,/* create/update an inode mark */ switch (flags & (FAN_MARK_ADD |FAN_MARK_REMOVE )) {case FAN_MARK_ADD : -if (flags &FAN_MARK_MOUNT ) +if (mark_type ==FAN_MARK_MOUNT ) ret =fanotify_add_vfsmount_mark (group, mnt, mask, flags); +else if (mark_type ==FAN_MARK_FILESYSTEM ) + ret =fanotify_add_sb_mark (group, mnt->mnt_sb, mask, flags);else ret =fanotify_add_inode_mark (group, inode, mask, flags);break ;case FAN_MARK_REMOVE : -if (flags &FAN_MARK_MOUNT ) +if (mark_type ==FAN_MARK_MOUNT ) ret =fanotify_remove_vfsmount_mark (group, mnt, mask, flags); +else if (mark_type ==FAN_MARK_FILESYSTEM ) + ret =fanotify_remove_sb_mark (group, mnt->mnt_sb, mask, flags);else ret =fanotify_remove_inode_mark (group, inode, mask, flags);break ;
include/uapi/linux/fanotify.h +9 -3
@@ -47,19 +47,25 @@#define FAN_MARK_REMOVE 0x00000002#define FAN_MARK_DONT_FOLLOW 0x00000004#define FAN_MARK_ONLYDIR 0x00000008 -#define FAN_MARK_MOUNT 0x00000010#define FAN_MARK_IGNORED_MASK 0x00000020#define FAN_MARK_IGNORED_SURV_MODIFY 0x00000040#define FAN_MARK_FLUSH 0x00000080 +/* These are NOT bitwise flags. Both bits can be used togther. */ +#define FAN_MARK_INODE 0x00000000 +#define FAN_MARK_MOUNT 0x00000010 +#define FAN_MARK_FILESYSTEM 0x00000100 +#define FAN_MARK_TYPE_MASK (FAN_MARK_INODE | FAN_MARK_MOUNT | \ + FAN_MARK_FILESYSTEM) +#define FAN_ALL_MARK_FLAGS (FAN_MARK_ADD |\ FAN_MARK_REMOVE |\ FAN_MARK_DONT_FOLLOW |\ FAN_MARK_ONLYDIR |\ - FAN_MARK_MOUNT |\ FAN_MARK_IGNORED_MASK |\ FAN_MARK_IGNORED_SURV_MODIFY |\ - FAN_MARK_FLUSH) + FAN_MARK_FLUSH|\ + FAN_MARK_TYPE_MASK)/* * All of the events - we build the list by hand so that we can add flags in
Signature · 1 line
2.17.1
Jan Kara
maintainerHi Amir!
Quoted 6 lines · Amir Goldstein
The following patches implement the new mark type
FAN_MARK_FILESYSTEMto enable monitoring of filesystem events on all filesystem objects regardless of the mount where event was generated.These patches are available on my github [1] along with LTP tests [2] and man-pages update [3].
Thanks for the patches! I've queued them up to my tree for the next merge window (will publish them as soon as LTP tests are finished). I've just fixed a typo in comment in patch 3 and added comments into holes in flags space in fanotify.h header.
Honza
Quoted 32 lines
[1] https://github.com/amir73il/linux/commits/fanotify_sb
[2] https://github.com/amir73il/ltp/commits/fanotify_sb
[3] https://github.com/amir73il/man-pages/commits/fanotify_sbChanges since v3:
- Rebase on top of ignore mask fix patch
- Address "semantic" review comments onFAN_MARK_FILESYSTEMflagChanges since v2:
- Rebased on top of merged cleanup patches
- Show super block marks infanotify_fdinfo()
- Add man pages patch [3]Amir Goldstein (3):
fsnotify: add super block object type
fsnotify: send path type events to group with super block marks
fanotify: add API to attach/detach super block markfs/notify/fanotify/fanotify_user.c | 37 ++++++++++++++++++++++++++---- fs/notify/fdinfo.c | 5 ++++ fs/notify/fsnotify.c | 32 +++++++++++++++++--------- fs/notify/fsnotify.h | 11 +++++++++ fs/notify/mark.c | 4 ++++ fs/super.c | 2 +- include/linux/fs.h | 5 ++++ include/linux/fsnotify_backend.h | 17 +++++++++++--- include/uapi/linux/fanotify.h | 7 +++++- 9 files changed, 99 insertions(+), 21 deletions(-)Signature · 1 line
2.17.1
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR