Merge tag 'fsnotify_for_v5.11-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/jack/linux-fs

Pull fsnotify updates from Jan Kara: "A few fsnotify fixes from Amir fixing fallout from big fsnotify overhaul a few months back and an improvement of defaults limiting maximum number of inotify watches from Waiman" * tag 'fsnotify_for_v5.11-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/jack/linux-fs: fsnotify: fix events reported to watching parent and child inotify: convert to handle_inode_event() interface fsnotify: generalize handle_inode_event() inotify: Increase default inotify.max_user_watches limit to 1048576

Linus Torvalds committed 5 years ago

Commit 14bd41e2 parents d652d5f fecc45511 files · +120 −104Browse files

Unified · Split

11 files

fs/nfsd/filecache.c +1 −1
fs/notify/dnotify/dnotify.c +1 −1
fs/notify/fanotify/fanotify.c +3 −4
fs/notify/fsnotify.c +71 −36
fs/notify/inotify/inotify.h +4 −5
fs/notify/inotify/inotify_fsnotify.c +8 −43
fs/notify/inotify/inotify_user.c +24 −7
include/linux/fsnotify_backend.h +5 −4
kernel/audit_fsnotify.c +1 −1
kernel/audit_tree.c +1 −1
kernel/audit_watch.c +1 −1

fs/nfsd/filecache.c+1−1

