file system-wide error monitoring
Subsystems (9)
v9 cover file system-wide error monitoring
Hi,
This is the 9th version of this patch series. Thank you, Amir, Jan and Ted, for the feedback in the previous versions.
The main difference in this version is that the pool is no longer resizeable nor limited in number of marks, even though we only pre-allocate 32 slots. In addition, ext4 was modified to always return non-zero errno, and the documentation was fixed accordingly (No longer suggests we return EXT4_ERR* values.
I also droped the Reviewed-by tags from the ext4 patch, due to the changes above.
Please let me know what you think.
This was tested with LTP for regressions and also using the sample code on the last patch, with a corrupted image. I wrote a new ltp test for this feature which is being reviewed and is available at:
https://gitlab.collabora.com/krisman/ltp -b fan-fs-error
In addition, I wrote a man-page that can be pulled from:
https://gitlab.collabora.com/krisman/man-pages.git -b fan-fs-error
And is being reviewed at the list.
I also pushed this full series to:
https://gitlab.collabora.com/krisman/linux -b fanotify-notifications-v8
Thank you
Cc: Darrick J. Wong <[email protected]>
Cc: Theodore Ts'o <[email protected]>
Cc: Dave Chinner <[email protected]>
Cc: [email protected]
To: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Amir Goldstein (3):
fsnotify: pass data_type to fsnotify_name()
fsnotify: pass dentry instead of inode data
fsnotify: clarify contract for create event hooks
Gabriel Krisman Bertazi (28):
fsnotify: Don't insert unmergeable events in hashtable
fanotify: Fold event size calculation to its own function
fanotify: Split fsid check from other fid mode checks
inotify: Don't force FS_IN_IGNORED
fsnotify: Add helper to detect overflow_event
fsnotify: Add wrapper around fsnotify_add_event
fsnotify: Retrieve super block from the data field
fsnotify: Protect fsnotify_handle_inode_event from no-inode events
fsnotify: Pass group argument to free_event
fanotify: Support null inode event in fanotify_dfid_inode
fanotify: Allow file handle encoding for unhashed events
fanotify: Encode empty file handle when no inode is provided
fanotify: Require fid_mode for any non-fd event
fsnotify: Support FS_ERROR event type
fanotify: Reserve UAPI bits for FAN_FS_ERROR
fanotify: Pre-allocate pool of error events
fanotify: Support enqueueing of error events
fanotify: Support merging of error events
fanotify: Wrap object_fh inline space in a creator macro
fanotify: Add helpers to decide whether to report FID/DFID
fanotify: Report fid entry even for zero-length file_handle
fanotify: WARN_ON against too large file handles
fanotify: Report fid info for file related file system errors
fanotify: Emit generic error info for error event
fanotify: Allow users to request FAN_FS_ERROR events
ext4: Send notifications on error
samples: Add fs error monitoring example
docs: Document the FAN_FS_ERROR event
.../admin-guide/filesystem-monitoring.rst | 74 +++++++++ Documentation/admin-guide/index.rst | 1 + fs/ext4/super.c | 8 + fs/nfsd/filecache.c | 3 + fs/notify/fanotify/fanotify.c | 117 +++++++++++-- fs/notify/fanotify/fanotify.h | 54 +++++- fs/notify/fanotify/fanotify_user.c | 156 +++++++++++++----- fs/notify/fsnotify.c | 10 +- fs/notify/group.c | 2 +- fs/notify/inotify/inotify_fsnotify.c | 5 +- fs/notify/inotify/inotify_user.c | 6 +- fs/notify/notification.c | 14 +- include/linux/fanotify.h | 9 +- include/linux/fsnotify.h | 58 +++++-- include/linux/fsnotify_backend.h | 96 ++++++++++- include/uapi/linux/fanotify.h | 8 + kernel/audit_fsnotify.c | 3 +- kernel/audit_watch.c | 3 +- samples/Kconfig | 9 + samples/Makefile | 1 + samples/fanotify/Makefile | 5 + samples/fanotify/fs-monitor.c | 142 ++++++++++++++++ 22 files changed, 685 insertions(+), 99 deletions(-) create mode 100644 Documentation/admin-guide/filesystem-monitoring.rst create mode 100644 samples/fanotify/Makefile create mode 100644 samples/fanotify/fs-monitor.c
Signature · 1 line
2.33.0
PATCH v9 1/31 fsnotify: pass data_type to fsnotify_name()
From: Amir Goldstein <[email protected]>
Align the arguments of fsnotify_name() to those of fsnotify().
--- include/linux/fsnotify.h | 22 +++++++++++++--------- 1 file changed, 13 insertions(+), 9 deletions(-)
include/linux/fsnotify.h +13 -9
@@ -26,20 +26,21 @@* FS_EVENT_ON_CHILD mask on the parent inode and will not be reported if only * the child is interested and not the parent. */ -static inline void fsnotify_name (struct inode *dir,__u32 mask, -struct inode *child, -const struct qstr *name,u32 cookie) +static inline int fsnotify_name (__u32 mask,const void *data,int data_type, +struct inode *dir,const struct qstr *name, +u32 cookie) {if (atomic_long_read (&dir->i_sb->s_fsnotify_connectors) ==0 ) -return ; +return 0 ; -fsnotify (mask, child,FSNOTIFY_EVENT_INODE , dir, name,NULL , cookie); +return fsnotify (mask, data, data_type, dir, name,NULL , cookie); }static inline void fsnotify_dirent (struct inode *dir,struct dentry *dentry,__u32 mask) { -fsnotify_name (dir, mask,d_inode (dentry), &dentry->d_name,0 ); +fsnotify_name (mask,d_inode (dentry),FSNOTIFY_EVENT_INODE , + dir, &dentry->d_name,0 ); }static inline void fsnotify_inode (struct inode *inode,__u32 mask)
@@ -154,8 +155,10 @@ static inline void fsnotify_move(struct inode *old_dir, struct inode *new_dir, new_dir_mask |=FS_ISDIR ; } -fsnotify_name (old_dir, old_dir_mask, source, old_name, fs_cookie); -fsnotify_name (new_dir, new_dir_mask, source, new_name, fs_cookie); +fsnotify_name (old_dir_mask, source,FSNOTIFY_EVENT_INODE , + old_dir, old_name, fs_cookie); +fsnotify_name (new_dir_mask, source,FSNOTIFY_EVENT_INODE , + new_dir, new_name, fs_cookie);if (target)fsnotify_link_count (target);
@@ -209,7 +212,8 @@ static inline void fsnotify_link(struct inode *dir, struct inode *inode,fsnotify_link_count (inode);audit_inode_child (dir, new_dentry,AUDIT_TYPE_CHILD_CREATE ); -fsnotify_name (dir,FS_CREATE , inode, &new_dentry->d_name,0 ); +fsnotify_name (FS_CREATE , inode,FSNOTIFY_EVENT_INODE , + dir, &new_dentry->d_name,0 ); }/*
Signature · 1 line
2.33.0
PATCH v9 2/31 fsnotify: pass dentry instead of inode data
In reply to Gabriel Krisman BertaziFrom: Amir Goldstein <[email protected]>
Define a new data type to pass for event - FSNOTIFY_EVENT_DENTRY. Use it to pass the dentry instead of it's ->d_inode where available.
This is needed in preparation to the refactor to retrieve the super block from the data field. In some cases (i.e. mkdir in kernfs), the data inode comes from a negative dentry, such that no super block information would be available. By receiving the dentry itself, instead of the inode, fsnotify can derive the super block even on these cases.
---
Changes since v7:
- Improve commit message (Jan)
--- include/linux/fsnotify.h | 5 ++--- include/linux/fsnotify_backend.h | 16 ++++++++++++++++ 2 files changed, 18 insertions(+), 3 deletions(-)
include/linux/fsnotify.h +2 -3
@@ -39,8 +39,7 @@ static inline int fsnotify_name(__u32 mask, const void *data, int data_type,static inline void fsnotify_dirent (struct inode *dir,struct dentry *dentry,__u32 mask) { -fsnotify_name (mask,d_inode (dentry),FSNOTIFY_EVENT_INODE , - dir, &dentry->d_name,0 ); +fsnotify_name (mask, dentry,FSNOTIFY_EVENT_DENTRY , dir, &dentry->d_name,0 ); }static inline void fsnotify_inode (struct inode *inode,__u32 mask)
@@ -87,7 +86,7 @@ static inline int fsnotify_parent(struct dentry *dentry, __u32 mask,*/ static inline void fsnotify_dentry (struct dentry *dentry,__u32 mask) { -fsnotify_parent (dentry, mask,d_inode (dentry),FSNOTIFY_EVENT_INODE ); +fsnotify_parent (dentry, mask, dentry,FSNOTIFY_EVENT_DENTRY ); }static inline int fsnotify_file (struct file *file,__u32 mask)
include/linux/fsnotify_backend.h +16 -0
@@ -248,6 +248,7 @@ enum fsnotify_data_type {FSNOTIFY_EVENT_NONE ,FSNOTIFY_EVENT_PATH ,FSNOTIFY_EVENT_INODE , + FSNOTIFY_EVENT_DENTRY, };static inline struct inode *fsnotify_data_inode (const void *data,int data_type)
@@ -255,6 +256,8 @@ static inline struct inode *fsnotify_data_inode(const void *data, int data_type)switch (data_type) {case FSNOTIFY_EVENT_INODE :return (struct inode *)data; +case FSNOTIFY_EVENT_DENTRY : +return d_inode (data);case FSNOTIFY_EVENT_PATH :return d_inode (((const struct path *)data)->dentry);default :
@@ -262,6 +265,19 @@ static inline struct inode *fsnotify_data_inode(const void *data, int data_type) } } +static inline struct dentry *fsnotify_data_dentry (const void *data,int data_type) +{ +switch (data_type) { +case FSNOTIFY_EVENT_DENTRY : +/* Non const is needed for dget() */ +return (struct dentry *)data; +case FSNOTIFY_EVENT_PATH : +return ((const struct path *)data)->dentry; +default : +return NULL ; + } +} +static inline const struct path *fsnotify_data_path (const void *data,int data_type) {
Signature · 1 line
2.33.0
PATCH v9 3/31 fsnotify: clarify contract for create event hooks
In reply to Gabriel Krisman BertaziFrom: Amir Goldstein <[email protected]>
Clarify argument names and contract for fsnotify_create() and fsnotify_mkdir() to reflect the anomaly of kernfs, which leaves dentries negavite after mkdir/create.
Remove the WARN_ON(!inode) in audit code that were added by the Fixes commit under the wrong assumption that dentries cannot be negative after mkdir/create.
--- include/linux/fsnotify.h | 22 ++++++++++++++++------ kernel/audit_fsnotify.c | 3 +-- kernel/audit_watch.c | 3 +-- 3 files changed, 18 insertions(+), 10 deletions(-)
include/linux/fsnotify.h +16 -6
@@ -192,16 +192,22 @@ static inline void fsnotify_inoderemove(struct inode *inode)/* * fsnotify_create - 'name' was linked in +* +* Caller must make sure that dentry->d_name is stable. +* Note: some filesystems (e.g. kernfs) leave @dentry negative and instantiate +* ->d_inode later */ -static inline void fsnotify_create (struct inode *inode,struct dentry *dentry) +static inline void fsnotify_create (struct inode *dir,struct dentry *dentry) { -audit_inode_child (inode, dentry,AUDIT_TYPE_CHILD_CREATE ); +audit_inode_child (dir, dentry,AUDIT_TYPE_CHILD_CREATE ); -fsnotify_dirent (inode, dentry,FS_CREATE ); +fsnotify_dirent (dir, dentry,FS_CREATE ); }/* * fsnotify_link - new hardlink in 'inode' directory +* +* Caller must make sure that new_dentry->d_name is stable. * Note: We have to pass also the linked inode ptr as some filesystems leave * new_dentry->d_inode NULL and instantiate inode pointer later */
@@ -230,12 +236,16 @@ static inline void fsnotify_unlink(struct inode *dir, struct dentry *dentry)/* * fsnotify_mkdir - directory 'name' was created +* +* Caller must make sure that dentry->d_name is stable. +* Note: some filesystems (e.g. kernfs) leave @dentry negative and instantiate +* ->d_inode later */ -static inline void fsnotify_mkdir (struct inode *inode,struct dentry *dentry) +static inline void fsnotify_mkdir (struct inode *dir,struct dentry *dentry) { -audit_inode_child (inode, dentry,AUDIT_TYPE_CHILD_CREATE ); +audit_inode_child (dir, dentry,AUDIT_TYPE_CHILD_CREATE ); -fsnotify_dirent (inode, dentry,FS_CREATE |FS_ISDIR ); +fsnotify_dirent (dir, dentry,FS_CREATE |FS_ISDIR ); }/*
kernel/audit_fsnotify.c +1 -2
@@ -160,8 +160,7 @@ static int audit_mark_handle_event(struct fsnotify_mark *inode_mark, u32 mask, audit_mark = container_of(inode_mark, struct audit_fsnotify_mark, mark); -if (WARN_ON_ONCE (inode_mark->group != audit_fsnotify_group) || -WARN_ON_ONCE (!inode)) +if (WARN_ON_ONCE (inode_mark->group != audit_fsnotify_group))return 0 ;if (mask & (FS_CREATE |FS_MOVED_TO |FS_DELETE |FS_MOVED_FROM )) {
kernel/audit_watch.c +1 -2
@@ -472,8 +472,7 @@ static int audit_watch_handle_event(struct fsnotify_mark *inode_mark, u32 mask, parent = container_of(inode_mark, struct audit_parent, mark); -if (WARN_ON_ONCE (inode_mark->group != audit_watch_group) || -WARN_ON_ONCE (!inode)) +if (WARN_ON_ONCE (inode_mark->group != audit_watch_group))return 0 ;if (mask & (FS_CREATE |FS_MOVED_TO ) && inode)
Signature · 1 line
2.33.0
PATCH v9 4/31 fsnotify: Don't insert unmergeable events in hashtable
In reply to Gabriel Krisman BertaziSome events, like the overflow event, are not mergeable, so they are not hashed. But, when failing inside fsnotify_add_event for lack of space, fsnotify_add_event() still calls the insert hook, which adds the overflow event to the merge list. Add a check to prevent any kind of unmergeable event to be inserted in the hashtable.
---
Changes since v2:
- Do check for hashed events inside the insert hook (Amir)
--- fs/notify/fanotify/fanotify.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)
fs/notify/fanotify/fanotify.c +4 -2
@@ -702,6 +702,9 @@ static void fanotify_insert_event(struct fsnotify_group *group,assert_spin_locked (&group->notification_lock); +if (!fanotify_is_hashed_event (event->mask)) +return ; +pr_debug ("%s: group=%p event=%p bucket=%u\n" , __func__, group, event, bucket);
@@ -779,8 +782,7 @@ static int fanotify_handle_event(struct fsnotify_group *group, u32 mask, fsn_event = &event->fse; ret =fsnotify_add_event (group, fsn_event, fanotify_merge, -fanotify_is_hashed_event (mask) ? - fanotify_insert_event :NULL ); + fanotify_insert_event);if (ret) {/* Permission events shouldn't be merged */ BUG_ON (ret ==1 && mask &FANOTIFY_PERM_EVENTS );
Signature · 1 line
2.33.0
PATCH v9 5/31 fanotify: Fold event size calculation to its own function
In reply to Gabriel Krisman BertaziEvery time this function is invoked, it is immediately added to FAN_EVENT_METADATA_LEN, since there is no need to just calculate the length of info records. This minor clean up folds the rest of the calculation into the function, which now operates in terms of events, returning the size of the entire event, including metadata.
---
Changes since v6:
- Rebase on top of pidfd patches
Changes since v1:
- rebased on top of hashing patches
--- fs/notify/fanotify/fanotify_user.c | 35 +++++++++++++++++------------- 1 file changed, 20 insertions(+), 15 deletions(-)
fs/notify/fanotify/fanotify_user.c +20 -15
@@ -126,17 +126,24 @@ static int fanotify_fid_info_len(int fh_len, int name_len) FANOTIFY_EVENT_ALIGN); } -static int fanotify_event_info_len (unsigned int info_mode, -struct fanotify_event *event) +static size_t fanotify_event_len (unsigned int info_mode, +struct fanotify_event *event) { -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 ; +size_t event_len =FAN_EVENT_METADATA_LEN ; +struct fanotify_info *info; +int dir_fh_len; +int fh_len;int dot_len =0 ; +if (!info_mode) +return event_len; + + info =fanotify_event_info (event); + dir_fh_len =fanotify_event_dir_fh_len (event); + fh_len =fanotify_event_object_fh_len (event); +if (dir_fh_len) { - info_len +=fanotify_fid_info_len (dir_fh_len, info->name_len); + event_len +=fanotify_fid_info_len (dir_fh_len, info->name_len); }else if ((info_mode &FAN_REPORT_NAME ) && (event->mask &FAN_ONDIR )) {/*
@@ -147,12 +154,12 @@ static int fanotify_event_info_len(unsigned int info_mode, }if (info_mode &FAN_REPORT_PIDFD ) - info_len +=FANOTIFY_PIDFD_INFO_HDR_LEN ; + event_len +=FANOTIFY_PIDFD_INFO_HDR_LEN ;if (fh_len) - info_len +=fanotify_fid_info_len (fh_len, dot_len); + event_len +=fanotify_fid_info_len (fh_len, dot_len); -return info_len; +return event_len; }/*
@@ -181,7 +188,7 @@ static void fanotify_unhash_event(struct fsnotify_group *group,static struct fanotify_event *get_one_event (struct fsnotify_group *group,size_t count) { -size_t event_size =FAN_EVENT_METADATA_LEN ; +size_t event_size;struct fanotify_event *event =NULL ;struct fsnotify_event *fsn_event;unsigned int info_mode =FAN_GROUP_FLAG (group,FANOTIFY_INFO_MODES );
@@ -194,8 +201,7 @@ static struct fanotify_event *get_one_event(struct fsnotify_group *group, goto out; event =FANOTIFY_E (fsn_event); -if (info_mode) - event_size +=fanotify_event_info_len (info_mode, event); + event_size =fanotify_event_len (info_mode, event);if (event_size > count) { event =ERR_PTR (-EINVAL );
@@ -537,8 +543,7 @@ static ssize_t copy_event_to_user(struct fsnotify_group *group,pr_debug ("%s: group=%p event=%p\n" , __func__, group, event); - metadata.event_len =FAN_EVENT_METADATA_LEN + -fanotify_event_info_len (info_mode, event); + metadata.event_len =fanotify_event_len (info_mode, event); metadata.metadata_len =FAN_EVENT_METADATA_LEN ; metadata.vers =FANOTIFY_METADATA_VERSION ; metadata.reserved =0 ;
Signature · 1 line
2.33.0
PATCH v9 6/31 fanotify: Split fsid check from other fid mode checks
In reply to Gabriel Krisman BertaziFAN_FS_ERROR will require fsid, but not necessarily require the filesystem to expose a file handle. Split those checks into different functions, so they can be used separately when setting up an event.
While there, update a comment about tmpfs having 0 fsid, which is no longer true.
---
Changes since v2:
- FAN_ERROR -> FAN_FS_ERROR (Amir)
- Update comment (Amir)
Changes since v1:
(Amir)
- Sort hunks to simplify diff.
Changes since RFC:
(Amir)
- Rename fanotify_check_path_fsid -> fanotify_test_fsid.
- Use dentry directly instead of path.
--- fs/notify/fanotify/fanotify_user.c | 27 ++++++++++++++++++--------- 1 file changed, 18 insertions(+), 9 deletions(-)
fs/notify/fanotify/fanotify_user.c +18 -9
@@ -1300,16 +1300,15 @@ SYSCALL_DEFINE2(fanotify_init, unsigned int, flags, unsigned int, event_f_flags)return fd; } -/* Check if filesystem can encode a unique fid */ -static int fanotify_test_fid (struct path *path,__kernel_fsid_t *fsid) +static int fanotify_test_fsid (struct dentry *dentry,__kernel_fsid_t *fsid) {__kernel_fsid_t root_fsid;int err;/* -* Make sure path is not in filesystem with zero fsid (e.g. tmpfs). +* Make sure dentry is not of a filesystem with zero fsid (e.g. fuse). */ - err =vfs_get_fsid (path->dentry, fsid); + err =vfs_get_fsid (dentry, fsid);if (err)return err;
@@ -1317,10 +1316,10 @@ static int fanotify_test_fid(struct path *path, __kernel_fsid_t *fsid)return -ENODEV ;/* -* Make sure path is not inside a filesystem subvolume (e.g. btrfs) +* Make sure dentry is not of a filesystem subvolume (e.g. btrfs) * which uses a different fsid than sb root. */ - err =vfs_get_fsid (path->dentry->d_sb->s_root, &root_fsid); + err =vfs_get_fsid (dentry->d_sb->s_root, &root_fsid);if (err)return err;
@@ -1328,6 +1327,12 @@ static int fanotify_test_fid(struct path *path, __kernel_fsid_t *fsid) root_fsid.val[1] != fsid->val[1])return -EXDEV ; +return 0 ; +} + +/* Check if filesystem can encode a unique fid */ +static int fanotify_test_fid (struct dentry *dentry) +{/* * We need to make sure that the file system supports at least * encoding a file handle so user can use name_to_handle_at() to
@@ -1335,8 +1340,8 @@ static int fanotify_test_fid(struct path *path, __kernel_fsid_t *fsid)* objects. However, name_to_handle_at() requires that the * filesystem also supports decoding file handles. */ -if (!path->dentry->d_sb->s_export_op || - !path->dentry->d_sb->s_export_op->fh_to_dentry) +if (!dentry->d_sb->s_export_op || + !dentry->d_sb->s_export_op->fh_to_dentry)return -EOPNOTSUPP ;return 0 ;
@@ -1487,7 +1492,11 @@ static int do_fanotify_mark(int fanotify_fd, unsigned int flags, __u64 mask, }if (fid_mode) { - ret =fanotify_test_fid (&path, &__fsid); + ret =fanotify_test_fsid (path.dentry, &__fsid); +if (ret) + goto path_put_and_out; + + ret =fanotify_test_fid (path.dentry);if (ret) goto path_put_and_out;
Signature · 1 line
2.33.0
PATCH v9 7/31 inotify: Don't force FS_IN_IGNORED
In reply to Gabriel Krisman BertaziAccording to Amir:
"FS_IN_IGNORED is completely internal to inotify and there is no need to set it in i_fsnotify_mask at all, so if we remove the bit from the output of inotify_arg_to_mask() no functionality will change and we will be able to overload the event bit for FS_ERROR."
This is done in preparation to overload FS_ERROR with the notification mechanism in fanotify.
--- fs/notify/inotify/inotify_user.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
fs/notify/inotify/inotify_user.c +3 -3
@@ -94,10 +94,10 @@ static inline __u32 inotify_arg_to_mask(struct inode *inode, u32 arg)__u32 mask;/* -* Everything should accept their own ignored and should receive events -* when the inode is unmounted. All directories care about children. +* Everything should receive events when the inode is unmounted. +* All directories care about children. */ - mask = (FS_IN_IGNORED |FS_UNMOUNT ); + mask = (FS_UNMOUNT );if (S_ISDIR (inode->i_mode)) mask |=FS_EVENT_ON_CHILD ;
Signature · 1 line
2.33.0
PATCH v9 8/31 fsnotify: Add helper to detect overflow_event
In reply to Gabriel Krisman BertaziSimilarly to fanotify_is_perm_event and friends, provide a helper predicate to say whether a mask is of an overflow event.
--- fs/notify/fanotify/fanotify.h | 3 ++- include/linux/fsnotify_backend.h | 5 +++++ 2 files changed, 7 insertions(+), 1 deletion(-)
fs/notify/fanotify/fanotify.h +2 -1
@@ -315,7 +315,8 @@ static inline struct path *fanotify_event_path(struct fanotify_event *event)*/ static inline bool fanotify_is_hashed_event (u32 mask) { -return !fanotify_is_perm_event (mask) && !(mask &FS_Q_OVERFLOW ); +return !(fanotify_is_perm_event (mask) || +fsnotify_is_overflow_event (mask)); } static inline unsigned int fanotify_event_hash_bucket(
include/linux/fsnotify_backend.h +5 -0
@@ -510,6 +510,11 @@ static inline void fsnotify_queue_overflow(struct fsnotify_group *group)fsnotify_add_event (group, group->overflow_event,NULL ,NULL ); } +static inline bool fsnotify_is_overflow_event (u32 mask) +{ +return mask &FS_Q_OVERFLOW ; +} +static inline bool fsnotify_notify_queue_is_empty (struct fsnotify_group *group) {assert_spin_locked (&group->notification_lock);
Signature · 1 line
2.33.0
PATCH v9 9/31 fsnotify: Add wrapper around fsnotify_add_event
In reply to Gabriel Krisman Bertazifsnotify_add_event is growing in number of parameters, which in most case are just passed a NULL pointer. So, split out a new fsnotify_insert_event function to clean things up for users who don't need an insert hook.
--- fs/notify/fanotify/fanotify.c | 4 ++-- fs/notify/inotify/inotify_fsnotify.c | 2 +- fs/notify/notification.c | 12 ++++++------ include/linux/fsnotify_backend.h | 23 ++++++++++++++++------- 4 files changed, 25 insertions(+), 16 deletions(-)
fs/notify/fanotify/fanotify.c +2 -2
@@ -781,8 +781,8 @@ static int fanotify_handle_event(struct fsnotify_group *group, u32 mask, } fsn_event = &event->fse; - ret =fsnotify_add_event (group, fsn_event, fanotify_merge, - fanotify_insert_event); + ret =fsnotify_insert_event (group, fsn_event, fanotify_merge, + fanotify_insert_event);if (ret) {/* Permission events shouldn't be merged */ BUG_ON (ret ==1 && mask &FANOTIFY_PERM_EVENTS );
fs/notify/inotify/inotify_fsnotify.c +1 -1
@@ -116,7 +116,7 @@ int inotify_handle_inode_event(struct fsnotify_mark *inode_mark, u32 mask,if (len)strcpy (event->name, name->name); - ret =fsnotify_add_event (group, fsn_event, inotify_merge,NULL ); + ret =fsnotify_add_event (group, fsn_event, inotify_merge);if (ret) {/* Our event wasn't used in the end. Free it. */ fsnotify_destroy_event (group, fsn_event);
fs/notify/notification.c +6 -6
@@ -78,12 +78,12 @@ void fsnotify_destroy_event(struct fsnotify_group *group,* 2 if the event was not queued - either the queue of events has overflown * or the group is shutting down. */ -int fsnotify_add_event (struct fsnotify_group *group, -struct fsnotify_event *event, -int (*merge)(struct fsnotify_group *, -struct fsnotify_event *), -void (*insert)(struct fsnotify_group *, -struct fsnotify_event *)) +int fsnotify_insert_event (struct fsnotify_group *group, +struct fsnotify_event *event, +int (*merge)(struct fsnotify_group *, +struct fsnotify_event *), +void (*insert)(struct fsnotify_group *, +struct fsnotify_event *)) {int ret =0 ;struct list_head *list = &group->notification_list;
include/linux/fsnotify_backend.h +16 -7
@@ -498,16 +498,25 @@ extern int fsnotify_fasync(int fd, struct file *file, int on);extern void fsnotify_destroy_event (struct fsnotify_group *group,struct fsnotify_event *event);/* attach the event to the group notification queue */ -extern int fsnotify_add_event (struct fsnotify_group *group, -struct fsnotify_event *event, -int (*merge)(struct fsnotify_group *, -struct fsnotify_event *), -void (*insert)(struct fsnotify_group *, -struct fsnotify_event *)); +extern int fsnotify_insert_event (struct fsnotify_group *group, +struct fsnotify_event *event, +int (*merge)(struct fsnotify_group *, +struct fsnotify_event *), +void (*insert)(struct fsnotify_group *, +struct fsnotify_event *)); + +static inline int fsnotify_add_event (struct fsnotify_group *group, +struct fsnotify_event *event, +int (*merge)(struct fsnotify_group *, +struct fsnotify_event *)) +{ +return fsnotify_insert_event (group, event, merge,NULL ); +} +/* Queue overflow event to a notification group */ static inline void fsnotify_queue_overflow (struct fsnotify_group *group) { -fsnotify_add_event (group, group->overflow_event,NULL ,NULL ); +fsnotify_add_event (group, group->overflow_event,NULL ); }static inline bool fsnotify_is_overflow_event (u32 mask)
Signature · 1 line
2.33.0
PATCH v9 10/31 fsnotify: Retrieve super block from the data field
In reply to Gabriel Krisman BertaziSome file system events (i.e. FS_ERROR) might not be associated with an inode or directory. For these, we can retrieve the super block from the data field. But, since the super_block is available in the data field on every event type, simplify the code to always retrieve it from there, through a new helper.
--
Changes since v6:
- Always use data field for superblock retrieval
Changes since v5:
- add fsnotify_data_sb handle to retrieve sb from the data field. (jan)
--- fs/notify/fsnotify.c | 7 +++---- include/linux/fsnotify_backend.h | 15 +++++++++++++++ 2 files changed, 18 insertions(+), 4 deletions(-)
fs/notify/fsnotify.c +3 -4
@@ -455,16 +455,16 @@ static void fsnotify_iter_next(struct fsnotify_iter_info *iter_info)* @file_name is relative to * @file_name: optional file name associated with event * @inode: optional inode associated with event - -* either @dir or @inode must be non-NULL. -* if both are non-NULL event may be reported to both. +* If @dir and @inode are both non-NULL, event may be +* reported to both. * @cookie: inotify rename cookie */ int fsnotify (__u32 mask,const void *data,int data_type,struct inode *dir,const struct qstr *file_name,struct inode *inode,u32 cookie) {const struct path *path =fsnotify_data_path (data, data_type); +struct super_block *sb =fsnotify_data_sb (data, data_type);struct fsnotify_iter_info iter_info = {}; -struct super_block *sb;struct mount *mnt =NULL ;struct inode *parent =NULL ;int ret =0 ;
@@ -483,7 +483,6 @@ int fsnotify(__u32 mask, const void *data, int data_type, struct inode *dir,*/ parent = dir; } - sb = inode->i_sb;/* * Optimization: srcu_read_lock() has a memory barrier which can
include/linux/fsnotify_backend.h +15 -0
@@ -289,6 +289,21 @@ static inline const struct path *fsnotify_data_path(const void *data, } } +static inline struct super_block *fsnotify_data_sb (const void *data, +int data_type) +{ +switch (data_type) { +case FSNOTIFY_EVENT_INODE : +return ((struct inode *)data)->i_sb; +case FSNOTIFY_EVENT_DENTRY : +return ((struct dentry *)data)->d_sb; +case FSNOTIFY_EVENT_PATH : +return ((const struct path *)data)->dentry->d_sb; +default : +return NULL ; + } +} +enum fsnotify_obj_type {FSNOTIFY_OBJ_TYPE_INODE ,FSNOTIFY_OBJ_TYPE_PARENT ,
Signature · 1 line
2.33.0
PATCH v9 11/31 fsnotify: Protect fsnotify_handle_inode_event from no-inode events
In reply to Gabriel Krisman BertaziFAN_FS_ERROR allows events without inodes - i.e. for file system-wide errors. Even though fsnotify_handle_inode_event is not currently used by fanotify, this patch protects other backends from cases where neither inode or dir are provided. Also document the constraints of the interface (inode and dir cannot be both NULL).
---
Changes since v8:
- Convert verifications to WARN_ON
- Require either inode or dir
- Protect nfsd backend from !inode.
--- fs/nfsd/filecache.c | 3 +++ fs/notify/fsnotify.c | 3 +++ include/linux/fsnotify_backend.h | 1 + 3 files changed, 7 insertions(+)
fs/nfsd/filecache.c +3 -0
@@ -602,6 +602,9 @@ nfsd_file_fsnotify_handle_event(struct fsnotify_mark *mark, u32 mask, struct inode *inode, struct inode *dir, const struct qstr *name, u32 cookie) { + if (WARN_ON_ONCE(!inode)) + return 0; + trace_nfsd_file_fsnotify_handle_event(inode, mask);/* Should be no marks on non-regular files */
fs/notify/fsnotify.c +3 -0
@@ -252,6 +252,9 @@ static int fsnotify_handle_inode_event(struct fsnotify_group *group,if (WARN_ON_ONCE (!ops->handle_inode_event))return 0 ; +if (WARN_ON_ONCE (!inode && !dir)) +return 0 ; +if ((inode_mark->mask &FS_EXCL_UNLINK ) && path &&d_unlinked (path->dentry))return 0 ;
include/linux/fsnotify_backend.h +1 -0
@@ -136,6 +136,7 @@ struct mem_cgroup;* @dir: optional directory associated with event - * if @file_name is not NULL, this is the directory that * @file_name is relative to. +* Either @inode or @dir must be non-NULL. * @file_name: optional file name associated with event * @cookie: inotify rename cookie *
Signature · 1 line
2.33.0
Re: [PATCH v9 11/31] fsnotify: Protect fsnotify_handle_inode_event from no-inode events
Quoted 10 lines · Gabriel Krisman Bertazi
FAN_FS_ERRORallows events without inodes - i.e. for file system-wide errors. Even thoughfsnotify_handle_inode_eventis not currently used by fanotify, this patch protects other backends from cases where neither inode or dir are provided. Also document the constraints of the interface (inode and dir cannot be both NULL).Suggested-by Amir Goldstein <[email protected]>Signed-off-by Gabriel Krisman Bertazi <[email protected]>
Quoted 54 lines
---
Changes since v8:
- Convert verifications toWARN_ON
- Require either inode or dir
- Protect nfsd backend from !inode.--- fs/nfsd/filecache.c | 3 +++ fs/notify/fsnotify.c | 3 +++ include/linux/fsnotify_backend.h | 1 + 3 files changed, 7 insertions(+)fs/nfsd/filecache.c +3
-0@@ -602,6 +602,9 @@ nfsd_file_fsnotify_handle_event(struct fsnotify_mark *mark, u32 mask, struct inode *inode, struct inode *dir, const struct qstr *name, u32 cookie) { + if (WARN_ON_ONCE(!inode)) + return 0; + trace_nfsd_file_fsnotify_handle_event(inode, mask);/* Should be no marks on non-regular files */ fs/notify/fsnotify.c +3
-0@@ -252,6 +252,9 @@ static int fsnotify_handle_inode_event(struct fsnotify_group *group,if (WARN_ON_ONCE (!ops->handle_inode_event))return 0 ; +if (WARN_ON_ONCE (!inode && !dir)) +return 0 ; +if ((inode_mark->mask &FS_EXCL_UNLINK ) && path &&d_unlinked (path->dentry))return 0 ;include/linux/fsnotify_backend.h +1
-1@@ -136,6 +136,7 @@ struct mem_cgroup;* @dir: optional directory associated with event - * if @file_name is not NULL, this is the directory that * @file_name is relative to. +* Either @inode or @dir must be non-NULL. * @file_name: optional file name associated with event * @cookie: inotify rename cookie * -- 2.33.0
Re: [PATCH v9 11/31] fsnotify: Protect fsnotify_handle_inode_event from no-inode events
In reply to Gabriel Krisman BertaziQuoted 8 lines · Gabriel Krisman Bertazi
FAN_FS_ERRORallows events without inodes - i.e. for file system-wide errors. Even thoughfsnotify_handle_inode_eventis not currently used by fanotify, this patch protects other backends from cases where neither inode or dir are provided. Also document the constraints of the interface (inode and dir cannot be both NULL).Suggested-by Amir Goldstein <[email protected]>Signed-off-by Gabriel Krisman Bertazi <[email protected]>
Looks good. Feel free to add:
Honza
Quoted 55 lines
---
Changes since v8:
- Convert verifications toWARN_ON
- Require either inode or dir
- Protect nfsd backend from !inode.--- fs/nfsd/filecache.c | 3 +++ fs/notify/fsnotify.c | 3 +++ include/linux/fsnotify_backend.h | 1 + 3 files changed, 7 insertions(+)fs/nfsd/filecache.c +3
-0@@ -602,6 +602,9 @@ nfsd_file_fsnotify_handle_event(struct fsnotify_mark *mark, u32 mask, struct inode *inode, struct inode *dir, const struct qstr *name, u32 cookie) { + if (WARN_ON_ONCE(!inode)) + return 0; + trace_nfsd_file_fsnotify_handle_event(inode, mask);/* Should be no marks on non-regular files */ fs/notify/fsnotify.c +3
-0@@ -252,6 +252,9 @@ static int fsnotify_handle_inode_event(struct fsnotify_group *group,if (WARN_ON_ONCE (!ops->handle_inode_event))return 0 ; +if (WARN_ON_ONCE (!inode && !dir)) +return 0 ; +if ((inode_mark->mask &FS_EXCL_UNLINK ) && path &&d_unlinked (path->dentry))return 0 ;include/linux/fsnotify_backend.h +1
-0@@ -136,6 +136,7 @@ struct mem_cgroup;* @dir: optional directory associated with event - * if @file_name is not NULL, this is the directory that * @file_name is relative to. +* Either @inode or @dir must be non-NULL. * @file_name: optional file name associated with event * @cookie: inotify rename cookie * Signature · 1 line
2.33.0
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
PATCH v9 12/31 fsnotify: Pass group argument to free_event
In reply to Gabriel Krisman BertaziFor group-wide mempool backed events, like FS_ERROR, the free_event callback will need to reference the group's mempool to free the memory. Wire that argument into the current callers.
--- fs/notify/fanotify/fanotify.c | 3 ++- fs/notify/group.c | 2 +- fs/notify/inotify/inotify_fsnotify.c | 3 ++- fs/notify/notification.c | 2 +- include/linux/fsnotify_backend.h | 2 +- 5 files changed, 7 insertions(+), 5 deletions(-)
fs/notify/fanotify/fanotify.c +2 -1
@@ -835,7 +835,8 @@ static void fanotify_free_name_event(struct fanotify_event *event)kfree (FANOTIFY_NE (event)); } -static void fanotify_free_event (struct fsnotify_event *fsn_event) +static void fanotify_free_event (struct fsnotify_group *group, +struct fsnotify_event *fsn_event) {struct fanotify_event *event;
fs/notify/group.c +1 -1
@@ -88,7 +88,7 @@ void fsnotify_destroy_group(struct fsnotify_group *group)* that deliberately ignores overflow events. */ if (group->overflow_event) - group->ops->free_event (group->overflow_event); + group->ops->free_event (group, group->overflow_event);fsnotify_put_group (group); }
fs/notify/inotify/inotify_fsnotify.c +2 -1
@@ -177,7 +177,8 @@ static void inotify_free_group_priv(struct fsnotify_group *group)dec_inotify_instances (group->inotify_data.ucounts); } -static void inotify_free_event (struct fsnotify_event *fsn_event) +static void inotify_free_event (struct fsnotify_group *group, +struct fsnotify_event *fsn_event) {kfree (INOTIFY_E (fsn_event)); }
fs/notify/notification.c +1 -1
@@ -64,7 +64,7 @@ void fsnotify_destroy_event(struct fsnotify_group *group,WARN_ON (!list_empty (&event->list));spin_unlock (&group->notification_lock); } - group->ops->free_event (event); + group->ops->free_event (group, event); }/*
include/linux/fsnotify_backend.h +1 -1
@@ -156,7 +156,7 @@ struct fsnotify_ops { const struct qstr *file_name, u32 cookie);void (*free_group_priv)(struct fsnotify_group *group);void (*freeing_mark)(struct fsnotify_mark *mark,struct fsnotify_group *group); -void (*free_event)(struct fsnotify_event *event); +void (*free_event)(struct fsnotify_group *group,struct fsnotify_event *event);/* called on final put+free to free memory */ void (*free_mark)(struct fsnotify_mark *mark); };
Signature · 1 line
2.33.0
PATCH v9 13/31 fanotify: Support null inode event in fanotify_dfid_inode
In reply to Gabriel Krisman BertaziFAN_FS_ERROR doesn't support DFID, but this function is still called for every event. The problem is that it is not capable of handling null inodes, which now can happen in case of superblock error events. For this case, just returning dir will be enough.
--- fs/notify/fanotify/fanotify.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
fs/notify/fanotify/fanotify.c +1 -1
@@ -452,7 +452,7 @@ static struct inode *fanotify_dfid_inode(u32 event_mask, const void *data,if (event_mask &ALL_FSNOTIFY_DIRENT_EVENTS )return dir; -if (S_ISDIR (inode->i_mode)) +if (inode &&S_ISDIR (inode->i_mode))return inode;return dir;
Signature · 1 line
2.33.0
PATCH v9 14/31 fanotify: Allow file handle encoding for unhashed events
In reply to Gabriel Krisman BertaziAllow passing a NULL hash to fanotify_encode_fh and avoid calculating the hash if not needed.
--- fs/notify/fanotify/fanotify.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-)
fs/notify/fanotify/fanotify.c +6 -2
@@ -403,8 +403,12 @@ static int fanotify_encode_fh(struct fanotify_fh *fh, struct inode *inode, fh->type = type; fh->len = fh_len; -/* Mix fh into event merge key */ - *hash ^=fanotify_hash_fh (fh); +/* +* Mix fh into event merge key. Hash might be NULL in case of +* unhashed FID events (i.e. FAN_FS_ERROR). +*/ +if (hash) + *hash ^=fanotify_hash_fh (fh);return FANOTIFY_FH_HDR_LEN + fh_len;
Signature · 1 line
2.33.0
PATCH v9 15/31 fanotify: Encode empty file handle when no inode is provided
In reply to Gabriel Krisman BertaziInstead of failing, encode an invalid file handle in fanotify_encode_fh if no inode is provided. This bogus file handle will be reported by FAN_FS_ERROR for non-inode errors.
---
Changes since v6:
- Use FILEID_ROOT as the internal value (jan)
- Create an empty FH (jan)
Changes since v5:
- Preserve flags initialization (jan)
- Add BUILD_BUG_ON (amir)
- Require minimum of FANOTIFY_NULL_FH_LEN for fh_len(amir)
- Improve comment to explain the null FH length (jan)
- Simplify logic
--- fs/notify/fanotify/fanotify.c | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-)
fs/notify/fanotify/fanotify.c +8 -1
@@ -370,8 +370,14 @@ static int fanotify_encode_fh(struct fanotify_fh *fh, struct inode *inode, fh->type =FILEID_ROOT ; fh->len =0 ; fh->flags =0 ; + +/* +* Invalid FHs are used by FAN_FS_ERROR for errors not +* linked to any inode. The f_handle won't be reported +* back to userspace. +*/ if (!inode) -return 0 ; + goto out;/* * !gpf means preallocated variable size fh, but fh_len could
@@ -403,6 +409,7 @@ static int fanotify_encode_fh(struct fanotify_fh *fh, struct inode *inode, fh->type = type; fh->len = fh_len; +out:/* * Mix fh into event merge key. Hash might be NULL in case of * unhashed FID events (i.e. FAN_FS_ERROR).
Signature · 1 line
2.33.0
PATCH v9 16/31 fanotify: Require fid_mode for any non-fd event
In reply to Gabriel Krisman BertaziLike inode events, FAN_FS_ERROR will require fid mode. Therefore, convert the verification during fanotify_mark(2) to require fid for any non-fd event. This means fid_mode will not only be required for inode events, but for any event that doesn't provide a descriptor.
---
changes since v5:
- Fix condition to include FANOTIFY_EVENT_FLAGS. (me)
- Fix comment identation (jan)
--- fs/notify/fanotify/fanotify_user.c | 12 ++++++------ include/linux/fanotify.h | 3 +++ 2 files changed, 9 insertions(+), 6 deletions(-)
fs/notify/fanotify/fanotify_user.c +6 -6
@@ -1458,14 +1458,14 @@ static int do_fanotify_mark(int fanotify_fd, unsigned int flags, __u64 mask, goto fput_and_out;/* -* Events with data type inode do not carry enough information to report -* event->fd, so we do not allow setting a mask for inode events unless -* group supports reporting fid. -* 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. +* Events that do not carry enough information to report +* event->fd require a group that supports reporting fid. Those +* 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 && +if (mask & ~(FANOTIFY_FD_EVENTS |FANOTIFY_EVENT_FLAGS ) && (!fid_mode || mark_type ==FAN_MARK_MOUNT )) goto fput_and_out;
include/linux/fanotify.h +3 -0
@@ -84,6 +84,9 @@ extern struct ctl_table fanotify_table[]; /* for sysctl */*/ #define FANOTIFY_DIRENT_EVENTS (FAN_MOVE | FAN_CREATE | FAN_DELETE) +/* Events that can be reported with event->fd */ +#define FANOTIFY_FD_EVENTS (FANOTIFY_PATH_EVENTS | FANOTIFY_PERM_EVENTS) +/* Events that can only be reported with data type FSNOTIFY_EVENT_INODE */ #define FANOTIFY_INODE_EVENTS (FANOTIFY_DIRENT_EVENTS | \ FAN_ATTRIB | FAN_MOVE_SELF | FAN_DELETE_SELF)
Signature · 1 line
2.33.0
PATCH v9 17/31 fsnotify: Support FS_ERROR event type
In reply to Gabriel Krisman BertaziExpose a new type of fsnotify event for filesystems to report errors for userspace monitoring tools. fanotify will send this type of notification for FAN_FS_ERROR events. This also introduce a helper for generating the new event.
---
Changes since v6:
- Add fsnotify_data_error_report
Changes since v5:
- pass sb inside data field (jan)
Changes since v3:
- Squash patch ("fsnotify: Introduce helpers to send error_events")
- Drop reviewed-bys!
Changes since v2:
- FAN_ERROR->FAN_FS_ERROR (Amir)
Changes since v1:
- Overload FS_ERROR with FS_IN_IGNORED
- Implement support for this type on fsnotify_data_inode (Amir)
--- include/linux/fsnotify.h | 13 +++++++++++++ include/linux/fsnotify_backend.h | 32 +++++++++++++++++++++++++++++++- 2 files changed, 44 insertions(+), 1 deletion(-)
include/linux/fsnotify.h +13 -0
@@ -339,4 +339,17 @@ static inline void fsnotify_change(struct dentry *dentry, unsigned int ia_valid) fsnotify_dentry(dentry, mask); } +static inline int fsnotify_sb_error (struct super_block *sb,struct inode *inode, +int error) +{ +struct fs_error_report report = { + .error = error, + .inode = inode, + .sb = sb, + }; + +return fsnotify (FS_ERROR , &report,FSNOTIFY_EVENT_ERROR , +NULL ,NULL ,NULL ,0 ); +} +#endif /* _LINUX_FS_NOTIFY_H */
include/linux/fsnotify_backend.h +31 -1
@@ -42,6 +42,12 @@#define FS_UNMOUNT 0x00002000/* inode on umount fs */ #define FS_Q_OVERFLOW 0x00004000/* Event queued overflowed */ +#define FS_ERROR 0x00008000/* Filesystem Error (fanotify) */ + +/* +* FS_IN_IGNORED overloads FS_ERROR. It is only used internally by inotify +* which does not support FS_ERROR. +*/ #define FS_IN_IGNORED 0x00008000/* last inotify event here */ #define FS_OPEN_PERM 0x00010000/* open event in an permission hook */
@@ -95,7 +101,8 @@#define ALL_FSNOTIFY_EVENTS (ALL_FSNOTIFY_DIRENT_EVENTS | \ FS_EVENTS_POSS_ON_CHILD | \ FS_DELETE_SELF | FS_MOVE_SELF | FS_DN_RENAME | \ - FS_UNMOUNT | FS_Q_OVERFLOW | FS_IN_IGNORED) + FS_UNMOUNT | FS_Q_OVERFLOW | FS_IN_IGNORED | \ + FS_ERROR)/* Extra flags that may be reported with event or control handling of events */ #define ALL_FSNOTIFY_FLAGS (FS_EXCL_UNLINK | FS_ISDIR | FS_IN_ONESHOT | \
@@ -250,6 +257,13 @@ enum fsnotify_data_type {FSNOTIFY_EVENT_PATH ,FSNOTIFY_EVENT_INODE ,FSNOTIFY_EVENT_DENTRY , + FSNOTIFY_EVENT_ERROR, +}; + +struct fs_error_report { +int error; +struct inode *inode; +struct super_block *sb; };static inline struct inode *fsnotify_data_inode (const void *data,int data_type)
@@ -261,6 +275,8 @@ static inline struct inode *fsnotify_data_inode(const void *data, int data_type)return d_inode (data);case FSNOTIFY_EVENT_PATH :return d_inode (((const struct path *)data)->dentry); +case FSNOTIFY_EVENT_ERROR : +return ((struct fs_error_report *)data)->inode;default :return NULL ; }
@@ -300,6 +316,20 @@ static inline struct super_block *fsnotify_data_sb(const void *data,return ((struct dentry *)data)->d_sb;case FSNOTIFY_EVENT_PATH :return ((const struct path *)data)->dentry->d_sb; +case FSNOTIFY_EVENT_ERROR : +return ((struct fs_error_report *) data)->sb; +default : +return NULL ; + } +} + +static inline struct fs_error_report *fsnotify_data_error_report ( +const void *data, +int data_type) +{ +switch (data_type) { +case FSNOTIFY_EVENT_ERROR : +return (struct fs_error_report *) data;default :return NULL ; }
Signature · 1 line
2.33.0
PATCH v9 18/31 fanotify: Reserve UAPI bits for FAN_FS_ERROR
In reply to Gabriel Krisman BertaziFAN_FS_ERROR allows reporting of event type FS_ERROR to userspace, which is a mechanism to report file system wide problems via fanotify. This commit preallocate userspace visible bits to match the FS_ERROR event.
--- fs/notify/fanotify/fanotify.c | 1 + include/uapi/linux/fanotify.h | 1 + 2 files changed, 2 insertions(+)
fs/notify/fanotify/fanotify.c +1 -0
@@ -752,6 +752,7 @@ static int fanotify_handle_event(struct fsnotify_group *group, u32 mask,BUILD_BUG_ON (FAN_ONDIR !=FS_ISDIR );BUILD_BUG_ON (FAN_OPEN_EXEC !=FS_OPEN_EXEC );BUILD_BUG_ON (FAN_OPEN_EXEC_PERM !=FS_OPEN_EXEC_PERM ); +BUILD_BUG_ON (FAN_FS_ERROR !=FS_ERROR );BUILD_BUG_ON (HWEIGHT32 (ALL_FANOTIFY_EVENT_BITS ) !=19 );
include/uapi/linux/fanotify.h +1 -0
@@ -20,6 +20,7 @@#define FAN_OPEN_EXEC 0x00001000/* File was opened for exec */ #define FAN_Q_OVERFLOW 0x00004000/* Event queued overflowed */ +#define FAN_FS_ERROR 0x00008000/* Filesystem error */ #define FAN_OPEN_PERM 0x00010000/* File open in perm check */ #define FAN_ACCESS_PERM 0x00020000/* File accessed in perm check */
Signature · 1 line
2.33.0
PATCH v9 19/31 fanotify: Pre-allocate pool of error events
In reply to Gabriel Krisman BertaziPre-allocate slots for file system errors to have greater chances of succeeding, since error events can happen in GFP_NOFS context. This patch introduces a group-wide mempool of error events, shared by all FAN_FS_ERROR marks in this group.
For now, just allocate 128 positions. A future patch allows this array to be dynamically resized when a new mark is added.
---
Changes since v8:
- FANOTIFY_DEFAULT_MAX_FEE_POOL -> FANOTIFY_DEFAULT_FEE_POOL_SIZE
- Reduce limit to 32. (Jan)
Changes since v7:
- Expand limit to 128. (Amir)
--- fs/notify/fanotify/fanotify.c | 3 +++ fs/notify/fanotify/fanotify.h | 11 +++++++++++ fs/notify/fanotify/fanotify_user.c | 26 +++++++++++++++++++++++++- include/linux/fsnotify_backend.h | 2 ++ 4 files changed, 41 insertions(+), 1 deletion(-)
fs/notify/fanotify/fanotify.c +3 -0
@@ -819,6 +819,9 @@ static void fanotify_free_group_priv(struct fsnotify_group *group)if (group->fanotify_data.ucounts)dec_ucount (group->fanotify_data.ucounts,UCOUNT_FANOTIFY_GROUPS ); + +if (mempool_initialized (&group->fanotify_data.error_events_pool)) +mempool_exit (&group->fanotify_data.error_events_pool); }static void fanotify_free_path_event (struct fanotify_event *event)
fs/notify/fanotify/fanotify.h +11 -0
@@ -141,6 +141,7 @@ enum fanotify_event_type {FANOTIFY_EVENT_TYPE_PATH ,FANOTIFY_EVENT_TYPE_PATH_PERM ,FANOTIFY_EVENT_TYPE_OVERFLOW ,/* struct fanotify_event */ +FANOTIFY_EVENT_TYPE_FS_ERROR ,/* struct fanotify_error_event */ __FANOTIFY_EVENT_TYPE_NUM };
@@ -196,6 +197,16 @@ FANOTIFY_NE(struct fanotify_event *event) return container_of(event, struct fanotify_name_event, fae); } +struct fanotify_error_event { +struct fanotify_event fae; +}; + +static inline struct fanotify_error_event * +FANOTIFY_EE (struct fanotify_event *event) +{ + return container_of(event, struct fanotify_error_event, fae); +} +static inline __kernel_fsid_t *fanotify_event_fsid (struct fanotify_event *event) {if (event->type ==FANOTIFY_EVENT_TYPE_FID )
fs/notify/fanotify/fanotify_user.c +25 -1
@@ -30,6 +30,7 @@#define FANOTIFY_DEFAULT_MAX_EVENTS 16384#define FANOTIFY_OLD_DEFAULT_MAX_MARKS 8192#define FANOTIFY_DEFAULT_MAX_GROUPS 128 +#define FANOTIFY_DEFAULT_FEE_POOL_SIZE 32/* * Legacy fanotify marks limits (8192) is per group and we introduced a tunable
@@ -1054,6 +1055,15 @@ static struct fsnotify_mark *fanotify_add_new_mark(struct fsnotify_group *group,return ERR_PTR (ret); } +static int fanotify_group_init_error_pool (struct fsnotify_group *group) +{ +if (mempool_initialized (&group->fanotify_data.error_events_pool)) +return 0 ; + +return mempool_init_kmalloc_pool (&group->fanotify_data.error_events_pool, +FANOTIFY_DEFAULT_FEE_POOL_SIZE , +sizeof (struct fanotify_error_event )); +} static int fanotify_add_mark(struct fsnotify_group *group, fsnotify_connp_t *connp, unsigned int type,
@@ -1062,6 +1072,7 @@ static int fanotify_add_mark(struct fsnotify_group *group, {struct fsnotify_mark *fsn_mark;__u32 added; +int ret =0 ;mutex_lock (&group->mark_mutex); fsn_mark =fsnotify_find_mark (connp, group);
@@ -1072,13 +1083,26 @@ static int fanotify_add_mark(struct fsnotify_group *group,return PTR_ERR (fsn_mark); } } + +/* +* Error events are pre-allocated per group, only if strictly +* needed (i.e. FAN_FS_ERROR was requested). +*/ +if (!(flags &FAN_MARK_IGNORED_MASK ) && (mask &FAN_FS_ERROR )) { + ret =fanotify_group_init_error_pool (group); +if (ret) + goto out; + } + added =fanotify_mark_add_to_mask (fsn_mark, mask, flags);if (added & ~fsnotify_conn_mask (fsn_mark->connector))fsnotify_recalc_mask (fsn_mark->connector); + +out:mutex_unlock (&group->mark_mutex);fsnotify_put_mark (fsn_mark); -return 0 ; +return ret; } static int fanotify_add_vfsmount_mark(struct fsnotify_group *group,
include/linux/fsnotify_backend.h +2 -0
@@ -19,6 +19,7 @@#include <linux/atomic.h> #include <linux/user_namespace.h> #include <linux/refcount.h> +#include <linux/mempool.h> /* * IN_* from inotfy.h lines up EXACTLY with FS_*, this is so we can easily
@@ -246,6 +247,7 @@ struct fsnotify_group {int flags;/* flags from fanotify_init() */ int f_flags;/* event_f_flags from fanotify_init() */ struct ucounts *ucounts; + mempool_t error_events_pool; } fanotify_data;#endif /* CONFIG_FANOTIFY */ };
Signature · 1 line
2.33.0
Amir Goldstein
reviewerRe: [PATCH v9 19/31] fanotify: Pre-allocate pool of error events
Quoted 8 lines · Gabriel Krisman Bertazi
Pre-allocate slots for file system errors to have greater chances of succeeding, since error events can happen in
GFP_NOFScontext. This patch introduces a group-wide mempool of error events, shared by allFAN_FS_ERRORmarks in this group.For now, just allocate 128 positions. A future patch allows this array to be dynamically resized when a new mark is added.
This phrase is out dated.
No need to re-post entire v10 series just for that. You may suggest the re-phrase here.
Thanks,
Amir.
Quoted 148 lines
Reviewed-by Amir Goldstein <[email protected]>Reviewed-by Jan Kara <[email protected]>Signed-off-by Gabriel Krisman Bertazi <[email protected]>---
Changes since v8:
-FANOTIFY_DEFAULT_MAX_FEE_POOL->FANOTIFY_DEFAULT_FEE_POOL_SIZE
- Reduce limit to 32. (Jan)
Changes since v7:
- Expand limit to 128. (Amir)--- fs/notify/fanotify/fanotify.c | 3 +++ fs/notify/fanotify/fanotify.h | 11 +++++++++++ fs/notify/fanotify/fanotify_user.c | 26 +++++++++++++++++++++++++- include/linux/fsnotify_backend.h | 2 ++ 4 files changed, 41 insertions(+), 1 deletion(-)fs/notify/fanotify/fanotify.c +3
-0@@ -819,6 +819,9 @@ static void fanotify_free_group_priv(struct fsnotify_group *group)if (group->fanotify_data.ucounts)dec_ucount (group->fanotify_data.ucounts,UCOUNT_FANOTIFY_GROUPS ); + +if (mempool_initialized (&group->fanotify_data.error_events_pool)) +mempool_exit (&group->fanotify_data.error_events_pool); }static void fanotify_free_path_event (struct fanotify_event *event)fs/notify/fanotify/fanotify.h +11
-0@@ -141,6 +141,7 @@ enum fanotify_event_type {FANOTIFY_EVENT_TYPE_PATH ,FANOTIFY_EVENT_TYPE_PATH_PERM ,FANOTIFY_EVENT_TYPE_OVERFLOW ,/* struct fanotify_event */ +FANOTIFY_EVENT_TYPE_FS_ERROR ,/* struct fanotify_error_event */ __FANOTIFY_EVENT_TYPE_NUM };@@ -196,6 +197,16 @@ FANOTIFY_NE(struct fanotify_event *event) return container_of(event, struct fanotify_name_event, fae); } +struct fanotify_error_event { +struct fanotify_event fae; +}; + +static inline struct fanotify_error_event * +FANOTIFY_EE (struct fanotify_event *event) +{ + return container_of(event, struct fanotify_error_event, fae); +} +static inline __kernel_fsid_t *fanotify_event_fsid (struct fanotify_event *event) {if (event->type ==FANOTIFY_EVENT_TYPE_FID )fs/notify/fanotify/fanotify_user.c +25
-1@@ -30,6 +30,7 @@#define FANOTIFY_DEFAULT_MAX_EVENTS 16384#define FANOTIFY_OLD_DEFAULT_MAX_MARKS 8192#define FANOTIFY_DEFAULT_MAX_GROUPS 128 +#define FANOTIFY_DEFAULT_FEE_POOL_SIZE 32/* * Legacy fanotify marks limits (8192) is per group and we introduced a tunable @@ -1054,6 +1055,15 @@ static struct fsnotify_mark *fanotify_add_new_mark(struct fsnotify_group *group,return ERR_PTR (ret); } +static int fanotify_group_init_error_pool (struct fsnotify_group *group) +{ +if (mempool_initialized (&group->fanotify_data.error_events_pool)) +return 0 ; + +return mempool_init_kmalloc_pool (&group->fanotify_data.error_events_pool, +FANOTIFY_DEFAULT_FEE_POOL_SIZE , +sizeof (struct fanotify_error_event )); +} static int fanotify_add_mark(struct fsnotify_group *group, fsnotify_connp_t *connp, unsigned int type,@@ -1062,6 +1072,7 @@ static int fanotify_add_mark(struct fsnotify_group *group, {struct fsnotify_mark *fsn_mark;__u32 added; +int ret =0 ;mutex_lock (&group->mark_mutex); fsn_mark =fsnotify_find_mark (connp, group);@@ -1072,13 +1083,26 @@ static int fanotify_add_mark(struct fsnotify_group *group,return PTR_ERR (fsn_mark); } } + +/* +* Error events are pre-allocated per group, only if strictly +* needed (i.e. FAN_FS_ERROR was requested). +*/ +if (!(flags &FAN_MARK_IGNORED_MASK ) && (mask &FAN_FS_ERROR )) { + ret =fanotify_group_init_error_pool (group); +if (ret) + goto out; + } + added =fanotify_mark_add_to_mask (fsn_mark, mask, flags);if (added & ~fsnotify_conn_mask (fsn_mark->connector))fsnotify_recalc_mask (fsn_mark->connector); + +out:mutex_unlock (&group->mark_mutex);fsnotify_put_mark (fsn_mark); -return 0 ; +return ret; } static int fanotify_add_vfsmount_mark(struct fsnotify_group *group,include/linux/fsnotify_backend.h +2
-1@@ -19,6 +19,7 @@#include <linux/atomic.h> #include <linux/user_namespace.h> #include <linux/refcount.h> +#include <linux/mempool.h> /* * IN_* from inotfy.h lines up EXACTLY with FS_*, this is so we can easily @@ -246,6 +247,7 @@ struct fsnotify_group {int flags;/* flags from fanotify_init() */ int f_flags;/* event_f_flags from fanotify_init() */ struct ucounts *ucounts; + mempool_t error_events_pool; } fanotify_data;#endif /* CONFIG_FANOTIFY */ }; --2.33.0
PATCH v9 20/31 fanotify: Support enqueueing of error events
In reply to Gabriel Krisman BertaziOnce an error event is triggered, enqueue it in the notification group, similarly to what is done for other events. FAN_FS_ERROR is not handled specially, since the memory is now handled by a preallocated mempool.
For now, make the event unhashed. A future patch implements merging of this kind of event.
---
Changes since v7:
- WARN_ON -> WARN_ON_ONCE (Amir)
--- fs/notify/fanotify/fanotify.c | 35 +++++++++++++++++++++++++++++++++++ fs/notify/fanotify/fanotify.h | 6 ++++++ 2 files changed, 41 insertions(+)
fs/notify/fanotify/fanotify.c +35 -0
@@ -574,6 +574,27 @@ static struct fanotify_event *fanotify_alloc_name_event(struct inode *id,return &fne->fae; } +static struct fanotify_event *fanotify_alloc_error_event ( +struct fsnotify_group *group, +__kernel_fsid_t *fsid, +const void *data,int data_type) +{ +struct fs_error_report *report = +fsnotify_data_error_report (data, data_type); +struct fanotify_error_event *fee; + +if (WARN_ON_ONCE (!report)) +return NULL ; + + fee =mempool_alloc (&group->fanotify_data.error_events_pool,GFP_NOFS ); +if (!fee) +return NULL ; + + fee->fae.type =FANOTIFY_EVENT_TYPE_FS_ERROR ; + +return &fee->fae; +} + static struct fanotify_event *fanotify_alloc_event(struct fsnotify_group *group, u32 mask, const void *data, int data_type, struct inode *dir,
@@ -641,6 +662,9 @@ 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 (fanotify_is_error_event (mask)) { + event =fanotify_alloc_error_event (group, fsid, data, + data_type); }else if (name_event && (file_name || child)) { event =fanotify_alloc_name_event (id, fsid, file_name, child, &hash, gfp);
@@ -850,6 +874,14 @@ static void fanotify_free_name_event(struct fanotify_event *event)kfree (FANOTIFY_NE (event)); } +static void fanotify_free_error_event (struct fsnotify_group *group, +struct fanotify_event *event) +{ +struct fanotify_error_event *fee =FANOTIFY_EE (event); + +mempool_free (fee, &group->fanotify_data.error_events_pool); +} +static void fanotify_free_event (struct fsnotify_group *group,struct fsnotify_event *fsn_event) {
@@ -873,6 +905,9 @@ static void fanotify_free_event(struct fsnotify_group *group,case FANOTIFY_EVENT_TYPE_OVERFLOW :kfree (event);break ; +case FANOTIFY_EVENT_TYPE_FS_ERROR : +fanotify_free_error_event (group, event); +break ;default :WARN_ON_ONCE (1 ); }
fs/notify/fanotify/fanotify.h +6 -0
@@ -298,6 +298,11 @@ static inline struct fanotify_event *FANOTIFY_E(struct fsnotify_event *fse) return container_of(fse, struct fanotify_event, fse); } +static inline bool fanotify_is_error_event (u32 mask) +{ +return mask &FAN_FS_ERROR ; +} +static inline bool fanotify_event_has_path (struct fanotify_event *event) { return event->type == FANOTIFY_EVENT_TYPE_PATH ||
@@ -327,6 +332,7 @@ static inline struct path *fanotify_event_path(struct fanotify_event *event)static inline bool fanotify_is_hashed_event (u32 mask) {return !(fanotify_is_perm_event (mask) || +fanotify_is_error_event (mask) ||fsnotify_is_overflow_event (mask)); }
Signature · 1 line
2.33.0
PATCH v9 21/31 fanotify: Support merging of error events
In reply to Gabriel Krisman BertaziError events (FAN_FS_ERROR) against the same file system can be merged by simply iterating the error count. The hash is taken from the fsid, without considering the FH. This means that only the first error object is reported.
---
Changes since v7:
- Move fee->fsid assignment here (Amir)
- Open code error event merge logic in fanotify_merge (Jan)
--- fs/notify/fanotify/fanotify.c | 26 ++++++++++++++++++++++++-- fs/notify/fanotify/fanotify.h | 4 +++- 2 files changed, 27 insertions(+), 3 deletions(-)
fs/notify/fanotify/fanotify.c +24 -2
@@ -111,6 +111,16 @@ static bool fanotify_name_event_equal(struct fanotify_name_event *fne1,return fanotify_info_equal (info1, info2); } +static bool fanotify_error_event_equal (struct fanotify_error_event *fee1, +struct fanotify_error_event *fee2) +{ +/* Error events against the same file system are always merged. */ +if (!fanotify_fsid_equal (&fee1->fsid, &fee2->fsid)) +return false; + +return true; +} +static bool fanotify_should_merge (struct fanotify_event *old,struct fanotify_event *new) {
@@ -141,6 +151,9 @@ static bool fanotify_should_merge(struct fanotify_event *old,case FANOTIFY_EVENT_TYPE_FID_NAME :return fanotify_name_event_equal (FANOTIFY_NE (old),FANOTIFY_NE (new)); +case FANOTIFY_EVENT_TYPE_FS_ERROR : +return fanotify_error_event_equal (FANOTIFY_EE (old), +FANOTIFY_EE (new));default :WARN_ON_ONCE (1 ); }
@@ -176,6 +189,10 @@ static int fanotify_merge(struct fsnotify_group *group,break ;if (fanotify_should_merge (old, new)) { old->mask |= new->mask; + +if (fanotify_is_error_event (old->mask)) +FANOTIFY_EE (old)->err_count++; +return 1 ; } }
@@ -577,7 +594,8 @@ static struct fanotify_event *fanotify_alloc_name_event(struct inode *id,static struct fanotify_event *fanotify_alloc_error_event (struct fsnotify_group *group,__kernel_fsid_t *fsid, -const void *data,int data_type) +const void *data,int data_type, +unsigned int *hash) {struct fs_error_report *report =fsnotify_data_error_report (data, data_type);
@@ -591,6 +609,10 @@ static struct fanotify_event *fanotify_alloc_error_event(return NULL ; fee->fae.type =FANOTIFY_EVENT_TYPE_FS_ERROR ; + fee->err_count =1 ; + fee->fsid = *fsid; + + *hash ^=fanotify_hash_fsid (fsid);return &fee->fae; }
@@ -664,7 +686,7 @@ static struct fanotify_event *fanotify_alloc_event(struct fsnotify_group *group, event =fanotify_alloc_perm_event (path, gfp); }else if (fanotify_is_error_event (mask)) { event =fanotify_alloc_error_event (group, fsid, data, - data_type); + data_type, &hash); }else if (name_event && (file_name || child)) { event =fanotify_alloc_name_event (id, fsid, file_name, child, &hash, gfp);
fs/notify/fanotify/fanotify.h +3 -1
@@ -199,6 +199,9 @@ FANOTIFY_NE(struct fanotify_event *event)struct fanotify_error_event {struct fanotify_event fae; +u32 err_count;/* Suppressed errors count */ + +__kernel_fsid_t fsid;/* FSID this error refers to. */ }; static inline struct fanotify_error_event *
@@ -332,7 +335,6 @@ static inline struct path *fanotify_event_path(struct fanotify_event *event)static inline bool fanotify_is_hashed_event (u32 mask) {return !(fanotify_is_perm_event (mask) || -fanotify_is_error_event (mask) ||fsnotify_is_overflow_event (mask)); }
Signature · 1 line
2.33.0
PATCH v9 22/31 fanotify: Wrap object_fh inline space in a creator macro
In reply to Gabriel Krisman Bertazifanotify_error_event would duplicate this sequence of declarations that already exist elsewhere with a slight different size. Create a helper macro to avoid code duplication.
---
Changes since v8:
- Drop comment (Amir)
- Pass fanotify_fh object name to constructor (Jan)
--- fs/notify/fanotify/fanotify.h | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-)
fs/notify/fanotify/fanotify.h +9 -3
@@ -171,12 +171,18 @@ static inline void fanotify_init_event(struct fanotify_event *event, event->pid =NULL ; } +#define FANOTIFY_INLINE_FH (name, size) \ +struct { \ + struct fanotify_fh (name); \ +/* Space for object_fh.buf[] - access with fanotify_fh_buf() */ \ +unsigned char _inline_fh_buf[(size)]; \ +} +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 ]; + + FANOTIFY_INLINE_FH(object_fh, FANOTIFY_INLINE_FH_LEN); }; static inline struct fanotify_fid_event *
Signature · 1 line
2.33.0
PATCH v9 23/31 fanotify: Add helpers to decide whether to report FID/DFID
In reply to Gabriel Krisman BertaziNow that there is an event that reports FID records even for a zeroed file handle, wrap the logic that deides whether to issue the records into helper functions. This shouldn't have any impact on the code, but simplifies further patches.
---
Changes since v8:
- Simplify constructs (Amir)
--- fs/notify/fanotify/fanotify.h | 10 ++++++++++ fs/notify/fanotify/fanotify_user.c | 13 +++++++------ 2 files changed, 17 insertions(+), 6 deletions(-)
fs/notify/fanotify/fanotify.h +10 -0
@@ -264,6 +264,16 @@ static inline int fanotify_event_dir_fh_len(struct fanotify_event *event)return info ?fanotify_info_dir_fh_len (info) :0 ; } +static inline bool fanotify_event_has_object_fh (struct fanotify_event *event) +{ +return fanotify_event_object_fh_len (event) >0 ; +} + +static inline bool fanotify_event_has_dir_fh (struct fanotify_event *event) +{ +return fanotify_event_dir_fh_len (event) >0 ; +} +struct fanotify_path_event {struct fanotify_event fae;struct path path;
fs/notify/fanotify/fanotify_user.c +7 -6
@@ -140,10 +140,9 @@ static size_t fanotify_event_len(unsigned int info_mode,return event_len; info =fanotify_event_info (event); - dir_fh_len =fanotify_event_dir_fh_len (event); - fh_len =fanotify_event_object_fh_len (event); -if (dir_fh_len) { +if (fanotify_event_has_dir_fh (event)) { + dir_fh_len =fanotify_event_dir_fh_len (event); event_len +=fanotify_fid_info_len (dir_fh_len, info->name_len); }else if ((info_mode &FAN_REPORT_NAME ) && (event->mask &FAN_ONDIR )) {
@@ -157,8 +156,10 @@ static size_t fanotify_event_len(unsigned int info_mode,if (info_mode &FAN_REPORT_PIDFD ) event_len +=FANOTIFY_PIDFD_INFO_HDR_LEN ; -if (fh_len) +if (fanotify_event_has_object_fh (event)) { + fh_len =fanotify_event_object_fh_len (event); event_len +=fanotify_fid_info_len (fh_len, dot_len); + }return event_len; }
@@ -451,7 +452,7 @@ static int copy_info_records_to_user(struct fanotify_event *event,/* * Event info records order is as follows: dir fid + name, child fid. */ -if (fanotify_event_dir_fh_len (event)) { +if (fanotify_event_has_dir_fh (event)) { info_type = info->name_len ?FAN_EVENT_INFO_TYPE_DFID_NAME :FAN_EVENT_INFO_TYPE_DFID ; ret = copy_fid_info_to_user(fanotify_event_fsid(event),
@@ -467,7 +468,7 @@ static int copy_info_records_to_user(struct fanotify_event *event, total_bytes += ret; } -if (fanotify_event_object_fh_len (event)) { +if (fanotify_event_has_object_fh (event)) {const char *dot =NULL ;int dot_len =0 ;
Signature · 1 line
2.33.0
Re: [PATCH v9 23/31] fanotify: Add helpers to decide whether to report FID/DFID
Quoted 9 lines · Gabriel Krisman Bertazi
Now that there is an event that reports FID records even for a zeroed file handle, wrap the logic that deides whether to issue the records into helper functions. This shouldn't have any impact on the code, but simplifies further patches.
Reviewed-by Jan Kara <[email protected]>Signed-off-by Gabriel Krisman Bertazi <[email protected]>
Quoted 79 lines
---
Changes since v8:
- Simplify constructs (Amir)--- fs/notify/fanotify/fanotify.h | 10 ++++++++++ fs/notify/fanotify/fanotify_user.c | 13 +++++++------ 2 files changed, 17 insertions(+), 6 deletions(-)fs/notify/fanotify/fanotify.h +10
-0@@ -264,6 +264,16 @@ static inline int fanotify_event_dir_fh_len(struct fanotify_event *event)return info ?fanotify_info_dir_fh_len (info) :0 ; } +static inline bool fanotify_event_has_object_fh (struct fanotify_event *event) +{ +return fanotify_event_object_fh_len (event) >0 ; +} + +static inline bool fanotify_event_has_dir_fh (struct fanotify_event *event) +{ +return fanotify_event_dir_fh_len (event) >0 ; +} +struct fanotify_path_event {struct fanotify_event fae;struct path path;fs/notify/fanotify/fanotify_user.c +7
-7@@ -140,10 +140,9 @@ static size_t fanotify_event_len(unsigned int info_mode,return event_len; info =fanotify_event_info (event); - dir_fh_len =fanotify_event_dir_fh_len (event); - fh_len =fanotify_event_object_fh_len (event); -if (dir_fh_len) { +if (fanotify_event_has_dir_fh (event)) { + dir_fh_len =fanotify_event_dir_fh_len (event); event_len +=fanotify_fid_info_len (dir_fh_len, info->name_len); }else if ((info_mode &FAN_REPORT_NAME ) && (event->mask &FAN_ONDIR )) {@@ -157,8 +156,10 @@ static size_t fanotify_event_len(unsigned int info_mode,if (info_mode &FAN_REPORT_PIDFD ) event_len +=FANOTIFY_PIDFD_INFO_HDR_LEN ; -if (fh_len) +if (fanotify_event_has_object_fh (event)) { + fh_len =fanotify_event_object_fh_len (event); event_len +=fanotify_fid_info_len (fh_len, dot_len); + }return event_len; }@@ -451,7 +452,7 @@ static int copy_info_records_to_user(struct fanotify_event *event,/* * Event info records order is as follows: dir fid + name, child fid. */ -if (fanotify_event_dir_fh_len (event)) { +if (fanotify_event_has_dir_fh (event)) { info_type = info->name_len ?FAN_EVENT_INFO_TYPE_DFID_NAME :FAN_EVENT_INFO_TYPE_DFID ; ret = copy_fid_info_to_user(fanotify_event_fsid(event),@@ -467,7 +468,7 @@ static int copy_info_records_to_user(struct fanotify_event *event, total_bytes += ret; } -if (fanotify_event_object_fh_len (event)) { +if (fanotify_event_has_object_fh (event)) {const char *dot =NULL ;int dot_len =0 ; --2.33.0
PATCH v9 24/31 fanotify: Report fid entry even for zero-length file_handle
In reply to Gabriel Krisman BertaziNon-inode errors will reported with an empty file_handle. In preparation for that, allow some events to print the FID record even if there isn't any file_handle encoded
Even though FILEID_ROOT is used internally, make zero-length file handles be reported as FILEID_INVALID.
---
Changes since v8:
- Move fanotify_event_has_object_fh check here (jan)
--- fs/notify/fanotify/fanotify.h | 3 +++ fs/notify/fanotify/fanotify_user.c | 8 +++++--- 2 files changed, 8 insertions(+), 3 deletions(-)
fs/notify/fanotify/fanotify.h +3 -0
@@ -266,6 +266,9 @@ static inline int fanotify_event_dir_fh_len(struct fanotify_event *event)static inline bool fanotify_event_has_object_fh (struct fanotify_event *event) { +/* For error events, even zeroed fh are reported. */ +if (event->type ==FANOTIFY_EVENT_TYPE_FS_ERROR ) +return true;return fanotify_event_object_fh_len (event) >0 ; }
fs/notify/fanotify/fanotify_user.c +5 -3
@@ -339,9 +339,6 @@ static int copy_fid_info_to_user(__kernel_fsid_t *fsid, struct fanotify_fh *fh,pr_debug ("%s: fh_len=%zu name_len=%zu, info_len=%zu, count=%zu\n" , __func__, fh_len, name_len, info_len, count); -if (!fh_len) -return 0 ; -if (WARN_ON_ONCE (len <sizeof (info) || len > count))return -EFAULT ;
@@ -376,6 +373,11 @@ static int copy_fid_info_to_user(__kernel_fsid_t *fsid, struct fanotify_fh *fh, handle.handle_type = fh->type; handle.handle_bytes = fh_len; + +/* Mangle handle_type for bad file_handle */ +if (!fh_len) + handle.handle_type =FILEID_INVALID ; +if (copy_to_user (buf, &handle,sizeof (handle)))return -EFAULT ;
Signature · 1 line
2.33.0
Amir Goldstein
reviewerRe: [PATCH v9 24/31] fanotify: Report fid entry even for zero-length file_handle
Quoted 8 lines · Gabriel Krisman Bertazi
Non-inode errors will reported with an empty
file_handle. In preparation for that, allow some events to print the FID record even if there isn't anyfile_handleencodedEven though
FILEID_ROOTis used internally, make zero-length file handles be reported asFILEID_INVALID.
Quoted 7 lines
Reviewed-by Amir Goldstein <[email protected]>Reviewed-by Jan Kara <[email protected]>Signed-off-by Gabriel Krisman Bertazi <[email protected]>---
Changes since v8:
- Movefanotify_event_has_object_fhcheck here (jan)
Logically, this move is wrong, because after this patch, copy_fid_info_to_user() can theoretically be called with NULL fh in the existing construct of:
if (fanotify_event_has_object_fh(event)) {
...
ret = copy_fid_info_to_user(fanotify_event_fsid(event),
fanotify_event_object_fh(event),
The thing that prevents this case in effect is that FAN_FS_ERROR is not yet wired, but I am not sure if leaving this theoretic bisect issue is a good idea.
Anyway, that's a very minor theoretic issue and I am sure Jan can decide whether to deal with it and how (no need to post v10 IMO).
Thanks,
Amir.
Jan Kara
maintainerRe: [PATCH v9 24/31] fanotify: Report fid entry even for zero-length file_handle
Quoted 25 lines · Amir Goldstein
Quoted 8 lines · Gabriel Krisman Bertazi
Non-inode errors will reported with an empty
file_handle. In preparation for that, allow some events to print the FID record even if there isn't anyfile_handleencodedEven though
FILEID_ROOTis used internally, make zero-length file handles be reported asFILEID_INVALID.Quoted 7 lines
Reviewed-by Amir Goldstein <[email protected]>Reviewed-by Jan Kara <[email protected]>Signed-off-by Gabriel Krisman Bertazi <[email protected]>---
Changes since v8:
- Movefanotify_event_has_object_fhcheck here (jan)Logically, this move is wrong, because after this patch,
copy_fid_info_to_user()can theoretically be called with NULL fh in the existing construct of:
if (fanotify_event_has_object_fh(event)) {
...
ret = copy_fid_info_to_user(fanotify_event_fsid(event),
Quoted 8 lines
fanotify_event_object_fh(event),The thing that prevents this case in effect is that
FAN_FS_ERRORis not yet wired, but I am not sure if leaving this theoretic bisect issue is a good idea.Anyway, that's a very minor theoretic issue and I am sure Jan can decide whether to deal with it and how (no need to post v10 IMO).
Hum, correct. I guess I'll just fold this patch into patch 26. Logically they are very close anyway.
Honza
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
PATCH v9 25/31 fanotify: WARN_ON against too large file handles
In reply to Gabriel Krisman Bertazistruct fanotify_error_event, at least, is preallocated and isn't able to to handle arbitrarily large file handles. Future-proof the code by complaining loudly if a handle larger than MAX_HANDLE_SZ is ever found.
--- fs/notify/fanotify/fanotify.c | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-)
fs/notify/fanotify/fanotify.c +11 -1
@@ -360,13 +360,23 @@ static u32 fanotify_group_event_mask(struct fsnotify_group *group,static int fanotify_encode_fh_len (struct inode *inode) {int dwords =0 ; +int fh_len;if (!inode)return 0 ;exportfs_encode_inode_fh (inode,NULL , &dwords,NULL ); + fh_len = dwords <<2 ; -return dwords <<2 ; +/* +* struct fanotify_error_event might be preallocated and is +* limited to MAX_HANDLE_SZ. This should never happen, but +* safeguard by forcing an invalid file handle. +*/ +if (WARN_ON_ONCE (fh_len >MAX_HANDLE_SZ )) +return 0 ; + +return fh_len; }/*
Signature · 1 line
2.33.0
PATCH v9 26/31 fanotify: Report fid info for file related file system errors
In reply to Gabriel Krisman BertaziPlumb the pieces to add a FID report to error records. Since all error event memory must be pre-allocated, we pre-allocate the maximum file handle size possible, such that it should always fit.
For errors that don't expose a file handle report it with an invalid FID.
---
Changes since v8:
- Drop comment (Amir)
- Move report dereference till after null check (jan)
- Move has_object_fh hunk to earlier patch (jan)
Changes since v7:
- Move WARN_ON to separate patch (Amir)
- Avoid duplication in the structure definition (Amir)
Changes since v6:
- pass fsid from handle_events
Changes since v5:
- Use preallocated MAX_HANDLE_SZ FH buffer
- Report superblock errors with a zerolength INVALID FID (jan, amir)
--- fs/notify/fanotify/fanotify.c | 11 +++++++++++ fs/notify/fanotify/fanotify.h | 6 ++++++ 2 files changed, 17 insertions(+)
fs/notify/fanotify/fanotify.c +11 -0
@@ -609,7 +609,9 @@ static struct fanotify_event *fanotify_alloc_error_event( {struct fs_error_report *report =fsnotify_data_error_report (data, data_type); +struct inode *inode;struct fanotify_error_event *fee; +int fh_len;if (WARN_ON_ONCE (!report))return NULL ;
@@ -622,6 +624,15 @@ static struct fanotify_event *fanotify_alloc_error_event( fee->err_count =1 ; fee->fsid = *fsid; + inode = report->inode; + fh_len =fanotify_encode_fh_len (inode); + +/* Bad fh_len. Fallback to using an invalid fh. Should never happen. */ +if (!fh_len && inode) + inode =NULL ; + +fanotify_encode_fh (&fee->object_fh, inode, fh_len,NULL ,0 ); + *hash ^=fanotify_hash_fsid (fsid);return &fee->fae;
fs/notify/fanotify/fanotify.h +6 -0
@@ -208,6 +208,8 @@ struct fanotify_error_event {u32 err_count;/* Suppressed errors count */ __kernel_fsid_t fsid;/* FSID this error refers to. */ + +FANOTIFY_INLINE_FH (object_fh,MAX_HANDLE_SZ ); }; static inline struct fanotify_error_event *
@@ -222,6 +224,8 @@ static inline __kernel_fsid_t *fanotify_event_fsid(struct fanotify_event *event)return &FANOTIFY_FE (event)->fsid; else if (event->type == FANOTIFY_EVENT_TYPE_FID_NAME) return &FANOTIFY_NE(event)->fsid; + else if (event->type == FANOTIFY_EVENT_TYPE_FS_ERROR) + return &FANOTIFY_EE(event)->fsid; else return NULL; }
@@ -233,6 +237,8 @@ static inline struct fanotify_fh *fanotify_event_object_fh(return &FANOTIFY_FE (event)->object_fh; else if (event->type == FANOTIFY_EVENT_TYPE_FID_NAME) return fanotify_info_file_fh(&FANOTIFY_NE(event)->info); + else if (event->type == FANOTIFY_EVENT_TYPE_FS_ERROR) + return &FANOTIFY_EE(event)->object_fh; else return NULL; }
Signature · 1 line
2.33.0
PATCH v9 27/31 fanotify: Emit generic error info for error event
In reply to Gabriel Krisman BertaziThe error info is a record sent to users on FAN_FS_ERROR events documenting the type of error. It also carries an error count, documenting how many errors were observed since the last reporting.
---
Changes since v6:
- Rebase on top of pidfd patches
Changes since v5:
- Move error code here
--- fs/notify/fanotify/fanotify.c | 1 + fs/notify/fanotify/fanotify.h | 1 + fs/notify/fanotify/fanotify_user.c | 35 ++++++++++++++++++++++++++++++ include/uapi/linux/fanotify.h | 7 ++++++ 4 files changed, 44 insertions(+)
fs/notify/fanotify/fanotify.c +1 -0
@@ -621,6 +621,7 @@ static struct fanotify_event *fanotify_alloc_error_event(return NULL ; fee->fae.type =FANOTIFY_EVENT_TYPE_FS_ERROR ; + fee->error = report->error; fee->err_count =1 ; fee->fsid = *fsid;
fs/notify/fanotify/fanotify.h +1 -0
@@ -205,6 +205,7 @@ FANOTIFY_NE(struct fanotify_event *event)struct fanotify_error_event {struct fanotify_event fae; +s32 error;/* Error reported by the Filesystem. */ u32 err_count;/* Suppressed errors count */ __kernel_fsid_t fsid;/* FSID this error refers to. */
fs/notify/fanotify/fanotify_user.c +35 -0
@@ -115,6 +115,8 @@ struct kmem_cache *fanotify_perm_event_cachep __read_mostly; (sizeof(struct fanotify_event_info_fid) + sizeof(struct file_handle))#define FANOTIFY_PIDFD_INFO_HDR_LEN \ sizeof(struct fanotify_event_info_pidfd) +#define FANOTIFY_ERROR_INFO_LEN \ + (sizeof(struct fanotify_event_info_error))static int fanotify_fid_info_len (int fh_len,int name_len) {
@@ -139,6 +141,9 @@ static size_t fanotify_event_len(unsigned int info_mode,if (!info_mode)return event_len; +if (fanotify_is_error_event (event->mask)) + event_len +=FANOTIFY_ERROR_INFO_LEN ; + info =fanotify_event_info (event);if (fanotify_event_has_dir_fh (event)) {
@@ -324,6 +329,28 @@ static int process_access_response(struct fsnotify_group *group,return -ENOENT ; } +static size_t copy_error_info_to_user (struct fanotify_event *event, +char __user *buf,int count) +{ +struct fanotify_event_info_error info; +struct fanotify_error_event *fee =FANOTIFY_EE (event); + + info.hdr.info_type =FAN_EVENT_INFO_TYPE_ERROR ; + info.hdr.pad =0 ; + info.hdr.len =FANOTIFY_ERROR_INFO_LEN ; + +if (WARN_ON (count < info.hdr.len)) +return -EFAULT ; + + info.error = fee->error; + info.error_count = fee->err_count; + +if (copy_to_user (buf, &info,sizeof (info))) +return -EFAULT ; + +return info.hdr.len; +} + static int copy_fid_info_to_user(__kernel_fsid_t *fsid, struct fanotify_fh *fh, int info_type, const char *name, size_t name_len,
@@ -530,6 +557,14 @@ static int copy_info_records_to_user(struct fanotify_event *event, total_bytes += ret; } +if (fanotify_is_error_event (event->mask)) { + ret =copy_error_info_to_user (event, buf, count); +if (ret <0 ) +return ret; + buf += ret; + count -= ret; + } +return total_bytes; }
include/uapi/linux/fanotify.h +7 -0
@@ -126,6 +126,7 @@ struct fanotify_event_metadata {#define FAN_EVENT_INFO_TYPE_DFID_NAME 2#define FAN_EVENT_INFO_TYPE_DFID 3#define FAN_EVENT_INFO_TYPE_PIDFD 4 +#define FAN_EVENT_INFO_TYPE_ERROR 5/* Variable length info record following event metadata */ struct fanotify_event_info_header {
@@ -160,6 +161,12 @@ struct fanotify_event_info_pidfd {__s32 pidfd; }; +struct fanotify_event_info_error { +struct fanotify_event_info_header hdr; +__s32 error; +__u32 error_count; +}; +struct fanotify_response {__s32 fd;__u32 response;
Signature · 1 line
2.33.0
Jan Kara
maintainerRe: [PATCH v9 27/31] fanotify: Emit generic error info for error event
Quoted 7 lines · Gabriel Krisman Bertazi
The error info is a record sent to users on
FAN_FS_ERRORevents documenting the type of error. It also carries an error count, documenting how many errors were observed since the last reporting.Reviewed-by Amir Goldstein <[email protected]>Reviewed-by Jan Kara <[email protected]>Signed-off-by Gabriel Krisman Bertazi <[email protected]>
...
Quoted 4 lines
fs/notify/fanotify/fanotify_user.c +0
-0@@ -530,6 +557,14 @@ static int copy_info_records_to_user(struct fanotify_event *event, total_bytes += ret; }
fs/notify/fanotify/fanotify_user.c static int copy_info_records_to_user(struct fanotify_event *event, · line 569
Quoted 10 lines
fs/notify/fanotify/fanotify_user.c +8
-0+if (fanotify_is_error_event (event->mask)) { + ret =copy_error_info_to_user (event, buf, count); +if (ret <0 ) +return ret; + buf += ret; + count -= ret; + } +return total_bytes; }
This is currently harmless but we should add
total_bytes += ret;
here as well.
Honza
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
PATCH v9 28/31 fanotify: Allow users to request FAN_FS_ERROR events
In reply to Gabriel Krisman BertaziWire up the FAN_FS_ERROR event in the fanotify_mark syscall, allowing user space to request the monitoring of FAN_FS_ERROR events.
These events are limited to filesystem marks, so check it is the case in the syscall handler.
---
Changes since v7:
- Move the verification closer to similar code (Amir)
--- fs/notify/fanotify/fanotify.c | 2 +- fs/notify/fanotify/fanotify_user.c | 4 ++++ include/linux/fanotify.h | 6 +++++- 3 files changed, 10 insertions(+), 2 deletions(-)
fs/notify/fanotify/fanotify.c +1 -1
@@ -822,7 +822,7 @@ static int fanotify_handle_event(struct fsnotify_group *group, u32 mask,BUILD_BUG_ON (FAN_OPEN_EXEC_PERM !=FS_OPEN_EXEC_PERM );BUILD_BUG_ON (FAN_FS_ERROR !=FS_ERROR ); -BUILD_BUG_ON (HWEIGHT32 (ALL_FANOTIFY_EVENT_BITS ) !=19 ); +BUILD_BUG_ON (HWEIGHT32 (ALL_FANOTIFY_EVENT_BITS ) !=20 ); mask =fanotify_group_event_mask (group, iter_info, mask, data, data_type, dir);
fs/notify/fanotify/fanotify_user.c +4 -0
@@ -1519,6 +1519,10 @@ static int do_fanotify_mark(int fanotify_fd, unsigned int flags, __u64 mask, group->priority == FS_PRIO_0) goto fput_and_out; +if (mask &FAN_FS_ERROR && + mark_type !=FAN_MARK_FILESYSTEM ) + goto fput_and_out; +/* * Events that do not carry enough information to report * event->fd require a group that supports reporting fid. Those
include/linux/fanotify.h +5 -1
@@ -91,9 +91,13 @@ extern struct ctl_table fanotify_table[]; /* for sysctl */#define FANOTIFY_INODE_EVENTS (FANOTIFY_DIRENT_EVENTS | \ FAN_ATTRIB | FAN_MOVE_SELF | FAN_DELETE_SELF) +/* Events that can only be reported with data type FSNOTIFY_EVENT_ERROR */ +#define FANOTIFY_ERROR_EVENTS (FAN_FS_ERROR) +/* Events that user can request to be notified on */ #define FANOTIFY_EVENTS (FANOTIFY_PATH_EVENTS | \ - FANOTIFY_INODE_EVENTS) + FANOTIFY_INODE_EVENTS | \ + FANOTIFY_ERROR_EVENTS)/* Events that require a permission response from user */ #define FANOTIFY_PERM_EVENTS (FAN_OPEN_PERM | FAN_ACCESS_PERM | \
Signature · 1 line
2.33.0
PATCH v9 29/31 ext4: Send notifications on error
In reply to Gabriel Krisman BertaziSend a FS_ERROR message via fsnotify to a userspace monitoring tool whenever a ext4 error condition is triggered. This follows the existing error conditions in ext4, so it is hooked to the ext4_error* functions.
---
Changes since v8:
- Report always report non-zero errno (Jan, Amir, Ted)
Changes since v6:
- Report ext4_std_errors agains superblock (jan)
--- fs/ext4/super.c | 8 ++++++++ 1 file changed, 8 insertions(+)
fs/ext4/super.c +8 -0
@@ -46,6 +46,7 @@#include <linux/part_stat.h> #include <linux/kthread.h> #include <linux/freezer.h> +#include <linux/fsnotify.h> #include "ext4.h" #include "ext4_extents.h" /* Needed for trace points definition */
@@ -759,6 +760,8 @@ void __ext4_error(struct super_block *sb, const char *function, sb->s_id, function, line, current->comm, &vaf);va_end (args); } +fsnotify_sb_error (sb,NULL , error ? error :EFSCORRUPTED ); +ext4_handle_error (sb, force_ro, error,0 , block, function, line); }
@@ -789,6 +792,8 @@ void __ext4_error_inode(struct inode *inode, const char *function, current->comm, &vaf);va_end (args); } +fsnotify_sb_error (inode->i_sb, inode, error ? error :EFSCORRUPTED ); +ext4_handle_error (inode->i_sb, false, error, inode->i_ino, block, function, line); }
@@ -827,6 +832,8 @@ void __ext4_error_file(struct file *file, const char *function, current->comm, path, &vaf);va_end (args); } +fsnotify_sb_error (inode->i_sb, inode,EFSCORRUPTED ); +ext4_handle_error (inode->i_sb, false,EFSCORRUPTED , inode->i_ino, block, function, line); }
@@ -894,6 +901,7 @@ void __ext4_std_error(struct super_block *sb, const char *function,printk (KERN_CRIT "EXT4-fs error (device %s) in %s:%d: %s\n" , sb->s_id, function, line, errstr); } +fsnotify_sb_error (sb,NULL , errno ? errno :EFSCORRUPTED );ext4_handle_error (sb, false, -errno,0 ,0 , function, line); }
Signature · 1 line
2.33.0
Re: [PATCH v9 29/31] ext4: Send notifications on error
Quoted 5 lines · Gabriel Krisman Bertazi
Send a
FS_ERRORmessage via fsnotify to a userspace monitoring tool whenever a ext4 error condition is triggered. This follows the existing error conditions in ext4, so it is hooked to the ext4_error* functions.Signed-off-by Gabriel Krisman Bertazi <[email protected]>
Thanks!
- Ted
Re: [PATCH v9 29/31] ext4: Send notifications on error
In reply to Gabriel Krisman BertaziQuoted 7 lines · Gabriel Krisman Bertazi
Send a
FS_ERRORmessage via fsnotify to a userspace monitoring tool whenever a ext4 error condition is triggered. This follows the existing error conditions in ext4, so it is hooked to the ext4_error* functions.Signed-off-by Gabriel Krisman Bertazi <[email protected]>
Quoted 59 lines
---
Changes since v8:
- Report always report non-zero errno (Jan, Amir, Ted)
Changes since v6:
- Reportext4_std_errorsagains superblock (jan)--- fs/ext4/super.c | 8 ++++++++ 1 file changed, 8 insertions(+)fs/ext4/super.c +8
-1@@ -46,6 +46,7 @@#include <linux/part_stat.h> #include <linux/kthread.h> #include <linux/freezer.h> +#include <linux/fsnotify.h> #include "ext4.h" #include "ext4_extents.h" /* Needed for trace points definition */ @@ -759,6 +760,8 @@ void __ext4_error(struct super_block *sb, const char *function, sb->s_id, function, line, current->comm, &vaf);va_end (args); } +fsnotify_sb_error (sb,NULL , error ? error :EFSCORRUPTED ); +ext4_handle_error (sb, force_ro, error,0 , block, function, line); }@@ -789,6 +792,8 @@ void __ext4_error_inode(struct inode *inode, const char *function, current->comm, &vaf);va_end (args); } +fsnotify_sb_error (inode->i_sb, inode, error ? error :EFSCORRUPTED ); +ext4_handle_error (inode->i_sb, false, error, inode->i_ino, block, function, line); }@@ -827,6 +832,8 @@ void __ext4_error_file(struct file *file, const char *function, current->comm, path, &vaf);va_end (args); } +fsnotify_sb_error (inode->i_sb, inode,EFSCORRUPTED ); +ext4_handle_error (inode->i_sb, false,EFSCORRUPTED , inode->i_ino, block, function, line); }@@ -894,6 +901,7 @@ void __ext4_std_error(struct super_block *sb, const char *function,printk (KERN_CRIT "EXT4-fs error (device %s) in %s:%d: %s\n" , sb->s_id, function, line, errstr); } +fsnotify_sb_error (sb,NULL , errno ? errno :EFSCORRUPTED );ext4_handle_error (sb, false, -errno,0 ,0 , function, line); } --2.33.0
Re: [PATCH v9 29/31] ext4: Send notifications on error
In reply to Gabriel Krisman BertaziQuoted 5 lines · Gabriel Krisman Bertazi
Send a
FS_ERRORmessage via fsnotify to a userspace monitoring tool whenever a ext4 error condition is triggered. This follows the existing error conditions in ext4, so it is hooked to the ext4_error* functions.Signed-off-by Gabriel Krisman Bertazi <[email protected]>
Looks good. Feel free to add:
Honza
Quoted 59 lines
---
Changes since v8:
- Report always report non-zero errno (Jan, Amir, Ted)
Changes since v6:
- Reportext4_std_errorsagains superblock (jan)--- fs/ext4/super.c | 8 ++++++++ 1 file changed, 8 insertions(+)fs/ext4/super.c +8
-0@@ -46,6 +46,7 @@#include <linux/part_stat.h> #include <linux/kthread.h> #include <linux/freezer.h> +#include <linux/fsnotify.h> #include "ext4.h" #include "ext4_extents.h" /* Needed for trace points definition */ @@ -759,6 +760,8 @@ void __ext4_error(struct super_block *sb, const char *function, sb->s_id, function, line, current->comm, &vaf);va_end (args); } +fsnotify_sb_error (sb,NULL , error ? error :EFSCORRUPTED ); +ext4_handle_error (sb, force_ro, error,0 , block, function, line); }@@ -789,6 +792,8 @@ void __ext4_error_inode(struct inode *inode, const char *function, current->comm, &vaf);va_end (args); } +fsnotify_sb_error (inode->i_sb, inode, error ? error :EFSCORRUPTED ); +ext4_handle_error (inode->i_sb, false, error, inode->i_ino, block, function, line); }@@ -827,6 +832,8 @@ void __ext4_error_file(struct file *file, const char *function, current->comm, path, &vaf);va_end (args); } +fsnotify_sb_error (inode->i_sb, inode,EFSCORRUPTED ); +ext4_handle_error (inode->i_sb, false,EFSCORRUPTED , inode->i_ino, block, function, line); }@@ -894,6 +901,7 @@ void __ext4_std_error(struct super_block *sb, const char *function,printk (KERN_CRIT "EXT4-fs error (device %s) in %s:%d: %s\n" , sb->s_id, function, line, errstr); } +fsnotify_sb_error (sb,NULL , errno ? errno :EFSCORRUPTED );ext4_handle_error (sb, false, -errno,0 ,0 , function, line); }Signature · 1 line
2.33.0
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
PATCH v9 30/31 samples: Add fs error monitoring example
In reply to Gabriel Krisman BertaziIntroduce an example of a FAN_FS_ERROR fanotify user to track filesystem errors.
---
Changes since v4:
- Protect file_handle defines with ifdef guards
Changes since v1:
- minor fixes
--- samples/Kconfig | 9 +++ samples/Makefile | 1 + samples/fanotify/Makefile | 5 ++ samples/fanotify/fs-monitor.c | 142 ++++++++++++++++++++++++++++++++++ 4 files changed, 157 insertions(+) create mode 100644 samples/fanotify/Makefile create mode 100644 samples/fanotify/fs-monitor.c
samples/Kconfig +9 -0
@@ -120,6 +120,15 @@ config SAMPLE_CONNECTOR with it. See also Documentation/driver-api/connector.rst +config SAMPLE_FANOTIFY_ERROR + bool "Build fanotify error monitoring sample" + depends on FANOTIFY + help + When enabled, this builds an example code that uses the + FAN_FS_ERROR fanotify mechanism to monitor filesystem + errors. + See also Documentation/admin-guide/filesystem-monitoring.rst. + config SAMPLE_HIDRAW bool "hidraw sample" depends on CC_CAN_LINK && HEADERS_INSTALL
samples/Makefile +1 -0
@@ -5,6 +5,7 @@ subdir-$(CONFIG_SAMPLE_AUXDISPLAY) += auxdisplay subdir-$(CONFIG_SAMPLE_ANDROID_BINDERFS) += binderfs obj-$(CONFIG_SAMPLE_CONFIGFS) += configfs/ obj-$(CONFIG_SAMPLE_CONNECTOR) += connector/ +obj-$(CONFIG_SAMPLE_FANOTIFY_ERROR) += fanotify/ subdir-$(CONFIG_SAMPLE_HIDRAW) += hidraw obj-$(CONFIG_SAMPLE_HW_BREAKPOINT) += hw_breakpoint/ obj-$(CONFIG_SAMPLE_KDB) += kdb/
samples/fanotify/Makefile new file +5 -0
@@ -0,0 +1,5 @@ +# SPDX-License-Identifier: GPL-2.0-only +userprogs-always-y += fs-monitor + +userccflags += -I usr/include -Wall +
samples/fanotify/fs-monitor.c new file +142 -0
142 lines not on this page · raw message
Signature · 1 line
2.33.0
PATCH v9 31/31 docs: Document the FAN_FS_ERROR event
In reply to Gabriel Krisman BertaziDocument the FAN_FS_ERROR event for user administrators and user space developers.
---
Changes Since v8:
- Replace fs-error specific errno bits with generic errno. (Jan)
- Explain event order guarantees and point to example parser (Jan)
Changes Since v7:
- Update semantics
Changes Since v6:
- English fixes (jan)
- Proper document error field (jan)
Changes Since v4:
- Update documentation about reporting non-file error.
Changes Since v3:
- Move FAN_FS_ERROR notification into a subsection of the file.
Changes Since v2:
- NTR
Changes since v1:
- Drop references to location record
- Explain that the inode field is optional
- Explain we are reporting only the first error
--- .../admin-guide/filesystem-monitoring.rst | 74 +++++++++++++++++++ Documentation/admin-guide/index.rst | 1 + 2 files changed, 75 insertions(+) create mode 100644 Documentation/admin-guide/filesystem-monitoring.rst
Documentation/admin-guide/filesystem-monitoring.rst new file +74 -0
@@ -0,0 +1,74 @@ +.. SPDX-License-Identifier: GPL-2.0 + +==================================== +File system Monitoring with fanotify +==================================== + +File system Error Reporting +=========================== + +Fanotify supports the FAN_FS_ERROR event type for file system-wide error +reporting. It is meant to be used by file system health monitoring +daemons, which listen for these events and take actions (notify +sysadmin, start recovery) when a file system problem is detected. + +By design, a FAN_FS_ERROR notification exposes sufficient information +for a monitoring tool to know a problem in the file system has happened. +It doesn't necessarily provide a user space application with semantics +to verify an IO operation was successfully executed. That is out of +scope for this feature. Instead, it is only meant as a framework for +early file system problem detection and reporting recovery tools. + +When a file system operation fails, it is common for dozens of kernel +errors to cascade after the initial failure, hiding the original failure +log, which is usually the most useful debug data to troubleshoot the +problem. For this reason, FAN_FS_ERROR tries to report only the first +error that occurred for a file system since the last notification, and +it simply counts additional errors. This ensures that the most +important pieces of information are never lost. + +FAN_FS_ERROR requires the fanotify group to be setup with the +FAN_REPORT_FID flag. + +At the time of this writing, the only file system that emits FAN_FS_ERROR +notifications is Ext4. + +A FAN_FS_ERROR Notification has the following format:: + + [ Notification Metadata (Mandatory) ] + [ Generic Error Record (Mandatory) ] + [ FID record (Mandatory) ] + +The order of records is not guaranteed, and new records might be added +in the future. Therefore, applications must not rely on the order and +must be prepared to skip over unknown records. Please refer to +``samples/fanotify/fs-monitor.c`` for an example parser. + +Generic error record +-------------------- + +The generic error record provides enough information for a file system +agnostic tool to learn about a problem in the file system, without +providing any additional details about the problem. This record is +identified by ``struct fanotify_event_info_header.info_type`` being set +to FAN_EVENT_INFO_TYPE_ERROR. + + struct fanotify_event_info_error { + struct fanotify_event_info_header hdr; + __s32 error; + __u32 error_count; + }; + +The `error` field identifies the type of error using errno values. +`error_count` tracks the number of errors that occurred and were +suppressed to preserve the original error information, since the last +notification. + +FID record +---------- + +The FID record can be used to uniquely identify the inode that triggered +the error through the combination of fsid and file handle. A file system +specific application can use that information to attempt a recovery +procedure. Errors that are not related to an inode are reported with an +empty file handle of type FILEID_INVALID.
Documentation/admin-guide/index.rst +1 -0
@@ -82,6 +82,7 @@ configure specific aspects of kernel behavior to your liking. edid efi-stub ext4 + filesystem-monitoring nfs/index gpio/index highuid
Signature · 1 line
2.33.0
Re: [PATCH v9 31/31] docs: Document the FAN_FS_ERROR event
Quoted 5 lines · Gabriel Krisman Bertazi
Document the
FAN_FS_ERRORevent for user administrators and user space developers.Reviewed-by Amir Goldstein <[email protected]>Signed-off-by Gabriel Krisman Bertazi <[email protected]>
Looks good. Feel free to add:
Honza
Quoted 121 lines
---
Changes Since v8:
- Replace fs-error specific errno bits with generic errno. (Jan)
- Explain event order guarantees and point to example parser (Jan)
Changes Since v7:
- Update semantics
Changes Since v6:
- English fixes (jan)
- Proper document error field (jan)
Changes Since v4:
- Update documentation about reporting non-file error.
Changes Since v3:
- MoveFAN_FS_ERRORnotification into a subsection of the file.
Changes Since v2:
- NTR
Changes since v1:
- Drop references to location record
- Explain that the inode field is optional
- Explain we are reporting only the first error--- .../admin-guide/filesystem-monitoring.rst | 74 +++++++++++++++++++ Documentation/admin-guide/index.rst | 1 + 2 files changed, 75 insertions(+) create mode 100644 Documentation/admin-guide/filesystem-monitoring.rstDocumentation/admin-guide/filesystem-monitoring.rst new file +74
-0@@ -0,0 +1,74 @@ +.. SPDX-License-Identifier: GPL-2.0 + +==================================== +File system Monitoring with fanotify +==================================== + +File system Error Reporting +=========================== + +Fanotify supports the FAN_FS_ERROR event type for file system-wide error +reporting. It is meant to be used by file system health monitoring +daemons, which listen for these events and take actions (notify +sysadmin, start recovery) when a file system problem is detected. + +By design, a FAN_FS_ERROR notification exposes sufficient information +for a monitoring tool to know a problem in the file system has happened. +It doesn't necessarily provide a user space application with semantics +to verify an IO operation was successfully executed. That is out of +scope for this feature. Instead, it is only meant as a framework for +early file system problem detection and reporting recovery tools. + +When a file system operation fails, it is common for dozens of kernel +errors to cascade after the initial failure, hiding the original failure +log, which is usually the most useful debug data to troubleshoot the +problem. For this reason, FAN_FS_ERROR tries to report only the first +error that occurred for a file system since the last notification, and +it simply counts additional errors. This ensures that the most +important pieces of information are never lost. + +FAN_FS_ERROR requires the fanotify group to be setup with the +FAN_REPORT_FID flag. + +At the time of this writing, the only file system that emits FAN_FS_ERROR +notifications is Ext4. + +A FAN_FS_ERROR Notification has the following format:: + + [ Notification Metadata (Mandatory) ] + [ Generic Error Record (Mandatory) ] + [ FID record (Mandatory) ] + +The order of records is not guaranteed, and new records might be added +in the future. Therefore, applications must not rely on the order and +must be prepared to skip over unknown records. Please refer to +``samples/fanotify/fs-monitor.c`` for an example parser. + +Generic error record +-------------------- + +The generic error record provides enough information for a file system +agnostic tool to learn about a problem in the file system, without +providing any additional details about the problem. This record is +identified by ``struct fanotify_event_info_header.info_type`` being set +to FAN_EVENT_INFO_TYPE_ERROR. + + struct fanotify_event_info_error { + struct fanotify_event_info_header hdr; + __s32 error; + __u32 error_count; + }; + +The `error` field identifies the type of error using errno values. +`error_count` tracks the number of errors that occurred and were +suppressed to preserve the original error information, since the last +notification. + +FID record +---------- + +The FID record can be used to uniquely identify the inode that triggered +the error through the combination of fsid and file handle. A file system +specific application can use that information to attempt a recovery +procedure. Errors that are not related to an inode are reported with an +empty file handle of type FILEID_INVALID.Documentation/admin-guide/index.rst +1
-0@@ -82,6 +82,7 @@ configure specific aspects of kernel behavior to your liking. edid efi-stub ext4 + filesystem-monitoring nfs/index gpio/index highuidSignature · 1 line
2.33.0
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Amir Goldstein
reviewerQuoted 12 lines · Gabriel Krisman Bertazi
Hi,
This is the 9th version of this patch series. Thank you, Amir, Jan and Ted, for the feedback in the previous versions.
The main difference in this version is that the pool is no longer resizeable nor limited in number of marks, even though we only pre-allocate 32 slots. In addition, ext4 was modified to always return non-zero errno, and the documentation was fixed accordingly (No longer suggests we return EXT4_ERR* values.
Quoted 5 lines
I also droped the Reviewed-by tags from the ext4 patch, due to the changes above.
Please let me know what you think.
All good on my end.
I've made a couple of minor comments that
could be addressed on commit if no other issues are found.
Thanks,
Amir.
Jan Kara
maintainerQuoted 17 lines · Amir Goldstein
Quoted 15 lines · Gabriel Krisman Bertazi
Hi,
This is the 9th version of this patch series. Thank you, Amir, Jan and Ted, for the feedback in the previous versions.
The main difference in this version is that the pool is no longer resizeable nor limited in number of marks, even though we only pre-allocate 32 slots. In addition, ext4 was modified to always return non-zero errno, and the documentation was fixed accordingly (No longer suggests we return EXT4_ERR* values.
I also droped the Reviewed-by tags from the ext4 patch, due to the changes above.
Quoted 6 lines
Quoted 2 lines
Please let me know what you think.
All good on my end.
I've made a couple of minor comments that
could be addressed on commit if no other issues are found.
All good on my end as well. I've applied all the minor updates, tested the result and pushed it out to fsnotify branch of my tree. WRT to your new FS_ERROR LTP tests, I've noticed that the testcases 1 and 3 from test fanotify20 fail for me. After a bit of debugging this seems to be a bug in ext4 where it calls ext4_abort() with EXT4_ERR_ESHUTDOWN instead of plain ESHUTDOWN. Not sure if you have that fixed or how come the tests passed for you. After fixing that ext4 bug everything passes for me.
Honza
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Amir Goldstein
reviewerQuoted 26 lines · Jan Kara
Quoted 17 lines · Amir Goldstein
Quoted 15 lines · Gabriel Krisman Bertazi
Hi,
This is the 9th version of this patch series. Thank you, Amir, Jan and Ted, for the feedback in the previous versions.
The main difference in this version is that the pool is no longer resizeable nor limited in number of marks, even though we only pre-allocate 32 slots. In addition, ext4 was modified to always return non-zero errno, and the documentation was fixed accordingly (No longer suggests we return EXT4_ERR* values.
I also droped the Reviewed-by tags from the ext4 patch, due to the changes above.
Quoted 6 lines
Quoted 2 lines
Please let me know what you think.
All good on my end.
I've made a couple of minor comments that
could be addressed on commit if no other issues are found.
Quoted 8 lines
All good on my end as well. I've applied all the minor updates, tested the result and pushed it out to fsnotify branch of my tree. WRT to your new
FS_ERRORLTP tests, I've noticed that the testcases 1 and 3 from test fanotify20 fail for me. After a bit of debugging this seems to be a bug in ext4 where it callsext4_abort()withEXT4_ERR_ESHUTDOWNinstead of plain ESHUTDOWN. Not sure if you have that fixed or how come the tests passed for you. After fixing that ext4 bug everything passes for me.
Gabriel mentioned that bug in the cover letter of the LTP series :-)
https://lore.kernel.org/linux-ext4/[email protected]/T/#u
Thanks,
Amir.
Quoted 36 lines · Amir Goldstein
Quoted 26 lines · Jan Kara
Quoted 17 lines · Amir Goldstein
Quoted 15 lines · Gabriel Krisman Bertazi
Hi,
This is the 9th version of this patch series. Thank you, Amir, Jan and Ted, for the feedback in the previous versions.
The main difference in this version is that the pool is no longer resizeable nor limited in number of marks, even though we only pre-allocate 32 slots. In addition, ext4 was modified to always return non-zero errno, and the documentation was fixed accordingly (No longer suggests we return EXT4_ERR* values.
I also droped the Reviewed-by tags from the ext4 patch, due to the changes above.
Quoted 6 lines
Quoted 2 lines
Please let me know what you think.
All good on my end.
I've made a couple of minor comments that
could be addressed on commit if no other issues are found.Quoted 8 lines
All good on my end as well. I've applied all the minor updates, tested the result and pushed it out to fsnotify branch of my tree. WRT to your new
FS_ERRORLTP tests, I've noticed that the testcases 1 and 3 from test fanotify20 fail for me. After a bit of debugging this seems to be a bug in ext4 where it callsext4_abort()withEXT4_ERR_ESHUTDOWNinstead of plain ESHUTDOWN. Not sure if you have that fixed or how come the tests passed for you. After fixing that ext4 bug everything passes for me.
Quoted 2 lines
Gabriel mentioned that bug in the cover letter of the LTP series :-)
https://lore.kernel.org/linux-ext4/[email protected]/T/#u
Yes :)
Also, thank you both for the extensive review and ideas during the development of this series. It was really appreciated!
I'm sending out the new version for tests + man pages today.
Signature · 1 line
Gabriel Krisman Bertazi
Amir Goldstein
reviewerQuoted 3 lines
Also, thank you both for the extensive review and ideas during the development of this series. It was really appreciated!
Thank you for your appreciated effort!
It was a wild journey through some interesting experiments, but you survived it well ;-)
Would you be interested in pursuing FAN_WB_ERROR after a due rest and after all the dust on FAN_FS_ERROR has settled?
FAN_WB_ERROR can use the same info record and same internal error event struct as FAN_FS_ERROR.
A call to fsnotify_wb_error(sb, inode, err) can be placed inside mapping_set_error() and maybe for other sporadic callers of errseq_set().
For wb error, we can consider storing a snapshot of errseq of the sb/inode in the sb/inode mark and compute error_count from the errseq diff instead of counting it when merging events. This will keep a more accurate report even when error reports are dropped due to allocation failure or event queue overflow.
I have a feeling that the Postgres project would find this functionality useful (?).
Thanks,
Amir.
Quoted 10 lines · Amir Goldstein
Quoted 3 lines
Also, thank you both for the extensive review and ideas during the development of this series. It was really appreciated!
Thank you for your appreciated effort!
It was a wild journey through some interesting experiments, but you survived it well ;-)Would you be interested in pursuing
FAN_WB_ERRORafter a due rest and after all the dust onFAN_FS_ERRORhas settled?
I think it would make sense for me to continue working on it, yes. But, before that, I think I still have some support to add to FAN_FS_ERROR, like a detailed, fs-specific, info record, and an error location info record, which has a use-case in Google Cloud environments. I have to discuss priorities internally, but we (collabora) do have an interest in supporting WB_ERROR too.
For the detailed error report, fanotify could have a new info record that carries a structure sent out by the file system. fanotify could handle the lifetime of this object, by keeping a larger mempool, or delegate its allocation/destruction to the filesystem.
Like I proposed in an earlier version of FAN_FS_ERROR, the format could be as simple as:
struct fanotify_error_data_info {
struct fanotify_event_info_header hdr;
char data[];
}
I think xfs, at least, would be able to make good use of this record with xfs_scrub, as the xfs maintainers mentioned.
Signature · 1 line
Gabriel Krisman Bertazi
Amir Goldstein
reviewerQuoted 21 lines · Gabriel Krisman Bertazi
Quoted 10 lines · Amir Goldstein
Quoted 3 lines
Also, thank you both for the extensive review and ideas during the development of this series. It was really appreciated!
Thank you for your appreciated effort!
It was a wild journey through some interesting experiments, but you survived it well ;-)Would you be interested in pursuing
FAN_WB_ERRORafter a due rest and after all the dust onFAN_FS_ERRORhas settled?I think it would make sense for me to continue working on it, yes. But, before that, I think I still have some support to add to
FAN_FS_ERROR, like a detailed, fs-specific, info record, and an error location info record, which has a use-case in Google Cloud environments. I have to discuss priorities internally, but we (collabora) do have an interest in supportingWB_ERRORtoo.
Quoted 5 lines
For the detailed error report, fanotify could have a new info record that carries a structure sent out by the file system. fanotify could handle the lifetime of this object, by keeping a larger mempool, or delegate its allocation/destruction to the filesystem.
Before you try anything radical, please check the size of prospect fs-specific data.
My hunch says that in most cases fs-specific data could fit cozy along side the file handle within MAX_HANDLE_SZ and if this is true, then we do not need to worry about extreme cases right now.
If there comes a time when we have a justified case of a filesystem that needs to report much bigger fs-specific data, we can consider it then. Until that time, we simply drop the over sized fs-specific data same as we do if filesystem passed in a file handle larger than MAX_HANDLE_SZ.
Quoted 8 lines
Like I proposed in an earlier version of
FAN_FS_ERROR, the format could be as simple as:struct fanotify_error_data_info { struct fanotify_event_info_header hdr; char data[]; }
We can add char data[] field to the end of struct fanotify_event_info_error. It does not change the layout nor size of the structure and the info record is variable size per definition anyway.
I know Jan didn't like this so much at the time and contemplated a separate info record for filename, but eventually, fanotify_event_info_fid also has an optional name following the unsigned char handle[].
Quoted 2 lines
I think xfs, at least, would be able to make good use of this record with
xfs_scrub, as the xfs maintainers mentioned.
I am not sure if that was the final conclusion.xfs_scrub is proactive and should have no problem reporting its own findings, but I have no objections to fs-specific details in FS_ERROR event.
Thanks,
Amir.