@@ -600,7 +600,7 @@ static struct notifier_block nfsd_file_lease_notifier = { · 599 unmodified lines
600	static int	600	static int
601	nfsd_file_fsnotify_handle_event(struct fsnotify_mark *mark, u32 mask,	601	nfsd_file_fsnotify_handle_event(struct fsnotify_mark *mark, u32 mask,
602	struct inode inode, struct inode dir,	602	struct inode inode, struct inode dir,
603	const struct qstr *name)	603	const struct qstr *name, u32 cookie)
604	{	604	{
605	trace_nfsd_file_fsnotify_handle_event(inode, mask);	605	trace_nfsd_file_fsnotify_handle_event(inode, mask);
606		606

fs/notify/dnotify/dnotify.c+1−1

@@ -72,7 +72,7 @@ static void dnotify_recalc_inode_mask(struct fsnotify_mark *fsn_mark) · 71 unmodified lines
72	*/	72	*/
73	static int dnotify_handle_event(struct fsnotify_mark *inode_mark, u32 mask,	73	static int dnotify_handle_event(struct fsnotify_mark *inode_mark, u32 mask,
74	struct inode inode, struct inode dir,	74	struct inode inode, struct inode dir,
75	const struct qstr *name)	75	const struct qstr *name, u32 cookie)
76	{	76	{
77	struct dnotify_mark *dn_mark;	77	struct dnotify_mark *dn_mark;
78	struct dnotify_struct *dn;	78	struct dnotify_struct *dn;

fs/notify/fanotify/fanotify.c+3−4

 			continue;
 		/*
-		 * If the event is for a child and this mark is on a parent not
+		 * If the event is on a child and this mark is on a parent not
 		 * watching children, don't send it!
 		 */
-		if (event_mask & FS_EVENT_ON_CHILD &&
+		if (type == FSNOTIFY_OBJ_TYPE_PARENT &&
-		    type == FSNOTIFY_OBJ_TYPE_INODE &&
+		    !(mark->mask & FS_EVENT_ON_CHILD))
-		     !(mark->mask & FS_EVENT_ON_CHILD))
 			continue;
 		marks_mask |= mark->mask;

fs/notify/fsnotify.c+71−36

 	if (mask & FS_ISDIR)
 		return false;
+	/*
+	 * All events that are possible on child can also may be reported with
+	 * parent/name info to inode/sb/mount.  Otherwise, a watching parent
+	 * could result in events reported with unexpected name info to sb/mount.
+	 */
+	BUILD_BUG_ON(FS_EVENTS_POSS_ON_CHILD & ~FS_EVENTS_POSS_TO_PARENT);
 	/* Did either inode/sb/mount subscribe for events with parent/name? */
 	marks_mask |= fsnotify_parent_needed_mask(inode->i_fsnotify_mask);
 	marks_mask |= fsnotify_parent_needed_mask(inode->i_sb->s_fsnotify_mask);
 }
 EXPORT_SYMBOL_GPL(__fsnotify_parent);
+static int fsnotify_handle_inode_event(struct fsnotify_group *group,
+				       struct fsnotify_mark *inode_mark,
+				       u32 mask, const void *data, int data_type,
+				       struct inode *dir, const struct qstr *name,
+				       u32 cookie)
+{
+	const struct path *path = fsnotify_data_path(data, data_type);
+	struct inode *inode = fsnotify_data_inode(data, data_type);
+	const struct fsnotify_ops *ops = group->ops;
+	if (WARN_ON_ONCE(!ops->handle_inode_event))
+		return 0;
+	if ((inode_mark->mask & FS_EXCL_UNLINK) &&
+	    path && d_unlinked(path->dentry))
+		return 0;
+	/* Check interest of this mark in case event was sent with two marks */
+	if (!(mask & inode_mark->mask & ALL_FSNOTIFY_EVENTS))
+		return 0;
+	return ops->handle_inode_event(inode_mark, mask, inode, dir, name, cookie);
+}
 static int fsnotify_handle_event(struct fsnotify_group *group, __u32 mask,
 				 const void *data, int data_type,
 				 struct inode *dir, const struct qstr *name,
 				 u32 cookie, struct fsnotify_iter_info *iter_info)
 {
 	struct fsnotify_mark *inode_mark = fsnotify_iter_inode_mark(iter_info);
-	struct fsnotify_mark *child_mark = fsnotify_iter_child_mark(iter_info);
+	struct fsnotify_mark *parent_mark = fsnotify_iter_parent_mark(iter_info);
-	struct inode *inode = fsnotify_data_inode(data, data_type);
-	const struct fsnotify_ops *ops = group->ops;
 	int ret;
-	if (WARN_ON_ONCE(!ops->handle_inode_event))
-		return 0;
 	if (WARN_ON_ONCE(fsnotify_iter_sb_mark(iter_info)) ||
 	    WARN_ON_ONCE(fsnotify_iter_vfsmount_mark(iter_info)))
 		return 0;
-	/*
+	if (parent_mark) {
-	 * An event can be sent on child mark iterator instead of inode mark
+		/*
-	 * iterator because of other groups that have interest of this inode
+		 * parent_mark indicates that the parent inode is watching
-	 * and have marks on both parent and child.  We can simplify this case.
+		 * children and interested in this event, which is an event
-	 */
+		 * possible on child. But is *this mark* watching children and
-	if (!inode_mark) {
+		 * interested in this event?
-		inode_mark = child_mark;
+		 */
-		child_mark = NULL;
+		if (parent_mark->mask & FS_EVENT_ON_CHILD) {
+			ret = fsnotify_handle_inode_event(group, parent_mark, mask,
+							  data, data_type, dir, name, 0);
+			if (ret)
+				return ret;
+		}
+		if (!inode_mark)
+			return 0;
+	}
+	if (mask & FS_EVENT_ON_CHILD) {
+		/*
+		 * Some events can be sent on both parent dir and child marks
+		 * (e.g. FS_ATTRIB).  If both parent dir and child are
+		 * watching, report the event once to parent dir with name (if
+		 * interested) and once to child without name (if interested).
+		 * The child watcher is expecting an event without a file name
+		 * and without the FS_EVENT_ON_CHILD flag.
+		 */
+		mask &= ~FS_EVENT_ON_CHILD;
 		dir = NULL;
 		name = NULL;
 	}
-	ret = ops->handle_inode_event(inode_mark, mask, inode, dir, name);
+	return fsnotify_handle_inode_event(group, inode_mark, mask, data, data_type,
-	if (ret || !child_mark)
+					   dir, name, cookie);
-		return ret;
-	/*
-	 * Some events can be sent on both parent dir and child marks
-	 * (e.g. FS_ATTRIB).  If both parent dir and child are watching,
-	 * report the event once to parent dir with name and once to child
-	 * without name.
-	 */
-	return ops->handle_inode_event(child_mark, mask, inode, NULL, NULL);
 }
 static int send_to_group(__u32 mask, const void *data, int data_type,
 	struct fsnotify_iter_info iter_info = {};
 	struct super_block *sb;
 	struct mount *mnt = NULL;
-	struct inode *child = NULL;
+	struct inode *parent = NULL;
 	int ret = 0;
 	__u32 test_mask, marks_mask;
 		inode = dir;
 	} else if (mask & FS_EVENT_ON_CHILD) {
 		/*
-		 * Event on child - report on TYPE_INODE to dir if it is
+		 * Event on child - report on TYPE_PARENT to dir if it is
-		 * watching children and on TYPE_CHILD to child.
+		 * watching children and on TYPE_INODE to child.
 		 */
-		child = inode;
+		parent = dir;
-		inode = dir;
 	}
 	sb = inode->i_sb;
 	if (!sb->s_fsnotify_marks &&
 	    (!mnt || !mnt->mnt_fsnotify_marks) &&
 	    (!inode || !inode->i_fsnotify_marks) &&
-	    (!child || !child->i_fsnotify_marks))
+	    (!parent || !parent->i_fsnotify_marks))
 		return 0;
 	marks_mask = sb->s_fsnotify_mask;
 		marks_mask |= mnt->mnt_fsnotify_mask;
 	if (inode)
 		marks_mask |= inode->i_fsnotify_mask;
-	if (child)
+	if (parent)
-		marks_mask |= child->i_fsnotify_mask;
+		marks_mask |= parent->i_fsnotify_mask;
 	/*
 		iter_info.marks[FSNOTIFY_OBJ_TYPE_INODE] =
 			fsnotify_first_mark(&inode->i_fsnotify_marks);
 	}
-	if (child) {
+	if (parent) {
-		iter_info.marks[FSNOTIFY_OBJ_TYPE_CHILD] =
+		iter_info.marks[FSNOTIFY_OBJ_TYPE_PARENT] =
-			fsnotify_first_mark(&child->i_fsnotify_marks);
+			fsnotify_first_mark(&parent->i_fsnotify_marks);
 	}
 	/*

fs/notify/inotify/inotify.h+4−5

@@ -24,11 +24,10 @@ static inline struct inotify_event_info INOTIFY_E(struct fsnotify_event fse) · 23 unmodified lines
24		24
25	extern void inotify_ignored_and_remove_idr(struct fsnotify_mark *fsn_mark,	25	extern void inotify_ignored_and_remove_idr(struct fsnotify_mark *fsn_mark,
26	struct fsnotify_group *group);	26	struct fsnotify_group *group);
27	extern int inotify_handle_event(struct fsnotify_group *group, u32 mask,	27	extern int inotify_handle_inode_event(struct fsnotify_mark *inode_mark,
28	const void *data, int data_type,	28	u32 mask, struct inode *inode,
29	struct inode *dir,	29	struct inode *dir,
30	const struct qstr *file_name, u32 cookie,	30	const struct qstr *name, u32 cookie);
31	struct fsnotify_iter_info *iter_info);
32		31
33	extern const struct fsnotify_ops inotify_fsnotify_ops;	32	extern const struct fsnotify_ops inotify_fsnotify_ops;
34	extern struct kmem_cache *inotify_inode_mark_cachep;	33	extern struct kmem_cache *inotify_inode_mark_cachep;

fs/notify/inotify/inotify_fsnotify.c+8−43

 	return event_compare(last_event, event);
 }
-static int inotify_one_event(struct fsnotify_group *group, u32 mask,
+int inotify_handle_inode_event(struct fsnotify_mark *inode_mark, u32 mask,
-			     struct fsnotify_mark *inode_mark,
+			       struct inode *inode, struct inode *dir,
-			     const struct path *path,
+			       const struct qstr *name, u32 cookie)
-			     const struct qstr *file_name, u32 cookie)
 {
 	struct inotify_inode_mark *i_mark;
 	struct inotify_event_info *event;
 	struct fsnotify_event *fsn_event;
+	struct fsnotify_group *group = inode_mark->group;
 	int ret;
 	int len = 0;
 	int alloc_len = sizeof(struct inotify_event_info);
 	struct mem_cgroup *old_memcg;
-	if ((inode_mark->mask & FS_EXCL_UNLINK) &&
+	if (name) {
-	    path && d_unlinked(path->dentry))
+		len = name->len;
-		return 0;
-	if (file_name) {
-		len = file_name->len;
 		alloc_len += len + 1;
 	}
 	event->sync_cookie = cookie;
 	event->name_len = len;
 	if (len)
-		strcpy(event->name, file_name->name);
+		strcpy(event->name, name->name);
 	ret = fsnotify_add_event(group, fsn_event, inotify_merge);
 	if (ret) {
 	return 0;
 }
-int inotify_handle_event(struct fsnotify_group *group, u32 mask,
-			 const void *data, int data_type, struct inode *dir,
-			 const struct qstr *file_name, u32 cookie,
-			 struct fsnotify_iter_info *iter_info)
-{
-	const struct path *path = fsnotify_data_path(data, data_type);
-	struct fsnotify_mark *inode_mark = fsnotify_iter_inode_mark(iter_info);
-	struct fsnotify_mark *child_mark = fsnotify_iter_child_mark(iter_info);
-	int ret = 0;
-	if (WARN_ON(fsnotify_iter_vfsmount_mark(iter_info)))
-		return 0;
-	/*
-	 * Some events cannot be sent on both parent and child marks
-	 * (e.g. IN_CREATE).  Those events are always sent on inode_mark.
-	 * For events that are possible on both parent and child (e.g. IN_OPEN),
-	 * event is sent on inode_mark with name if the parent is watching and
-	 * is sent on child_mark without name if child is watching.
-	 * If both parent and child are watching, report the event with child's
-	 * name here and report another event without child's name below.
-	 */
-	if (inode_mark)
-		ret = inotify_one_event(group, mask, inode_mark, path,
-					file_name, cookie);
-	if (ret || !child_mark)
-		return ret;
-	return inotify_one_event(group, mask, child_mark, path, NULL, 0);
-}
 static void inotify_freeing_mark(struct fsnotify_mark *fsn_mark, struct fsnotify_group *group)
 {
 	inotify_ignored_and_remove_idr(fsn_mark, group);
 }
 const struct fsnotify_ops inotify_fsnotify_ops = {
-	.handle_event = inotify_handle_event,
+	.handle_inode_event = inotify_handle_inode_event,
 	.free_group_priv = inotify_free_group_priv,
 	.free_event = inotify_free_event,
 	.freeing_mark = inotify_freeing_mark,

fs/notify/inotify/inotify_user.c+24−7

 #include <asm/ioctls.h>
+/*
+ * An inotify watch requires allocating an inotify_inode_mark structure as
+ * well as pinning the watched inode. Doubling the size of a VFS inode
+ * should be more than enough to cover the additional filesystem inode
+ * size increase.
+ */
+#define INOTIFY_WATCH_COST	(sizeof(struct inotify_inode_mark) + \
+				 2 * sizeof(struct inode))
 /* configurable via /proc/sys/fs/inotify/ */
 static int inotify_max_queued_events __read_mostly;
 				    struct fsnotify_group *group)
 {
 	struct inotify_inode_mark *i_mark;
-	struct fsnotify_iter_info iter_info = { };
-	fsnotify_iter_set_report_type_mark(&iter_info, FSNOTIFY_OBJ_TYPE_INODE,
-					   fsn_mark);
 	/* Queue ignore event for the watch */
-	inotify_handle_event(group, FS_IN_IGNORED, NULL, FSNOTIFY_EVENT_NONE,
+	inotify_handle_inode_event(fsn_mark, FS_IN_IGNORED, NULL, NULL, NULL,
-			     NULL, NULL, 0, &iter_info);
+				   0);
 	i_mark = container_of(fsn_mark, struct inotify_inode_mark, fsn_mark);
 	/* remove this mark from the idr */
  */
 static int __init inotify_user_setup(void)
 {
+	unsigned long watches_max;
+	struct sysinfo si;
+	si_meminfo(&si);
+	/*
+	 * Allow up to 1% of addressable memory to be allocated for inotify
+	 * watches (per user) limited to the range [8192, 1048576].
+	 */
+	watches_max = (((si.totalram - si.totalhigh) / 100) << PAGE_SHIFT) /
+			INOTIFY_WATCH_COST;
+	watches_max = clamp(watches_max, 8192UL, 1048576UL);
 	BUILD_BUG_ON(IN_ACCESS != FS_ACCESS);
 	BUILD_BUG_ON(IN_MODIFY != FS_MODIFY);
 	BUILD_BUG_ON(IN_ATTRIB != FS_ATTRIB);
 	inotify_max_queued_events = 16384;
 	init_user_ns.ucount_max[UCOUNT_INOTIFY_INSTANCES] = 128;
-	init_user_ns.ucount_max[UCOUNT_INOTIFY_WATCHES] = 8192;
+	init_user_ns.ucount_max[UCOUNT_INOTIFY_WATCHES] = watches_max;
 	return 0;
 }

include/linux/fsnotify_backend.h+5−4

  *		if @file_name is not NULL, this is the directory that
  *		@file_name is relative to.
  * @file_name:	optional file name associated with event
+ * @cookie:	inotify rename cookie
  *
  * free_group_priv - called when a group refcnt hits 0 to clean up the private union
  * freeing_mark - called when a mark is being destroyed for some reason.  The group
 			    struct fsnotify_iter_info *iter_info);
 	int (*handle_inode_event)(struct fsnotify_mark *mark, u32 mask,
 			    struct inode *inode, struct inode *dir,
-			    const struct qstr *file_name);
+			    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);
 enum fsnotify_obj_type {
 	FSNOTIFY_OBJ_TYPE_INODE,
-	FSNOTIFY_OBJ_TYPE_CHILD,
+	FSNOTIFY_OBJ_TYPE_PARENT,
 	FSNOTIFY_OBJ_TYPE_VFSMOUNT,
 	FSNOTIFY_OBJ_TYPE_SB,
 	FSNOTIFY_OBJ_TYPE_COUNT,
 };
 #define FSNOTIFY_OBJ_TYPE_INODE_FL	(1U << FSNOTIFY_OBJ_TYPE_INODE)
-#define FSNOTIFY_OBJ_TYPE_CHILD_FL	(1U << FSNOTIFY_OBJ_TYPE_CHILD)
+#define FSNOTIFY_OBJ_TYPE_PARENT_FL	(1U << FSNOTIFY_OBJ_TYPE_PARENT)
 #define FSNOTIFY_OBJ_TYPE_VFSMOUNT_FL	(1U << FSNOTIFY_OBJ_TYPE_VFSMOUNT)
 #define FSNOTIFY_OBJ_TYPE_SB_FL		(1U << FSNOTIFY_OBJ_TYPE_SB)
 #define FSNOTIFY_OBJ_ALL_TYPES_MASK	((1U << FSNOTIFY_OBJ_TYPE_COUNT) - 1)
 }
 FSNOTIFY_ITER_FUNCS(inode, INODE)
-FSNOTIFY_ITER_FUNCS(child, CHILD)
+FSNOTIFY_ITER_FUNCS(parent, PARENT)
 FSNOTIFY_ITER_FUNCS(vfsmount, VFSMOUNT)
 FSNOTIFY_ITER_FUNCS(sb, SB)

kernel/audit_fsnotify.c+1−1

@@ -154,7 +154,7 @@ static void audit_autoremove_mark_rule(struct audit_fsnotify_mark *audit_mark) · 153 unmodified lines
154	/* Update mark data in audit rules based on fsnotify events. */	154	/* Update mark data in audit rules based on fsnotify events. */
155	static int audit_mark_handle_event(struct fsnotify_mark *inode_mark, u32 mask,	155	static int audit_mark_handle_event(struct fsnotify_mark *inode_mark, u32 mask,
156	struct inode inode, struct inode dir,	156	struct inode inode, struct inode dir,
157	const struct qstr *dname)	157	const struct qstr *dname, u32 cookie)
158	{	158	{
159	struct audit_fsnotify_mark *audit_mark;	159	struct audit_fsnotify_mark *audit_mark;
160		160

kernel/audit_tree.c+1−1

@@ -1037,7 +1037,7 @@ static void evict_chunk(struct audit_chunk *chunk) · 1036 unmodified lines
1037		1037
1038	static int audit_tree_handle_event(struct fsnotify_mark *mark, u32 mask,	1038	static int audit_tree_handle_event(struct fsnotify_mark *mark, u32 mask,
1039	struct inode inode, struct inode dir,	1039	struct inode inode, struct inode dir,
1040	const struct qstr *file_name)	1040	const struct qstr *file_name, u32 cookie)
1041	{	1041	{
1042	return 0;	1042	return 0;
1043	}	1043	}

kernel/audit_watch.c+1−1

@@ -466,7 +466,7 @@ void audit_remove_watch_rule(struct audit_krule *krule) · 465 unmodified lines
466	/* Update watch data in audit rules based on fsnotify events. */	466	/* Update watch data in audit rules based on fsnotify events. */
467	static int audit_watch_handle_event(struct fsnotify_mark *inode_mark, u32 mask,	467	static int audit_watch_handle_event(struct fsnotify_mark *inode_mark, u32 mask,
468	struct inode inode, struct inode dir,	468	struct inode inode, struct inode dir,
469	const struct qstr *dname)	469	const struct qstr *dname, u32 cookie)
470	{	470	{
471	struct audit_parent *parent;	471	struct audit_parent *parent;
472		472

Merge tag 'fsnotify_for_v5.11-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/jack/linux-fs

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code