Skip to contentSkip to conversation

fsnotify: Avoid SRCU stalls with fanotify permission events

PATCH Superseded Jan Kara 2 participants 36 messages Jan 6, 2017 – Jan 10, 2017

Subsystems (6)

v2 of 7 Superseded Latest is v7 →

lore
Share & tools
lore

Jan Kara

author maintainer
#0 lore raw

v2 cover fsnotify: Avoid SRCU stalls with fanotify permission events

Hello,

This is the second revision of my patches to avoid SRCU stalls when fanotify waits for response to permission events from userspace processes. Thanks to Amir and Paul for review!

Changes since v1:
* renamed fsnotify_mark_list to fsnotify_mark_connector and couple other things
* updated some comments and changelogs to better explain what is going on
* made audit use inode pointer as a key again
* added Reviewed-by tags
* dropped two audit fixes that got already merged
* added cleanup of mark destruction functions

Patch set overview
------------------

Currently, fanotify waits for response to a permission even from userspace process while holding fsnotify_mark_srcu lock. That has a consequence that when userspace process takes long to respond or does not respond at all, fsnotify_mark_srcu period cannot ever complete blocking reclaim of any notification marks and also blocking any process that did synchronize_srcu() on fsnotify_mark_srcu. Effectively, this eventually blocks anybody interacting with the notification subsystem. Miklos has some real world reports of this happening. Although this in principle a problem of broken userspace application (which futhermore has to have CAP_SYS_ADMIN in init_user_ns, so it is not a security problem), it is still nasty that a simple error can block the kernel like this.

This patch set solves this problem. The basic idea of the solution is that when fanotify needs to wait for response from userspace process, it grabs reference to the mark which generated the event and drops fsnotify_mark_srcu lock. When userspace responds, we grab fsnotify_mark_srcu again, drop the mark reference, and continue iterating the list of marks attached to the inode / vfsmount delivering the event to other notification groups. What complicates this simple approach is that the mark for which we wait for response has to stay pinned in the list of marks attached to the inode / vfsmount so that we can resume iteration of the list when userspace responds but on the other hand when the inode gets unlinked while we wait for userspace reponse, we need to destroy the mark (or at least detach it from the inode).

The first 3 patches contain some initial fixes and cleanups. Patches 4-6 implement attaching of marks to inode / vfsmount via a dedicated structure which allows us to detach list of marks from the object without having to destroy the list itself. Patches 7-9 implement removal of mark from the list of marks attached to an object when last mark reference is dropped. Patches 10-13 then implement dropping of SRCU lock when waiting on response from userspace. Patches 14-22 are mostly trivial cleanups that get rid of trivial wrappers and one pointer in the mark structure.

Patches have survived testing with inotify/fanotify tests in LTP. I didn't test audit - Paul can you give these patches some testing? Since some of the changes are really non-trivial, I'd welcome if someone reviewed the patch set. Thanks!

Finally, to ease experimenting with the patches I've pushed them out to
git://git.kernel.org/pub/scm/linux/kernel/git/jack/linux-fs.git for_testing

Honza

author maintainer
#1 lore raw

PATCH v2 1/22 fsnotify: Remove unnecessary tests when showing fdinfo

show_fdinfo() iterates group's list of marks. All marks found there are guaranteed to be alive and they stay so until we release group->mark_mutex. So remove uncecessary tests whether mark is alive.

---
 fs/notify/fdinfo.c | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)
fs/notify/fdinfo.c +1 -5
index fd98e5100cab..601a59c8d87e 100644
@@ -76,8 +76,7 @@ static void inotify_fdinfo(struct seq_file *m, struct fsnotify_mark *mark)
 	struct inotify_inode_mark *inode_mark;
 	struct inode *inode;
 
-	if (!(mark->flags & FSNOTIFY_MARK_FLAG_ALIVE) ||
-	    !(mark->flags & FSNOTIFY_MARK_FLAG_INODE))
+	if (!(mark->flags & FSNOTIFY_MARK_FLAG_INODE))
 		return;
 
 	inode_mark = container_of(mark, struct inotify_inode_mark, fsn_mark);
@@ -113,9 +112,6 @@ static void fanotify_fdinfo(struct seq_file *m, struct fsnotify_mark *mark)
 	unsigned int mflags = 0;
 	struct inode *inode;
 
-	if (!(mark->flags & FSNOTIFY_MARK_FLAG_ALIVE))
-		return;
-
 	if (mark->flags & FSNOTIFY_MARK_FLAG_IGNORED_SURV_MODIFY)
 		mflags |= FAN_MARK_IGNORED_SURV_MODIFY;
 
Signature · 1 line
2.10.2
author maintainer
#2 lore raw

PATCH v2 2/22 inotify: Remove inode pointers from debug messages

In reply to Jan Kara

Printing inode pointers in warnings has dubious value and with future changes we won't be able to easily get them without either locking or chances we oops along the way. So just remove inode pointers from the warning messages.

---
 fs/notify/inotify/inotify_fsnotify.c |  4 ++--
 fs/notify/inotify/inotify_user.c     | 25 ++++++++++---------------
 2 files changed, 12 insertions(+), 17 deletions(-)
fs/notify/inotify/inotify_fsnotify.c +2 -2
index 19e7ec109a75..8421f44b3cb3 100644
@@ -155,8 +155,8 @@ static int idr_callback(int id, void *p, void *data)
 	 * BUG() that was here.
 	 */
 	if (fsn_mark)
-		printk(KERN_WARNING "fsn_mark->group=%p inode=%p wd=%d\n",
-			fsn_mark->group, fsn_mark->inode, i_mark->wd);
+		printk(KERN_WARNING "fsn_mark->group=%p wd=%d\n",
+			fsn_mark->group, i_mark->wd);
 	return 0;
 }
 
fs/notify/inotify/inotify_user.c +10 -15
index 69d1ea3d292a..3697567c7897 100644
@@ -431,18 +431,16 @@ static void inotify_remove_from_idr(struct fsnotify_group *group,
 	 * if it wasn't....
 	 */
 	if (wd == -1) {
-		WARN_ONCE(1, "%s: i_mark=%p i_mark->wd=%d i_mark->group=%p"
-			" i_mark->inode=%p\n", __func__, i_mark, i_mark->wd,
-			i_mark->fsn_mark.group, i_mark->fsn_mark.inode);
+		WARN_ONCE(1, "%s: i_mark=%p i_mark->wd=%d i_mark->group=%p\n",
+			__func__, i_mark, i_mark->wd, i_mark->fsn_mark.group);
 		goto out;
 	}
 
 	/* Lets look in the idr to see if we find it */
 	found_i_mark = inotify_idr_find_locked(group, wd);
 	if (unlikely(!found_i_mark)) {
-		WARN_ONCE(1, "%s: i_mark=%p i_mark->wd=%d i_mark->group=%p"
-			" i_mark->inode=%p\n", __func__, i_mark, i_mark->wd,
-			i_mark->fsn_mark.group, i_mark->fsn_mark.inode);
+		WARN_ONCE(1, "%s: i_mark=%p i_mark->wd=%d i_mark->group=%p\n",
+			__func__, i_mark, i_mark->wd, i_mark->fsn_mark.group);
 		goto out;
 	}
 
@@ -453,12 +451,10 @@ static void inotify_remove_from_idr(struct fsnotify_group *group,
 	 */
 	if (unlikely(found_i_mark != i_mark)) {
 		WARN_ONCE(1, "%s: i_mark=%p i_mark->wd=%d i_mark->group=%p "
-			"mark->inode=%p found_i_mark=%p found_i_mark->wd=%d "
-			"found_i_mark->group=%p found_i_mark->inode=%p\n",
-			__func__, i_mark, i_mark->wd, i_mark->fsn_mark.group,
-			i_mark->fsn_mark.inode, found_i_mark, found_i_mark->wd,
-			found_i_mark->fsn_mark.group,
-			found_i_mark->fsn_mark.inode);
+			"found_i_mark=%p found_i_mark->wd=%d "
+			"found_i_mark->group=%p\n", __func__, i_mark,
+			i_mark->wd, i_mark->fsn_mark.group, found_i_mark,
+			found_i_mark->wd, found_i_mark->fsn_mark.group);
 		goto out;
 	}
 
@@ -468,9 +464,8 @@ static void inotify_remove_from_idr(struct fsnotify_group *group,
 	 * one ref grabbed by inotify_idr_find
 	 */
 	if (unlikely(atomic_read(&i_mark->fsn_mark.refcnt) < 3)) {
-		printk(KERN_ERR "%s: i_mark=%p i_mark->wd=%d i_mark->group=%p"
-			" i_mark->inode=%p\n", __func__, i_mark, i_mark->wd,
-			i_mark->fsn_mark.group, i_mark->fsn_mark.inode);
+		printk(KERN_ERR "%s: i_mark=%p i_mark->wd=%d i_mark->group=%p\n",
+			 __func__, i_mark, i_mark->wd, i_mark->fsn_mark.group);
 		/* we can't really recover with bad ref cnting.. */
 		BUG();
 	}
Signature · 1 line
2.10.2
author maintainer
#3 lore raw

PATCH v2 3/22 fanotify: Move recalculation of inode / vfsmount mask under mark_mutex

In reply to Jan Kara

Move recalculation of inode / vfsmount notification mask under group->mark_mutex of the mark which was modified. These are the only places where mask recalculation happens without mark being protected from detaching from inode / vfsmount which will cause issues with the following patches.

---
 fs/notify/fanotify/fanotify_user.c | 15 ++++++---------
 1 file changed, 6 insertions(+), 9 deletions(-)
fs/notify/fanotify/fanotify_user.c +6 -9
index 7ebfca6a1427..8dcec9eecafd 100644
@@ -541,6 +541,8 @@ static int fanotify_remove_vfsmount_mark(struct fsnotify_group *group,
 
 	removed = fanotify_mark_remove_from_mask(fsn_mark, mask, flags,
 						 &destroy_mark);
+	if (removed & real_mount(mnt)->mnt_fsnotify_mask)
+		fsnotify_recalc_vfsmount_mask(mnt);
 	if (destroy_mark)
 		fsnotify_detach_mark(fsn_mark);
 	mutex_unlock(&group->mark_mutex);
@@ -548,9 +550,6 @@ static int fanotify_remove_vfsmount_mark(struct fsnotify_group *group,
 		fsnotify_free_mark(fsn_mark);
 
 	fsnotify_put_mark(fsn_mark);
-	if (removed & real_mount(mnt)->mnt_fsnotify_mask)
-		fsnotify_recalc_vfsmount_mask(mnt);
-
 	return 0;
 }
 
@@ -571,6 +570,8 @@ static int fanotify_remove_inode_mark(struct fsnotify_group *group,
 
 	removed = fanotify_mark_remove_from_mask(fsn_mark, mask, flags,
 						 &destroy_mark);
+	if (removed & inode->i_fsnotify_mask)
+		fsnotify_recalc_inode_mask(inode);
 	if (destroy_mark)
 		fsnotify_detach_mark(fsn_mark);
 	mutex_unlock(&group->mark_mutex);
@@ -579,8 +580,6 @@ static int fanotify_remove_inode_mark(struct fsnotify_group *group,
 
 	/* matches the fsnotify_find_inode_mark() */
 	fsnotify_put_mark(fsn_mark);
-	if (removed & inode->i_fsnotify_mask)
-		fsnotify_recalc_inode_mask(inode);
 
 	return 0;
 }
@@ -656,10 +655,9 @@ static int fanotify_add_vfsmount_mark(struct fsnotify_group *group,
 		}
 	}
 	added = fanotify_mark_add_to_mask(fsn_mark, mask, flags);
-	mutex_unlock(&group->mark_mutex);
-
 	if (added & ~real_mount(mnt)->mnt_fsnotify_mask)
 		fsnotify_recalc_vfsmount_mask(mnt);
+	mutex_unlock(&group->mark_mutex);
 
 	fsnotify_put_mark(fsn_mark);
 	return 0;
@@ -694,10 +692,9 @@ static int fanotify_add_inode_mark(struct fsnotify_group *group,
 		}
 	}
 	added = fanotify_mark_add_to_mask(fsn_mark, mask, flags);
-	mutex_unlock(&group->mark_mutex);
-
 	if (added & ~inode->i_fsnotify_mask)
 		fsnotify_recalc_inode_mask(inode);
+	mutex_unlock(&group->mark_mutex);
 
 	fsnotify_put_mark(fsn_mark);
 	return 0;
Signature · 1 line
2.10.2
author maintainer
#4 lore raw

PATCH v2 4/22 audit: Abstract hash key handling

In reply to Jan Kara

Audit tree currently uses inode pointer as a key into the hash table. Getting that from notification mark will be somewhat more difficult with coming fsnotify changes. So abstract getting of hash key from the audit chunk and inode so that we can change the method to obtain a key easily.

---
 kernel/audit_tree.c | 39 ++++++++++++++++++++++++++++-----------
 1 file changed, 28 insertions(+), 11 deletions(-)
kernel/audit_tree.c +28 -11
index 7b44195da81b..11c7ac441624 100644
@@ -163,33 +163,48 @@ enum {HASH_SIZE = 128};
 static struct list_head chunk_hash_heads[HASH_SIZE];
 static __cacheline_aligned_in_smp DEFINE_SPINLOCK(hash_lock);
 
-static inline struct list_head *chunk_hash(const struct inode *inode)
+/* Function to return search key in our hash from inode. */
+static unsigned long inode_to_key(const struct inode *inode)
 {
-	unsigned long n = (unsigned long)inode / L1_CACHE_BYTES;
+	return (unsigned long)inode;
+}
+
+/*
+ * Function to return search key in our hash from chunk. Key 0 is special and
+ * should never be present in the hash.
+ */
+static unsigned long chunk_to_key(struct audit_chunk *chunk)
+{
+	return (unsigned long)chunk->mark.inode;
+}
+
+static inline struct list_head *chunk_hash(unsigned long key)
+{
+	unsigned long n = key / L1_CACHE_BYTES;
 	return chunk_hash_heads + n % HASH_SIZE;
 }
 
 /* hash_lock & entry->lock is held by caller */
 static void insert_hash(struct audit_chunk *chunk)
 {
-	struct fsnotify_mark *entry = &chunk->mark;
+	unsigned long key = chunk_to_key(chunk);
 	struct list_head *list;
 
-	if (!entry->inode)
+	if (!key)
 		return;
-	list = chunk_hash(entry->inode);
+	list = chunk_hash(key);
 	list_add_rcu(&chunk->hash, list);
 }
 
 /* called under rcu_read_lock */
 struct audit_chunk *audit_tree_lookup(const struct inode *inode)
 {
-	struct list_head *list = chunk_hash(inode);
+	unsigned long key = inode_to_key(inode);
+	struct list_head *list = chunk_hash(key);
 	struct audit_chunk *p;
 
 	list_for_each_entry_rcu(p, list, hash) {
-		/* mark.inode may have gone NULL, but who cares? */
-		if (p->mark.inode == inode) {
+		if (chunk_to_key(p) == key) {
 			atomic_long_inc(&p->refs);
 			return p;
 		}
@@ -588,7 +603,8 @@ int audit_remove_tree_rule(struct audit_krule *rule)
 
 static int compare_root(struct vfsmount *mnt, void *arg)
 {
-	return d_backing_inode(mnt->mnt_root) == arg;
+	return inode_to_key(d_backing_inode(mnt->mnt_root)) ==
+	       (unsigned long)arg;
 }
 
 void audit_trim_trees(void)
@@ -623,9 +639,10 @@ void audit_trim_trees(void)
 		list_for_each_entry(node, &tree->chunks, list) {
 			struct audit_chunk *chunk = find_chunk(node);
 			/* this could be NULL if the watch is dying else where... */
-			struct inode *inode = chunk->mark.inode;
 			node->index |= 1U<<31;
-			if (iterate_mounts(compare_root, inode, root_mnt))
+			if (iterate_mounts(compare_root,
+					   (void *)chunk_to_key(chunk),
+					   root_mnt))
 				node->index &= ~(1U<<31);
 		}
 		spin_unlock(&hash_lock);
Signature · 1 line
2.10.2
author maintainer
#5 lore raw

PATCH v2 5/22 fsnotify: Update comments

In reply to Jan Kara

Add a comment that lifetime of a notification mark is protected by SRCU and remove a comment about clearing of marks attached to the inode. It is stale and more uptodate version is at fsnotify_destroy_marks() which is the function handling this case.

---
 fs/notify/mark.c | 13 +------------
 1 file changed, 1 insertion(+), 12 deletions(-)
fs/notify/mark.c +1 -12
index 6043306e8e21..44836e539169 100644
@@ -51,7 +51,7 @@
  *
  * LIFETIME:
  * Inode marks survive between when they are added to an inode and when their
- * refcnt==0.
+ * refcnt==0. Marks are also protected by fsnotify_mark_srcu.
  *
  * The inode mark can be cleared for a number of different reasons including:
  * - The inode is unlinked for the last time.  (fsnotify_inode_remove)
@@ -61,17 +61,6 @@
  * - The fsnotify_group associated with the mark is going away and all such marks
  *   need to be cleaned up. (fsnotify_clear_marks_by_group)
  *
- * Worst case we are given an inode and need to clean up all the marks on that
- * inode.  We take i_lock and walk the i_fsnotify_marks safely.  For each
- * mark on the list we take a reference (so the mark can't disappear under us).
- * We remove that mark form the inode's list of marks and we add this mark to a
- * private list anchored on the stack using i_free_list; we walk i_free_list
- * and before we destroy the mark we make sure that we dont race with a
- * concurrent destroy_group by getting a ref to the marks group and taking the
- * groups mutex.
-
- * Very similarly for freeing by group, except we use free_g_list.
- *
  * This has the very interesting property of being able to run concurrently with
  * any (or all) other directions.
  */
Signature · 1 line
2.10.2
author maintainer
#6 lore raw

PATCH v2 6/22 fsnotify: Attach marks to object via dedicated head structure

In reply to Jan Kara

Currently notification marks are attached to object (inode or vfsmnt) by a hlist_head in the object. The list is also protected by a spinlock in the object. So while there is any mark attached to the list of marks, the object must be pinned in memory (and thus e.g. last iput() deleting inode cannot happen). Also for list iteration in fsnotify() to work, we must hold fsnotify_mark_srcu lock so that mark itself and mark->obj_list.next cannot get freed. Thus we are required to wait for response to fanotify events from userspace process with fsnotify_mark_srcu lock held. That causes issues when userspace process is buggy and does not reply to some event - basically the whole notification subsystem gets eventually stuck.

So to be able to drop fsnotify_mark_srcu lock while waiting for response, we have to pin the mark in memory and make sure it stays in the object list (as removing the mark waiting for response could lead to lost notification events for groups later in the list). However we don't want inode reclaim to block on such mark as that would lead to system just locking up elsewhere.

This commit tries to pave a way towards solving these conflicting lifetime needs. Instead of anchoring the list of marks directly in the object, we anchor it in a dedicated structure (fsnotify_mark_connector) and just point to that structure from the object. Also the list is protected by a spinlock contained in that structure. With this, we can detach notification marks from object without having to modify the list itself.

---
 fs/inode.c                       |   3 -
 fs/mount.h                       |   2 +-
 fs/namespace.c                   |   3 -
 fs/notify/dnotify/dnotify.c      |   3 +-
 fs/notify/fdinfo.c               |  12 +-
 fs/notify/fsnotify.c             |  31 +++-
 fs/notify/fsnotify.h             |  38 +----
 fs/notify/inode_mark.c           |  94 +-----------
 fs/notify/mark.c                 | 316 +++++++++++++++++++++++++++++----------
 fs/notify/vfsmount_mark.c        |  64 +-------
 include/linux/fs.h               |   4 +-
 include/linux/fsnotify_backend.h |  43 ++++--
 kernel/audit_tree.c              |  30 +++-
 kernel/auditsc.c                 |   4 +-
 14 files changed, 339 insertions(+), 308 deletions(-)
fs/inode.c +0 -3
index 88110fd0b282..131b2bcebc48 100644
@@ -371,9 +371,6 @@ void inode_init_once(struct inode *inode)
 	INIT_LIST_HEAD(&inode->i_lru);
 	address_space_init_once(&inode->i_data);
 	i_size_ordered_init(inode);
-#ifdef CONFIG_FSNOTIFY
-	INIT_HLIST_HEAD(&inode->i_fsnotify_marks);
-#endif
 }
 EXPORT_SYMBOL(inode_init_once);
 
fs/mount.h +1 -1
index 2c856fc47ae3..e1dc79713abe 100644
@@ -59,7 +59,7 @@ struct mount {
 	struct mountpoint *mnt_mp;	/* where is it mounted */
 	struct hlist_node mnt_mp_list;	/* list mounts with the same mountpoint */
 #ifdef CONFIG_FSNOTIFY
-	struct hlist_head mnt_fsnotify_marks;
+	struct fsnotify_mark_connector __rcu *mnt_fsnotify_marks;
 	__u32 mnt_fsnotify_mask;
 #endif
 	int mnt_id;			/* mount identifier */
fs/namespace.c +0 -3
index b5b1259e064f..22a91352e2d7 100644
@@ -233,9 +233,6 @@ static struct mount *alloc_vfsmnt(const char *name)
 		INIT_LIST_HEAD(&mnt->mnt_slave_list);
 		INIT_LIST_HEAD(&mnt->mnt_slave);
 		INIT_HLIST_NODE(&mnt->mnt_mp_list);
-#ifdef CONFIG_FSNOTIFY
-		INIT_HLIST_HEAD(&mnt->mnt_fsnotify_marks);
-#endif
 		init_fs_pin(&mnt->mnt_umount, drop_mountpoint);
 	}
 	return mnt;
fs/notify/dnotify/dnotify.c +1 -2
index 5a4ec309e283..41b2a070761c 100644
@@ -69,8 +69,7 @@ static void dnotify_recalc_inode_mask(struct fsnotify_mark *fsn_mark)
 	if (old_mask == new_mask)
 		return;
 
-	if (fsn_mark->inode)
-		fsnotify_recalc_inode_mask(fsn_mark->inode);
+	fsnotify_recalc_mask(fsn_mark->connector);
 }
 
 /*
fs/notify/fdinfo.c +6 -6
index 601a59c8d87e..dd63aa9a6f9a 100644
@@ -76,11 +76,11 @@ static void inotify_fdinfo(struct seq_file *m, struct fsnotify_mark *mark)
 	struct inotify_inode_mark *inode_mark;
 	struct inode *inode;
 
-	if (!(mark->flags & FSNOTIFY_MARK_FLAG_INODE))
+	if (!(mark->connector->flags & FSNOTIFY_OBJ_TYPE_INODE))
 		return;
 
 	inode_mark = container_of(mark, struct inotify_inode_mark, fsn_mark);
-	inode = igrab(mark->inode);
+	inode = igrab(mark->connector->inode);
 	if (inode) {
 		/*
 		 * IN_ALL_EVENTS represents all of the mask bits
@@ -115,8 +115,8 @@ static void fanotify_fdinfo(struct seq_file *m, struct fsnotify_mark *mark)
 	if (mark->flags & FSNOTIFY_MARK_FLAG_IGNORED_SURV_MODIFY)
 		mflags |= FAN_MARK_IGNORED_SURV_MODIFY;
 
-	if (mark->flags & FSNOTIFY_MARK_FLAG_INODE) {
-		inode = igrab(mark->inode);
+	if (mark->connector->flags & FSNOTIFY_OBJ_TYPE_INODE) {
+		inode = igrab(mark->connector->inode);
 		if (!inode)
 			return;
 		seq_printf(m, "fanotify ino:%lx sdev:%x mflags:%x mask:%x ignored_mask:%x ",
@@ -125,8 +125,8 @@ static void fanotify_fdinfo(struct seq_file *m, struct fsnotify_mark *mark)
 		show_mark_fhandle(m, inode);
 		seq_putc(m, '\n');
 		iput(inode);
-	} else if (mark->flags & FSNOTIFY_MARK_FLAG_VFSMOUNT) {
-		struct mount *mnt = real_mount(mark->mnt);
+	} else if (mark->connector->flags & FSNOTIFY_OBJ_TYPE_VFSMOUNT) {
+		struct mount *mnt = real_mount(mark->connector->mnt);
 
 		seq_printf(m, "fanotify mnt_id:%x mflags:%x mask:%x ignored_mask:%x\n",
 			   mnt->mnt_id, mflags, mark->mask, mark->ignored_mask);
fs/notify/fsnotify.c +24 -7
index b41515d3f081..d512ef9f75fc 100644
@@ -193,6 +193,7 @@ int fsnotify(struct inode *to_tell, __u32 mask, const void *data, int data_is,
 	struct hlist_node *inode_node = NULL, *vfsmount_node = NULL;
 	struct fsnotify_mark *inode_mark = NULL, *vfsmount_mark = NULL;
 	struct fsnotify_group *inode_group, *vfsmount_group;
+	struct fsnotify_mark_connector *inode_conn, *vfsmount_conn;
 	struct mount *mnt;
 	int idx, ret = 0;
 	/* global tests shouldn't care about events on child only the specific event */
@@ -210,8 +211,8 @@ int fsnotify(struct inode *to_tell, __u32 mask, const void *data, int data_is,
 	 * SRCU because we have no references to any objects and do not
 	 * need SRCU to keep them "alive".
 	 */
-	if (hlist_empty(&to_tell->i_fsnotify_marks) &&
-	    (!mnt || hlist_empty(&mnt->mnt_fsnotify_marks)))
+	if (!to_tell->i_fsnotify_marks &&
+	    (!mnt || !mnt->mnt_fsnotify_marks))
 		return 0;
 	/*
 	 * if this is a modify event we may need to clear the ignored masks
@@ -226,16 +227,27 @@ int fsnotify(struct inode *to_tell, __u32 mask, const void *data, int data_is,
 	idx = srcu_read_lock(&fsnotify_mark_srcu);
 
 	if ((mask & FS_MODIFY) ||
-	    (test_mask & to_tell->i_fsnotify_mask))
-		inode_node = srcu_dereference(to_tell->i_fsnotify_marks.first,
+	    (test_mask & to_tell->i_fsnotify_mask)) {
+		inode_conn = srcu_dereference(to_tell->i_fsnotify_marks,
 					      &fsnotify_mark_srcu);
+		if (inode_conn)
+			inode_node = srcu_dereference(inode_conn->list.first,
+						      &fsnotify_mark_srcu);
+	}
 
 	if (mnt && ((mask & FS_MODIFY) ||
 		    (test_mask & mnt->mnt_fsnotify_mask))) {
-		vfsmount_node = srcu_dereference(mnt->mnt_fsnotify_marks.first,
-						 &fsnotify_mark_srcu);
-		inode_node = srcu_dereference(to_tell->i_fsnotify_marks.first,
+		inode_conn = srcu_dereference(to_tell->i_fsnotify_marks,
 					      &fsnotify_mark_srcu);
+		if (inode_conn)
+			inode_node = srcu_dereference(inode_conn->list.first,
+						      &fsnotify_mark_srcu);
+		vfsmount_conn = srcu_dereference(mnt->mnt_fsnotify_marks,
+					         &fsnotify_mark_srcu);
+		if (vfsmount_conn)
+			vfsmount_node = srcu_dereference(
+						vfsmount_conn->list.first,
+						&fsnotify_mark_srcu);
 	}
 
 	/*
@@ -293,6 +305,8 @@ int fsnotify(struct inode *to_tell, __u32 mask, const void *data, int data_is,
 }
 EXPORT_SYMBOL_GPL(fsnotify);
 
+extern struct kmem_cache *fsnotify_mark_connector_cachep;
+
 static __init int fsnotify_init(void)
 {
 	int ret;
@@ -303,6 +317,9 @@ static __init int fsnotify_init(void)
 	if (ret)
 		panic("initializing fsnotify_mark_srcu");
 
+	fsnotify_mark_connector_cachep = KMEM_CACHE(fsnotify_mark_connector,
+						    SLAB_PANIC);
+
 	return 0;
 }
 core_initcall(fsnotify_init);
fs/notify/fsnotify.h +8 -30
index 0a3bc2cf192c..24bc549e9709 100644
@@ -14,47 +14,25 @@ extern void fsnotify_flush_notify(struct fsnotify_group *group);
 /* protects reads of inode and vfsmount marks list */
 extern struct srcu_struct fsnotify_mark_srcu;
 
-/* Calculate mask of events for a list of marks */
-extern u32 fsnotify_recalc_mask(struct hlist_head *head);
-
 /* compare two groups for sorting of marks lists */
 extern int fsnotify_compare_groups(struct fsnotify_group *a,
 				   struct fsnotify_group *b);
 
-extern void fsnotify_set_inode_mark_mask_locked(struct fsnotify_mark *fsn_mark,
-						__u32 mask);
-/* Add mark to a proper place in mark list */
-extern int fsnotify_add_mark_list(struct hlist_head *head,
-				  struct fsnotify_mark *mark,
-				  int allow_dups);
-/* add a mark to an inode */
-extern int fsnotify_add_inode_mark(struct fsnotify_mark *mark,
-				   struct fsnotify_group *group, struct inode *inode,
-				   int allow_dups);
-/* add a mark to a vfsmount */
-extern int fsnotify_add_vfsmount_mark(struct fsnotify_mark *mark,
-				      struct fsnotify_group *group, struct vfsmount *mnt,
-				      int allow_dups);
-
-/* vfsmount specific destruction of a mark */
-extern void fsnotify_destroy_vfsmount_mark(struct fsnotify_mark *mark);
-/* inode specific destruction of a mark */
-extern void fsnotify_destroy_inode_mark(struct fsnotify_mark *mark);
-/* Find mark belonging to given group in the list of marks */
-extern struct fsnotify_mark *fsnotify_find_mark(struct hlist_head *head,
-						struct fsnotify_group *group);
-/* Destroy all marks in the given list protected by 'lock' */
-extern void fsnotify_destroy_marks(struct hlist_head *head, spinlock_t *lock);
+/* Find mark belonging to given group attached to given connector */
+extern struct fsnotify_mark *fsnotify_find_mark(
+					struct fsnotify_mark_connector **connp,
+					struct fsnotify_group *group);
+/* Destroy all marks connected via given connector */
+extern void fsnotify_destroy_marks(struct fsnotify_mark_connector **connp);
 /* run the list of all marks associated with inode and destroy them */
 static inline void fsnotify_clear_marks_by_inode(struct inode *inode)
 {
-	fsnotify_destroy_marks(&inode->i_fsnotify_marks, &inode->i_lock);
+	fsnotify_destroy_marks(&inode->i_fsnotify_marks);
 }
 /* run the list of all marks associated with vfsmount and destroy them */
 static inline void fsnotify_clear_marks_by_mount(struct vfsmount *mnt)
 {
-	fsnotify_destroy_marks(&real_mount(mnt)->mnt_fsnotify_marks,
-			       &mnt->mnt_root->d_lock);
+	fsnotify_destroy_marks(&real_mount(mnt)->mnt_fsnotify_marks);
 }
 /* prepare for freeing all marks associated with given group */
 extern void fsnotify_detach_group_marks(struct fsnotify_group *group);
fs/notify/inode_mark.c +3 -91

114 lines not on this page · raw message

fs/notify/mark.c +233 -83

441 lines not on this page · raw message

fs/notify/vfsmount_mark.c +4 -60

80 lines not on this page · raw message

include/linux/fs.h +3 -1
index 2ba074328894..8fc09316f996 100644
@@ -545,6 +545,8 @@ is_uncached_acl(struct posix_acl *acl)
 #define IOP_XATTR	0x0008
 #define IOP_DEFAULT_READLINK	0x0010
 
+struct fsnotify_mark_connector;
+
 /*
  * Keep mostly read-only and often accessed (especially for
  * the RCU path lookup and 'stat' data) fields at the beginning
@@ -644,7 +646,7 @@ struct inode {
 
 #ifdef CONFIG_FSNOTIFY
 	__u32			i_fsnotify_mask; /* all events this inode cares about */
-	struct hlist_head	i_fsnotify_marks;
+	struct fsnotify_mark_connector __rcu	*i_fsnotify_marks;
 #endif
 
 #if IS_ENABLED(CONFIG_FS_ENCRYPTION)
include/linux/fsnotify_backend.h +31 -12

70 lines not on this page · raw message

kernel/audit_tree.c +23 -7
index 11c7ac441624..a878a98f55b3 100644
@@ -172,10 +172,25 @@ static unsigned long inode_to_key(const struct inode *inode)
 /*
  * Function to return search key in our hash from chunk. Key 0 is special and
  * should never be present in the hash.
+ *
+ * Must be called with chunk->mark.lock held to protect from connector
+ * becoming NULL.
  */
+static unsigned long __chunk_to_key(struct audit_chunk *chunk)
+{
+	if (!chunk->mark.connector)
+		return 0;
+	return (unsigned long)chunk->mark.connector->inode;
+}
+
 static unsigned long chunk_to_key(struct audit_chunk *chunk)
 {
-	return (unsigned long)chunk->mark.inode;
+	unsigned long key;
+
+	spin_lock(&chunk->mark.lock);
+	key = __chunk_to_key(chunk);
+	spin_unlock(&chunk->mark.lock);
+	return key;
 }
 
 static inline struct list_head *chunk_hash(unsigned long key)
@@ -187,7 +202,7 @@ static inline struct list_head *chunk_hash(unsigned long key)
 /* hash_lock & entry->lock is held by caller */
 static void insert_hash(struct audit_chunk *chunk)
 {
-	unsigned long key = chunk_to_key(chunk);
+	unsigned long key = __chunk_to_key(chunk);
 	struct list_head *list;
 
 	if (!key)
@@ -248,7 +263,8 @@ static void untag_chunk(struct node *p)
 
 	mutex_lock(&entry->group->mark_mutex);
 	spin_lock(&entry->lock);
-	if (chunk->dead || !entry->inode) {
+	if (chunk->dead || !entry->connector ||
+	    !entry->connector->inode) {
 		spin_unlock(&entry->lock);
 		mutex_unlock(&entry->group->mark_mutex);
 		if (new)
@@ -276,8 +292,8 @@ static void untag_chunk(struct node *p)
 	if (!new)
 		goto Fallback;
 
-	if (fsnotify_add_mark_locked(&new->mark, entry->group, entry->inode,
-				     NULL, 1)) {
+	if (fsnotify_add_mark_locked(&new->mark, entry->group,
+				     entry->connector->inode, NULL, 1)) {
 		fsnotify_put_mark(&new->mark);
 		goto Fallback;
 	}
@@ -408,7 +424,7 @@ static int tag_chunk(struct inode *inode, struct audit_tree *tree)
 
 	mutex_lock(&old_entry->group->mark_mutex);
 	spin_lock(&old_entry->lock);
-	if (!old_entry->inode) {
+	if (!old_entry->connector || !old_entry->connector->inode) {
 		/* old_entry is being shot, lets just lie */
 		spin_unlock(&old_entry->lock);
 		mutex_unlock(&old_entry->group->mark_mutex);
@@ -418,7 +434,7 @@ static int tag_chunk(struct inode *inode, struct audit_tree *tree)
 	}
 
 	if (fsnotify_add_mark_locked(chunk_entry, old_entry->group,
-				     old_entry->inode, NULL, 1)) {
+			     old_entry->connector->inode, NULL, 1)) {
 		spin_unlock(&old_entry->lock);
 		mutex_unlock(&old_entry->group->mark_mutex);
 		fsnotify_put_mark(chunk_entry);
kernel/auditsc.c +2 -2
index cf1fa43512c1..e990de915341 100644
@@ -1591,7 +1591,7 @@ static inline void handle_one(const struct inode *inode)
 	struct audit_tree_refs *p;
 	struct audit_chunk *chunk;
 	int count;
-	if (likely(hlist_empty(&inode->i_fsnotify_marks)))
+	if (likely(!inode->i_fsnotify_marks))
 		return;
 	context = current->audit_context;
 	p = context->trees;
@@ -1634,7 +1634,7 @@ static void handle_path(const struct dentry *dentry)
 	seq = read_seqbegin(&rename_lock);
 	for(;;) {
 		struct inode *inode = d_backing_inode(d);
-		if (inode && unlikely(!hlist_empty(&inode->i_fsnotify_marks))) {
+		if (inode && unlikely(inode->i_fsnotify_marks)) {
 			struct audit_chunk *chunk;
 			chunk = audit_tree_lookup(inode);
 			if (chunk) {
Signature · 1 line
2.10.2
#7 lore raw

Re: [PATCH 06/22] fsnotify: Attach marks to object via dedicated head structure

Quoted 19 lines · Jan Kara

Currently notification marks are attached to object (inode or vfsmnt) by a hlist_head in the object. The list is also protected by a spinlock in the object. So while there is any mark attached to the list of marks, the object must be pinned in memory (and thus e.g. last iput() deleting inode cannot happen). Also for list iteration in fsnotify() to work, we must hold fsnotify_mark_srcu lock so that mark itself and mark->obj_list.next cannot get freed. Thus we are required to wait for response to fanotify events from userspace process with fsnotify_mark_srcu lock held. That causes issues when userspace process is buggy and does not reply to some event - basically the whole notification subsystem gets eventually stuck.

So to be able to drop fsnotify_mark_srcu lock while waiting for response, we have to pin the mark in memory and make sure it stays in the object list (as removing the mark waiting for response could lead to lost notification events for groups later in the list). However we don't want inode reclaim to block on such mark as that would lead to system just locking up elsewhere.

Quoted 8 lines

This commit tries to pave a way towards solving these conflicting lifetime needs. Instead of anchoring the list of marks directly in the object, we anchor it in a dedicated structure (fsnotify_mark_connector) and just point to that structure from the object. Also the list is protected by a spinlock contained in that structure. With this, we can detach notification marks from object without having to modify the list itself.

This looks much better to me then v1.
I reviewed most of the comments I gave for v1 on other patches. There was nothing more serious then inaccurate comment anyway.

I'll give the whole series another pass next week.

Amir.

Quoted 1,116 lines
---
 fs/inode.c                       |   3 -
 fs/mount.h                       |   2 +-
 fs/namespace.c                   |   3 -
 fs/notify/dnotify/dnotify.c      |   3 +-
 fs/notify/fdinfo.c               |  12 +-
 fs/notify/fsnotify.c             |  31 +++-
 fs/notify/fsnotify.h             |  38 +----
 fs/notify/inode_mark.c           |  94 +-----------
 fs/notify/mark.c                 | 316 +++++++++++++++++++++++++++++----------
 fs/notify/vfsmount_mark.c        |  64 +-------
 include/linux/fs.h               |   4 +-
 include/linux/fsnotify_backend.h |  43 ++++--
 kernel/audit_tree.c              |  30 +++-
 kernel/auditsc.c                 |   4 +-
 14 files changed, 339 insertions(+), 308 deletions(-)
fs/inode.c +0 -3
index 88110fd0b282..131b2bcebc48 100644
@@ -371,9 +371,6 @@ void inode_init_once(struct inode *inode)
        INIT_LIST_HEAD(&inode->i_lru);
        address_space_init_once(&inode->i_data);
        i_size_ordered_init(inode);
-#ifdef CONFIG_FSNOTIFY
-       INIT_HLIST_HEAD(&inode->i_fsnotify_marks);
-#endif
 }
 EXPORT_SYMBOL(inode_init_once);
 
fs/mount.h +1 -1
index 2c856fc47ae3..e1dc79713abe 100644
@@ -59,7 +59,7 @@ struct mount {
        struct mountpoint *mnt_mp;      /* where is it mounted */
        struct hlist_node mnt_mp_list;  /* list mounts with the same mountpoint */
 #ifdef CONFIG_FSNOTIFY
-       struct hlist_head mnt_fsnotify_marks;
+       struct fsnotify_mark_connector __rcu *mnt_fsnotify_marks;
        __u32 mnt_fsnotify_mask;
 #endif
        int mnt_id;                     /* mount identifier */
fs/namespace.c +0 -3
index b5b1259e064f..22a91352e2d7 100644
@@ -233,9 +233,6 @@ static struct mount *alloc_vfsmnt(const char *name)
                INIT_LIST_HEAD(&mnt->mnt_slave_list);
                INIT_LIST_HEAD(&mnt->mnt_slave);
                INIT_HLIST_NODE(&mnt->mnt_mp_list);
-#ifdef CONFIG_FSNOTIFY
-               INIT_HLIST_HEAD(&mnt->mnt_fsnotify_marks);
-#endif
                init_fs_pin(&mnt->mnt_umount, drop_mountpoint);
        }
        return mnt;
fs/notify/dnotify/dnotify.c +1 -2
index 5a4ec309e283..41b2a070761c 100644
@@ -69,8 +69,7 @@ static void dnotify_recalc_inode_mask(struct fsnotify_mark *fsn_mark)
        if (old_mask == new_mask)
                return;
 
-       if (fsn_mark->inode)
-               fsnotify_recalc_inode_mask(fsn_mark->inode);
+       fsnotify_recalc_mask(fsn_mark->connector);
 }
 
 /*
fs/notify/fdinfo.c +6 -6
index 601a59c8d87e..dd63aa9a6f9a 100644
@@ -76,11 +76,11 @@ static void inotify_fdinfo(struct seq_file *m, struct fsnotify_mark *mark)
        struct inotify_inode_mark *inode_mark;
        struct inode *inode;
 
-       if (!(mark->flags & FSNOTIFY_MARK_FLAG_INODE))
+       if (!(mark->connector->flags & FSNOTIFY_OBJ_TYPE_INODE))
                return;
 
        inode_mark = container_of(mark, struct inotify_inode_mark, fsn_mark);
-       inode = igrab(mark->inode);
+       inode = igrab(mark->connector->inode);
        if (inode) {
                /*
                 * IN_ALL_EVENTS represents all of the mask bits
@@ -115,8 +115,8 @@ static void fanotify_fdinfo(struct seq_file *m, struct fsnotify_mark *mark)
        if (mark->flags & FSNOTIFY_MARK_FLAG_IGNORED_SURV_MODIFY)
                mflags |= FAN_MARK_IGNORED_SURV_MODIFY;
 
-       if (mark->flags & FSNOTIFY_MARK_FLAG_INODE) {
-               inode = igrab(mark->inode);
+       if (mark->connector->flags & FSNOTIFY_OBJ_TYPE_INODE) {
+               inode = igrab(mark->connector->inode);
                if (!inode)
                        return;
                seq_printf(m, "fanotify ino:%lx sdev:%x mflags:%x mask:%x ignored_mask:%x ",
@@ -125,8 +125,8 @@ static void fanotify_fdinfo(struct seq_file *m, struct fsnotify_mark *mark)
                show_mark_fhandle(m, inode);
                seq_putc(m, '\n');
                iput(inode);
-       } else if (mark->flags & FSNOTIFY_MARK_FLAG_VFSMOUNT) {
-               struct mount *mnt = real_mount(mark->mnt);
+       } else if (mark->connector->flags & FSNOTIFY_OBJ_TYPE_VFSMOUNT) {
+               struct mount *mnt = real_mount(mark->connector->mnt);
 
                seq_printf(m, "fanotify mnt_id:%x mflags:%x mask:%x ignored_mask:%x\n",
                           mnt->mnt_id, mflags, mark->mask, mark->ignored_mask);
fs/notify/fsnotify.c +24 -7
index b41515d3f081..d512ef9f75fc 100644
@@ -193,6 +193,7 @@ int fsnotify(struct inode *to_tell, __u32 mask, const void *data, int data_is,
        struct hlist_node *inode_node = NULL, *vfsmount_node = NULL;
        struct fsnotify_mark *inode_mark = NULL, *vfsmount_mark = NULL;
        struct fsnotify_group *inode_group, *vfsmount_group;
+       struct fsnotify_mark_connector *inode_conn, *vfsmount_conn;
        struct mount *mnt;
        int idx, ret = 0;
        /* global tests shouldn't care about events on child only the specific event */
@@ -210,8 +211,8 @@ int fsnotify(struct inode *to_tell, __u32 mask, const void *data, int data_is,
         * SRCU because we have no references to any objects and do not
         * need SRCU to keep them "alive".
         */
-       if (hlist_empty(&to_tell->i_fsnotify_marks) &&
-           (!mnt || hlist_empty(&mnt->mnt_fsnotify_marks)))
+       if (!to_tell->i_fsnotify_marks &&
+           (!mnt || !mnt->mnt_fsnotify_marks))
                return 0;
        /*
         * if this is a modify event we may need to clear the ignored masks
@@ -226,16 +227,27 @@ int fsnotify(struct inode *to_tell, __u32 mask, const void *data, int data_is,
        idx = srcu_read_lock(&fsnotify_mark_srcu);
 
        if ((mask & FS_MODIFY) ||
-           (test_mask & to_tell->i_fsnotify_mask))
-               inode_node = srcu_dereference(to_tell->i_fsnotify_marks.first,
+           (test_mask & to_tell->i_fsnotify_mask)) {
+               inode_conn = srcu_dereference(to_tell->i_fsnotify_marks,
                                              &fsnotify_mark_srcu);
+               if (inode_conn)
+                       inode_node = srcu_dereference(inode_conn->list.first,
+                                                     &fsnotify_mark_srcu);
+       }
 
        if (mnt && ((mask & FS_MODIFY) ||
                    (test_mask & mnt->mnt_fsnotify_mask))) {
-               vfsmount_node = srcu_dereference(mnt->mnt_fsnotify_marks.first,
-                                                &fsnotify_mark_srcu);
-               inode_node = srcu_dereference(to_tell->i_fsnotify_marks.first,
+               inode_conn = srcu_dereference(to_tell->i_fsnotify_marks,
                                              &fsnotify_mark_srcu);
+               if (inode_conn)
+                       inode_node = srcu_dereference(inode_conn->list.first,
+                                                     &fsnotify_mark_srcu);
+               vfsmount_conn = srcu_dereference(mnt->mnt_fsnotify_marks,
+                                                &fsnotify_mark_srcu);
+               if (vfsmount_conn)
+                       vfsmount_node = srcu_dereference(
+                                               vfsmount_conn->list.first,
+                                               &fsnotify_mark_srcu);
        }
 
        /*
@@ -293,6 +305,8 @@ int fsnotify(struct inode *to_tell, __u32 mask, const void *data, int data_is,
 }
 EXPORT_SYMBOL_GPL(fsnotify);
 
+extern struct kmem_cache *fsnotify_mark_connector_cachep;
+
 static __init int fsnotify_init(void)
 {
        int ret;
@@ -303,6 +317,9 @@ static __init int fsnotify_init(void)
        if (ret)
                panic("initializing fsnotify_mark_srcu");
 
+       fsnotify_mark_connector_cachep = KMEM_CACHE(fsnotify_mark_connector,
+                                                   SLAB_PANIC);
+
        return 0;
 }
 core_initcall(fsnotify_init);
fs/notify/fsnotify.h +8 -30
index 0a3bc2cf192c..24bc549e9709 100644
@@ -14,47 +14,25 @@ extern void fsnotify_flush_notify(struct fsnotify_group *group);
 /* protects reads of inode and vfsmount marks list */
 extern struct srcu_struct fsnotify_mark_srcu;
 
-/* Calculate mask of events for a list of marks */
-extern u32 fsnotify_recalc_mask(struct hlist_head *head);
-
 /* compare two groups for sorting of marks lists */
 extern int fsnotify_compare_groups(struct fsnotify_group *a,
                                   struct fsnotify_group *b);
 
-extern void fsnotify_set_inode_mark_mask_locked(struct fsnotify_mark *fsn_mark,
-                                               __u32 mask);
-/* Add mark to a proper place in mark list */
-extern int fsnotify_add_mark_list(struct hlist_head *head,
-                                 struct fsnotify_mark *mark,
-                                 int allow_dups);
-/* add a mark to an inode */
-extern int fsnotify_add_inode_mark(struct fsnotify_mark *mark,
-                                  struct fsnotify_group *group, struct inode *inode,
-                                  int allow_dups);
-/* add a mark to a vfsmount */
-extern int fsnotify_add_vfsmount_mark(struct fsnotify_mark *mark,
-                                     struct fsnotify_group *group, struct vfsmount *mnt,
-                                     int allow_dups);
-
-/* vfsmount specific destruction of a mark */
-extern void fsnotify_destroy_vfsmount_mark(struct fsnotify_mark *mark);
-/* inode specific destruction of a mark */
-extern void fsnotify_destroy_inode_mark(struct fsnotify_mark *mark);
-/* Find mark belonging to given group in the list of marks */
-extern struct fsnotify_mark *fsnotify_find_mark(struct hlist_head *head,
-                                               struct fsnotify_group *group);
-/* Destroy all marks in the given list protected by 'lock' */
-extern void fsnotify_destroy_marks(struct hlist_head *head, spinlock_t *lock);
+/* Find mark belonging to given group attached to given connector */
+extern struct fsnotify_mark *fsnotify_find_mark(
+                                       struct fsnotify_mark_connector **connp,
+                                       struct fsnotify_group *group);
+/* Destroy all marks connected via given connector */
+extern void fsnotify_destroy_marks(struct fsnotify_mark_connector **connp);
 /* run the list of all marks associated with inode and destroy them */
 static inline void fsnotify_clear_marks_by_inode(struct inode *inode)
 {
-       fsnotify_destroy_marks(&inode->i_fsnotify_marks, &inode->i_lock);
+       fsnotify_destroy_marks(&inode->i_fsnotify_marks);
 }
 /* run the list of all marks associated with vfsmount and destroy them */
 static inline void fsnotify_clear_marks_by_mount(struct vfsmount *mnt)
 {
-       fsnotify_destroy_marks(&real_mount(mnt)->mnt_fsnotify_marks,
-                              &mnt->mnt_root->d_lock);
+       fsnotify_destroy_marks(&real_mount(mnt)->mnt_fsnotify_marks);
 }
 /* prepare for freeing all marks associated with given group */
 extern void fsnotify_detach_group_marks(struct fsnotify_group *group);
fs/notify/inode_mark.c +3 -91
index a3645249f7ec..b9370316727e 100644
@@ -30,38 +30,9 @@
 
 #include "../internal.h"
 
-/*
- * Recalculate the inode->i_fsnotify_mask, or the mask of all FS_* event types
- * any notifier is interested in hearing for this inode.
- */
 void fsnotify_recalc_inode_mask(struct inode *inode)
 {
-       spin_lock(&inode->i_lock);
-       inode->i_fsnotify_mask = fsnotify_recalc_mask(&inode->i_fsnotify_marks);
-       spin_unlock(&inode->i_lock);
-
-       __fsnotify_update_child_dentry_flags(inode);
-}
-
-void fsnotify_destroy_inode_mark(struct fsnotify_mark *mark)
-{
-       struct inode *inode = mark->inode;
-
-       BUG_ON(!mutex_is_locked(&mark->group->mark_mutex));
-       assert_spin_locked(&mark->lock);
-
-       spin_lock(&inode->i_lock);
-
-       hlist_del_init_rcu(&mark->obj_list);
-       mark->inode = NULL;
-
-       /*
-        * this mark is now off the inode->i_fsnotify_marks list and we
-        * hold the inode->i_lock, so this is the perfect time to update the
-        * inode->i_fsnotify_mask
-        */
-       inode->i_fsnotify_mask = fsnotify_recalc_mask(&inode->i_fsnotify_marks);
-       spin_unlock(&inode->i_lock);
+       fsnotify_recalc_mask(inode->i_fsnotify_marks);
 }
 
 /*
@@ -69,7 +40,7 @@ void fsnotify_destroy_inode_mark(struct fsnotify_mark *mark)
  */
 void fsnotify_clear_inode_marks_by_group(struct fsnotify_group *group)
 {
-       fsnotify_clear_marks_by_group_flags(group, FSNOTIFY_MARK_FLAG_INODE);
+       fsnotify_clear_marks_by_group_flags(group, FSNOTIFY_OBJ_TYPE_INODE);
 }
 
 /*
@@ -79,66 +50,7 @@ void fsnotify_clear_inode_marks_by_group(struct fsnotify_group *group)
 struct fsnotify_mark *fsnotify_find_inode_mark(struct fsnotify_group *group,
                                               struct inode *inode)
 {
-       struct fsnotify_mark *mark;
-
-       spin_lock(&inode->i_lock);
-       mark = fsnotify_find_mark(&inode->i_fsnotify_marks, group);
-       spin_unlock(&inode->i_lock);
-
-       return mark;
-}
-
-/*
- * If we are setting a mark mask on an inode mark we should pin the inode
- * in memory.
- */
-void fsnotify_set_inode_mark_mask_locked(struct fsnotify_mark *mark,
-                                        __u32 mask)
-{
-       struct inode *inode;
-
-       assert_spin_locked(&mark->lock);
-
-       if (mask &&
-           mark->inode &&
-           !(mark->flags & FSNOTIFY_MARK_FLAG_OBJECT_PINNED)) {
-               mark->flags |= FSNOTIFY_MARK_FLAG_OBJECT_PINNED;
-               inode = igrab(mark->inode);
-               /*
-                * we shouldn't be able to get here if the inode wasn't
-                * already safely held in memory.  But bug in case it
-                * ever is wrong.
-                */
-               BUG_ON(!inode);
-       }
-}
-
-/*
- * Attach an initialized mark to a given inode.
- * These marks may be used for the fsnotify backend to determine which
- * event types should be delivered to which group and for which inodes.  These
- * marks are ordered according to priority, highest number first, and then by
- * the group's location in memory.
- */
-int fsnotify_add_inode_mark(struct fsnotify_mark *mark,
-                           struct fsnotify_group *group, struct inode *inode,
-                           int allow_dups)
-{
-       int ret;
-
-       mark->flags |= FSNOTIFY_MARK_FLAG_INODE;
-
-       BUG_ON(!mutex_is_locked(&group->mark_mutex));
-       assert_spin_locked(&mark->lock);
-
-       spin_lock(&inode->i_lock);
-       mark->inode = inode;
-       ret = fsnotify_add_mark_list(&inode->i_fsnotify_marks, mark,
-                                    allow_dups);
-       inode->i_fsnotify_mask = fsnotify_recalc_mask(&inode->i_fsnotify_marks);
-       spin_unlock(&inode->i_lock);
-
-       return ret;
+       return fsnotify_find_mark(&inode->i_fsnotify_marks, group);
 }
 
 /**
fs/notify/mark.c +233 -83
index 44836e539169..97c68589742e 100644
@@ -33,7 +33,7 @@
  *
  * group->mark_mutex
  * mark->lock
- * inode->i_lock
+ * mark->connector->lock
  *
  * group->mark_mutex protects the marks_list anchored inside a given group and
  * each mark is hooked via the g_list.  It also protects the groups private
@@ -44,10 +44,12 @@
  * is assigned to as well as the access to a reference of the inode/vfsmount
  * that is being watched by the mark.
  *
- * inode->i_lock protects the i_fsnotify_marks list anchored inside a
- * given inode and each mark is hooked via the i_list. (and sorta the
- * free_i_list)
+ * mark->connector->lock protects the list of marks anchored inside an
+ * inode / vfsmount and each mark is hooked via the i_list.
  *
+ * A list of notification marks relating to inode / mnt is contained in
+ * fsnotify_mark_connector. That structure is alive as long as there are any marks
+ * in the list and is also protected by fsnotify_mark_srcu.
  *
  * LIFETIME:
  * Inode marks survive between when they are added to an inode and when their
@@ -83,12 +85,18 @@
 #define FSNOTIFY_REAPER_DELAY  (1)     /* 1 jiffy */
 
 struct srcu_struct fsnotify_mark_srcu;
+struct kmem_cache *fsnotify_mark_connector_cachep;
+
 static DEFINE_SPINLOCK(destroy_lock);
 static LIST_HEAD(destroy_list);
+static struct fsnotify_mark_connector *connector_destroy_list;
 
 static void fsnotify_mark_destroy_workfn(struct work_struct *work);
 static DECLARE_DELAYED_WORK(reaper_work, fsnotify_mark_destroy_workfn);
 
+static void fsnotify_connector_destroy_workfn(struct work_struct *work);
+static DECLARE_WORK(connector_reaper_work, fsnotify_connector_destroy_workfn);
+
 void fsnotify_get_mark(struct fsnotify_mark *mark)
 {
        atomic_inc(&mark->refcnt);
@@ -103,15 +111,97 @@ void fsnotify_put_mark(struct fsnotify_mark *mark)
        }
 }
 
-/* Calculate mask of events for a list of marks */
-u32 fsnotify_recalc_mask(struct hlist_head *head)
+static void __fsnotify_recalc_mask(struct fsnotify_mark_connector *conn)
 {
        u32 new_mask = 0;
        struct fsnotify_mark *mark;
 
-       hlist_for_each_entry(mark, head, obj_list)
-               new_mask |= mark->mask;
-       return new_mask;
+       assert_spin_locked(&conn->lock);
+       hlist_for_each_entry(mark, &conn->list, obj_list) {
+               if (mark->flags & FSNOTIFY_MARK_FLAG_ATTACHED)
+                       new_mask |= mark->mask;
+       }
+       if (conn->flags & FSNOTIFY_OBJ_TYPE_INODE)
+               conn->inode->i_fsnotify_mask = new_mask;
+       else if (conn->flags & FSNOTIFY_OBJ_TYPE_VFSMOUNT)
+               real_mount(conn->mnt)->mnt_fsnotify_mask = new_mask;
+}
+
+/*
+ * Calculate mask of events for a list of marks. The caller must make sure list
+ * cannot disappear under us (usually by holding a mark->lock or
+ * mark->group->mark_mutex for a mark on this list).
+ */
+void fsnotify_recalc_mask(struct fsnotify_mark_connector *conn)
+{
+       struct inode *inode = NULL;
+
+       spin_lock(&conn->lock);
+       __fsnotify_recalc_mask(conn);
+       if (conn->flags & FSNOTIFY_OBJ_TYPE_INODE)
+               inode = igrab(conn->inode);
+       spin_unlock(&conn->lock);
+       if (inode) {
+               __fsnotify_update_child_dentry_flags(inode);
+               iput(inode);
+       }
+}
+
+/* Free all connectors queued for freeing once SRCU period ends */
+static void fsnotify_connector_destroy_workfn(struct work_struct *work)
+{
+       struct fsnotify_mark_connector *conn, *free;
+
+       spin_lock(&destroy_lock);
+       conn = connector_destroy_list;
+       connector_destroy_list = NULL;
+       spin_unlock(&destroy_lock);
+
+       synchronize_srcu(&fsnotify_mark_srcu);
+       while (conn) {
+               free = conn;
+               conn = conn->destroy_next;
+               kmem_cache_free(fsnotify_mark_connector_cachep, free);
+       }
+}
+
+static struct inode *fsnotify_detach_from_object(struct fsnotify_mark *mark)
+{
+       struct fsnotify_mark_connector *conn;
+       struct inode *inode = NULL;
+       bool free_conn = false;
+
+       conn = mark->connector;
+       spin_lock(&conn->lock);
+       hlist_del_init_rcu(&mark->obj_list);
+       if (hlist_empty(&conn->list)) {
+               if (conn->flags & FSNOTIFY_OBJ_TYPE_INODE) {
+                       inode = conn->inode;
+                       inode->i_fsnotify_marks = NULL;
+                       inode->i_fsnotify_mask = 0;
+                       conn->inode = NULL;
+                       conn->flags &= ~FSNOTIFY_OBJ_TYPE_INODE;
+               } else if (conn->flags & FSNOTIFY_OBJ_TYPE_VFSMOUNT) {
+                       real_mount(conn->mnt)->mnt_fsnotify_marks = NULL;
+                       real_mount(conn->mnt)->mnt_fsnotify_mask = 0;
+                       conn->mnt = NULL;
+                       conn->flags &= ~FSNOTIFY_OBJ_TYPE_VFSMOUNT;
+               }
+               free_conn = true;
+       } else
+               __fsnotify_recalc_mask(conn);
+       mark->connector = NULL;
+       spin_unlock(&conn->lock);
+
+       if (free_conn) {
+               spin_lock(&destroy_lock);
+               conn->destroy_next = connector_destroy_list;
+               connector_destroy_list = conn;
+               spin_unlock(&destroy_lock);
+               queue_work(system_unbound_wq, &connector_reaper_work);
+       }
+
+       return inode;
 }
 
 /*
@@ -137,13 +227,8 @@ void fsnotify_detach_mark(struct fsnotify_mark *mark)
 
        mark->flags &= ~FSNOTIFY_MARK_FLAG_ATTACHED;
 
-       if (mark->flags & FSNOTIFY_MARK_FLAG_INODE) {
-               inode = mark->inode;
-               fsnotify_destroy_inode_mark(mark);
-       } else if (mark->flags & FSNOTIFY_MARK_FLAG_VFSMOUNT)
-               fsnotify_destroy_vfsmount_mark(mark);
-       else
-               BUG();
+       inode = fsnotify_detach_from_object(mark);
+
        /*
         * Note that we didn't update flags telling whether inode cares about
         * what's happening with children. We update these flags from
@@ -155,7 +240,7 @@ void fsnotify_detach_mark(struct fsnotify_mark *mark)
 
        spin_unlock(&mark->lock);
 
-       if (inode && (mark->flags & FSNOTIFY_MARK_FLAG_OBJECT_PINNED))
+       if (inode)
                iput(inode);
 
        atomic_dec(&group->num_marks);
@@ -220,45 +305,11 @@ void fsnotify_destroy_mark(struct fsnotify_mark *mark,
        fsnotify_free_mark(mark);
 }
 
-void fsnotify_destroy_marks(struct hlist_head *head, spinlock_t *lock)
-{
-       struct fsnotify_mark *mark;
-
-       while (1) {
-               /*
-                * We have to be careful since we can race with e.g.
-                * fsnotify_clear_marks_by_group() and once we drop 'lock',
-                * mark can get removed from the obj_list and destroyed. But
-                * we are holding mark reference so mark cannot be freed and
-                * calling fsnotify_destroy_mark() more than once is fine.
-                */
-               spin_lock(lock);
-               if (hlist_empty(head)) {
-                       spin_unlock(lock);
-                       break;
-               }
-               mark = hlist_entry(head->first, struct fsnotify_mark, obj_list);
-               /*
-                * We don't update i_fsnotify_mask / mnt_fsnotify_mask here
-                * since inode / mount is going away anyway. So just remove
-                * mark from the list.
-                */
-               hlist_del_init_rcu(&mark->obj_list);
-               fsnotify_get_mark(mark);
-               spin_unlock(lock);
-               fsnotify_destroy_mark(mark, mark->group);
-               fsnotify_put_mark(mark);
-       }
-}
-
 void fsnotify_set_mark_mask_locked(struct fsnotify_mark *mark, __u32 mask)
 {
        assert_spin_locked(&mark->lock);
 
        mark->mask = mask;
-
-       if (mark->flags & FSNOTIFY_MARK_FLAG_INODE)
-               fsnotify_set_inode_mark_mask_locked(mark, mask);
 }
 
 void fsnotify_set_mark_ignored_mask_locked(struct fsnotify_mark *mark, __u32 mask)
@@ -304,37 +355,118 @@ int fsnotify_compare_groups(struct fsnotify_group *a, struct fsnotify_group *b)
        return -1;
 }
 
-/* Add mark into proper place in given list of marks */
-int fsnotify_add_mark_list(struct hlist_head *head, struct fsnotify_mark *mark,
-                          int allow_dups)
+/*
+ * Get mark connector, make sure it is alive and return with its lock held.
+ * This is for users that get connector pointer from inode or mount. Users that
+ * hold reference to a mark on the list may directly lock connector->lock as
+ * they are sure list cannot go away under them.
+ */
+static struct fsnotify_mark_connector *fsnotify_grab_connector(
+                               struct fsnotify_mark_connector * __rcu *connp)
+{
+       struct fsnotify_mark_connector *conn;
+       int idx;
+
+       idx = srcu_read_lock(&fsnotify_mark_srcu);
+       conn = srcu_dereference(*connp, &fsnotify_mark_srcu);
+       if (!conn)
+               goto out;
+       spin_lock(&conn->lock);
+       if (!(conn->flags & (FSNOTIFY_OBJ_TYPE_INODE |
+                            FSNOTIFY_OBJ_TYPE_VFSMOUNT))) {
+               spin_unlock(&conn->lock);
+               srcu_read_unlock(&fsnotify_mark_srcu, idx);
+               return NULL;
+       }
+out:
+       srcu_read_unlock(&fsnotify_mark_srcu, idx);
+       return conn;
+}
+
+static void fsnotify_put_connector(struct fsnotify_mark_connector *conn)
+{
+       spin_unlock(&conn->lock);
+}
+
+/*
+ * Add mark into proper place in given list of marks. These marks may be used
+ * for the fsnotify backend to determine which event types should be delivered
+ * to which group and for which inodes. These marks are ordered according to
+ * priority, highest number first, and then by the group's location in memory.
+ */
+static int fsnotify_add_mark_list(struct fsnotify_mark *mark,
+                                 struct inode *inode, struct vfsmount *mnt,
+                                 int allow_dups)
 {
        struct fsnotify_mark *lmark, *last = NULL;
+       struct fsnotify_mark_connector *conn;
+       struct fsnotify_mark_connector **connp;
        int cmp;
+       int err = 0;
+
+       BUG_ON(!inode && !mnt);
+       if (inode)
+               connp = &inode->i_fsnotify_marks;
+       else
+               connp = &real_mount(mnt)->mnt_fsnotify_marks;
+restart:
+       spin_lock(&mark->lock);
+       conn = fsnotify_grab_connector(connp);
+       if (!conn) {
+               spin_unlock(&mark->lock);
+               conn = kmem_cache_alloc(fsnotify_mark_connector_cachep,
+                                       GFP_KERNEL);
+               if (!conn)
+                       return -ENOMEM;
+               spin_lock_init(&conn->lock);
+               INIT_HLIST_HEAD(&conn->list);
+               if (inode) {
+                       conn->flags = FSNOTIFY_OBJ_TYPE_INODE;
+                       conn->inode = igrab(inode);
+               } else {
+                       conn->flags = FSNOTIFY_OBJ_TYPE_VFSMOUNT;
+                       conn->mnt = mnt;
+               }
+               if (cmpxchg(connp, NULL, conn)) {
+                       /* Someone else created list structure for us */
+                       if (inode)
+                               iput(inode);
+                       kmem_cache_free(fsnotify_mark_connector_cachep, conn);
+               }
+               goto restart;
+       }
 
        /* is mark the first mark? */
-       if (hlist_empty(head)) {
-               hlist_add_head_rcu(&mark->obj_list, head);
-               return 0;
+       if (hlist_empty(&conn->list)) {
+               hlist_add_head_rcu(&mark->obj_list, &conn->list);
+               goto added;
        }
 
        /* should mark be in the middle of the current list? */
-       hlist_for_each_entry(lmark, head, obj_list) {
+       hlist_for_each_entry(lmark, &conn->list, obj_list) {
                last = lmark;
 
-               if ((lmark->group == mark->group) && !allow_dups)
-                       return -EEXIST;
+               if ((lmark->group == mark->group) && !allow_dups) {
+                       err = -EEXIST;
+                       goto out_err;
+               }
 
                cmp = fsnotify_compare_groups(lmark->group, mark->group);
                if (cmp >= 0) {
                        hlist_add_before_rcu(&mark->obj_list, &lmark->obj_list);
-                       return 0;
+                       goto added;
                }
        }
 
        BUG_ON(last == NULL);
        /* mark should be the last entry.  last is the current last entry */
        hlist_add_behind_rcu(&mark->obj_list, &last->obj_list);
-       return 0;
+added:
+       mark->connector = conn;
+out_err:
+       fsnotify_put_connector(conn);
+       spin_unlock(&mark->lock);
+       return err;
 }
 
 /*
@@ -356,7 +488,7 @@ int fsnotify_add_mark_locked(struct fsnotify_mark *mark,
         * LOCKING ORDER!!!!
         * group->mark_mutex
         * mark->lock
-        * inode->i_lock
+        * mark->connector->lock
         */
        spin_lock(&mark->lock);
        mark->flags |= FSNOTIFY_MARK_FLAG_ALIVE | FSNOTIFY_MARK_FLAG_ATTACHED;
@@ -366,25 +498,14 @@ int fsnotify_add_mark_locked(struct fsnotify_mark *mark,
        list_add(&mark->g_list, &group->marks_list);
        atomic_inc(&group->num_marks);
        fsnotify_get_mark(mark); /* for i_list and g_list */
-
-       if (inode) {
-               ret = fsnotify_add_inode_mark(mark, group, inode, allow_dups);
-               if (ret)
-                       goto err;
-       } else if (mnt) {
-               ret = fsnotify_add_vfsmount_mark(mark, group, mnt, allow_dups);
-               if (ret)
-                       goto err;
-       } else {
-               BUG();
-       }
-
-       /* this will pin the object if appropriate */
-       fsnotify_set_mark_mask_locked(mark, mark->mask);
        spin_unlock(&mark->lock);
 
-       if (inode)
-               __fsnotify_update_child_dentry_flags(inode);
+       ret = fsnotify_add_mark_list(mark, inode, mnt, allow_dups);
+       if (ret)
+               goto err;
+
+       if (mark->mask)
+               fsnotify_recalc_mask(mark->connector);
 
        return ret;
 err:
@@ -419,17 +540,23 @@ int fsnotify_add_mark(struct fsnotify_mark *mark, struct fsnotify_group *group,
  * Given a list of marks, find the mark associated with given group. If found
  * take a reference to that mark and return it, else return NULL.
  */
-struct fsnotify_mark *fsnotify_find_mark(struct hlist_head *head,
+struct fsnotify_mark *fsnotify_find_mark(struct fsnotify_mark_connector **connp,
                                         struct fsnotify_group *group)
 {
        struct fsnotify_mark *mark;
+       struct fsnotify_mark_connector *conn;
 
-       hlist_for_each_entry(mark, head, obj_list) {
+       conn = fsnotify_grab_connector(connp);
+       if (!conn)
+               return NULL;
+       hlist_for_each_entry(mark, &conn->list, obj_list) {
                if (mark->group == group) {
                        fsnotify_get_mark(mark);
+                       fsnotify_put_connector(conn);
                        return mark;
                }
        }
+       fsnotify_put_connector(conn);
        return NULL;
 }
 
@@ -453,7 +580,7 @@ void fsnotify_clear_marks_by_group_flags(struct fsnotify_group *group,
         */
        mutex_lock_nested(&group->mark_mutex, SINGLE_DEPTH_NESTING);
        list_for_each_entry_safe(mark, lmark, &group->marks_list, g_list) {
-               if (mark->flags & flags)
+               if (mark->connector->flags & flags)
                        list_move(&mark->g_list, &to_free);
        }
        mutex_unlock(&group->mark_mutex);
@@ -499,6 +626,29 @@ void fsnotify_detach_group_marks(struct fsnotify_group *group)
        }
 }
 
+/* Destroy all marks attached to inode / vfsmount */
+void fsnotify_destroy_marks(struct fsnotify_mark_connector **connp)
+{
+       struct fsnotify_mark_connector *conn;
+       struct fsnotify_mark *mark;
+
+       while ((conn = fsnotify_grab_connector(connp))) {
+               /*
+                * We have to be careful since we can race with e.g.
+                * fsnotify_clear_marks_by_group() and once we drop the list
+                * lock, mark can get removed from the obj_list and destroyed.
+                * But we are holding mark reference so mark cannot be freed
+                * and calling fsnotify_destroy_mark() more than once is fine.
+                */
+               mark = hlist_entry(conn->list.first, struct fsnotify_mark,
+                                  obj_list);
+               fsnotify_get_mark(mark);
+               fsnotify_put_connector(conn);
+               fsnotify_destroy_mark(mark, mark->group);
+               fsnotify_put_mark(mark);
+       }
+}
+
 /*
  * Nothing fancy, just initialize lists and locks and counters.
  */
fs/notify/vfsmount_mark.c +4 -60
index a8fcab68faef..8fc1aca21bcf 100644
@@ -29,39 +29,14 @@
 #include <linux/fsnotify_backend.h>
 #include "fsnotify.h"
 
-void fsnotify_clear_vfsmount_marks_by_group(struct fsnotify_group *group)
-{
-       fsnotify_clear_marks_by_group_flags(group, FSNOTIFY_MARK_FLAG_VFSMOUNT);
-}
-
-/*
- * Recalculate the mnt->mnt_fsnotify_mask, or the mask of all FS_* event types
- * any notifier is interested in hearing for this mount point
- */
 void fsnotify_recalc_vfsmount_mask(struct vfsmount *mnt)
 {
-       struct mount *m = real_mount(mnt);
-
-       spin_lock(&mnt->mnt_root->d_lock);
-       m->mnt_fsnotify_mask = fsnotify_recalc_mask(&m->mnt_fsnotify_marks);
-       spin_unlock(&mnt->mnt_root->d_lock);
+       fsnotify_recalc_mask(real_mount(mnt)->mnt_fsnotify_marks);
 }
 
-void fsnotify_destroy_vfsmount_mark(struct fsnotify_mark *mark)
+void fsnotify_clear_vfsmount_marks_by_group(struct fsnotify_group *group)
 {
-       struct vfsmount *mnt = mark->mnt;
-       struct mount *m = real_mount(mnt);
-
-       BUG_ON(!mutex_is_locked(&mark->group->mark_mutex));
-       assert_spin_locked(&mark->lock);
-
-       spin_lock(&mnt->mnt_root->d_lock);
-
-       hlist_del_init_rcu(&mark->obj_list);
-       mark->mnt = NULL;
-
-       m->mnt_fsnotify_mask = fsnotify_recalc_mask(&m->mnt_fsnotify_marks);
-       spin_unlock(&mnt->mnt_root->d_lock);
+       fsnotify_clear_marks_by_group_flags(group, FSNOTIFY_OBJ_TYPE_VFSMOUNT);
 }
 
 /*
@@ -72,37 +47,6 @@ struct fsnotify_mark *fsnotify_find_vfsmount_mark(struct fsnotify_group *group,
                                                  struct vfsmount *mnt)
 {
        struct mount *m = real_mount(mnt);
-       struct fsnotify_mark *mark;
-
-       spin_lock(&mnt->mnt_root->d_lock);
-       mark = fsnotify_find_mark(&m->mnt_fsnotify_marks, group);
-       spin_unlock(&mnt->mnt_root->d_lock);
-
-       return mark;
-}
-
-/*
- * Attach an initialized mark to a given group and vfsmount.
- * These marks may be used for the fsnotify backend to determine which
- * event types should be delivered to which groups.
- */
-int fsnotify_add_vfsmount_mark(struct fsnotify_mark *mark,
-                              struct fsnotify_group *group, struct vfsmount *mnt,
-                              int allow_dups)
-{
-       struct mount *m = real_mount(mnt);
-       int ret;
-
-       mark->flags |= FSNOTIFY_MARK_FLAG_VFSMOUNT;
-
-       BUG_ON(!mutex_is_locked(&group->mark_mutex));
-       assert_spin_locked(&mark->lock);
-
-       spin_lock(&mnt->mnt_root->d_lock);
-       mark->mnt = mnt;
-       ret = fsnotify_add_mark_list(&m->mnt_fsnotify_marks, mark, allow_dups);
-       m->mnt_fsnotify_mask = fsnotify_recalc_mask(&m->mnt_fsnotify_marks);
-       spin_unlock(&mnt->mnt_root->d_lock);
 
-       return ret;
+       return fsnotify_find_mark(&m->mnt_fsnotify_marks, group);
 }
include/linux/fs.h +3 -1
index 2ba074328894..8fc09316f996 100644
@@ -545,6 +545,8 @@ is_uncached_acl(struct posix_acl *acl)
 #define IOP_XATTR      0x0008
 #define IOP_DEFAULT_READLINK   0x0010
 
+struct fsnotify_mark_connector;
+
 /*
  * Keep mostly read-only and often accessed (especially for
  * the RCU path lookup and 'stat' data) fields at the beginning
@@ -644,7 +646,7 @@ struct inode {
 
 #ifdef CONFIG_FSNOTIFY
        __u32                   i_fsnotify_mask; /* all events this inode cares about */
-       struct hlist_head       i_fsnotify_marks;
+       struct fsnotify_mark_connector __rcu    *i_fsnotify_marks;
 #endif
 
 #if IS_ENABLED(CONFIG_FS_ENCRYPTION)
include/linux/fsnotify_backend.h +31 -12
index 487246546ebe..f3df68a64ee6 100644
@@ -194,6 +194,28 @@ struct fsnotify_group {
 #define FSNOTIFY_EVENT_INODE   2
 
 /*
+ * Inode / vfsmount point to this structure which tracks all marks attached to
+ * the inode / vfsmount. The reference to inode / vfsmount is held by this
+ * structure. We destroy this structure when there are no more marks attached
+ * to it. The structure is protected by fsnotify_mark_srcu.
+ */
+struct fsnotify_mark_connector {
+       spinlock_t lock;
+#define FSNOTIFY_OBJ_TYPE_INODE                0x01
+#define FSNOTIFY_OBJ_TYPE_VFSMOUNT     0x02
+       unsigned int flags;     /* Type of object [lock] */
+       union { /* Object pointer [lock] */
+               struct inode *inode;
+               struct vfsmount *mnt;
+       };
+       union {
+               struct hlist_head list;
+               /* Used listing heads to free after srcu period expires */
+               struct fsnotify_mark_connector *destroy_next;
+       };
+};
+
+/*
  * A mark is simply an object attached to an in core inode which allows an
  * fsnotify listener to indicate they are either no longer interested in events
  * of a type matching mask or only interested in those events.
@@ -222,20 +244,15 @@ struct fsnotify_mark {
        struct list_head g_list;
        /* Protects inode / mnt pointers, flags, masks */
        spinlock_t lock;
-       /* List of marks for inode / vfsmount [obj_lock] */
+       /* List of marks for inode / vfsmount [connector->lock] */
        struct hlist_node obj_list;
-       union { /* Object pointer [mark->lock, group->mark_mutex] */
-               struct inode *inode;    /* inode this mark is associated with */
-               struct vfsmount *mnt;   /* vfsmount this mark is associated with */
-       };
+       /* Head of list of marks for an object [mark->lock, group->mark_mutex] */
+       struct fsnotify_mark_connector *connector;
        /* Events types to ignore [mark->lock, group->mark_mutex] */
        __u32 ignored_mask;
-#define FSNOTIFY_MARK_FLAG_INODE               0x01
-#define FSNOTIFY_MARK_FLAG_VFSMOUNT            0x02
-#define FSNOTIFY_MARK_FLAG_OBJECT_PINNED       0x04
-#define FSNOTIFY_MARK_FLAG_IGNORED_SURV_MODIFY 0x08
-#define FSNOTIFY_MARK_FLAG_ALIVE               0x10
-#define FSNOTIFY_MARK_FLAG_ATTACHED            0x20
+#define FSNOTIFY_MARK_FLAG_IGNORED_SURV_MODIFY 0x01
+#define FSNOTIFY_MARK_FLAG_ALIVE               0x02
+#define FSNOTIFY_MARK_FLAG_ATTACHED            0x04
        unsigned int flags;             /* flags [mark->lock] */
        void (*free_mark)(struct fsnotify_mark *mark); /* called on final put+free */
 };
@@ -314,6 +331,8 @@ extern struct fsnotify_event *fsnotify_remove_first_event(struct fsnotify_group
 
 /* functions used to manipulate the marks attached to inodes */
 
+/* Calculate mask of events for a list of marks */
+extern void fsnotify_recalc_mask(struct fsnotify_mark_connector *conn);
 /* run all marks associated with a vfsmount and update mnt->mnt_fsnotify_mask */
 extern void fsnotify_recalc_vfsmount_mask(struct vfsmount *mnt);
 /* run all marks associated with an inode and update inode->i_fsnotify_mask */
@@ -343,7 +362,7 @@ extern void fsnotify_free_mark(struct fsnotify_mark *mark);
 extern void fsnotify_clear_vfsmount_marks_by_group(struct fsnotify_group *group);
 /* run all the marks in a group, and clear all of the inode marks */
 extern void fsnotify_clear_inode_marks_by_group(struct fsnotify_group *group);
-/* run all the marks in a group, and clear all of the marks where mark->flags & flags is true*/
+/* run all the marks in a group, and clear all of the marks attached to given object type */
 extern void fsnotify_clear_marks_by_group_flags(struct fsnotify_group *group, unsigned int flags);
 extern void fsnotify_get_mark(struct fsnotify_mark *mark);
 extern void fsnotify_put_mark(struct fsnotify_mark *mark);
kernel/audit_tree.c +23 -7
index 11c7ac441624..a878a98f55b3 100644
@@ -172,10 +172,25 @@ static unsigned long inode_to_key(const struct inode *inode)
 /*
  * Function to return search key in our hash from chunk. Key 0 is special and
  * should never be present in the hash.
+ *
+ * Must be called with chunk->mark.lock held to protect from connector
+ * becoming NULL.
  */
+static unsigned long __chunk_to_key(struct audit_chunk *chunk)
+{
+       if (!chunk->mark.connector)
+               return 0;
+       return (unsigned long)chunk->mark.connector->inode;
+}
+
 static unsigned long chunk_to_key(struct audit_chunk *chunk)
 {
-       return (unsigned long)chunk->mark.inode;
+       unsigned long key;
+
+       spin_lock(&chunk->mark.lock);
+       key = __chunk_to_key(chunk);
+       spin_unlock(&chunk->mark.lock);
+       return key;
 }
 
 static inline struct list_head *chunk_hash(unsigned long key)
@@ -187,7 +202,7 @@ static inline struct list_head *chunk_hash(unsigned long key)
 /* hash_lock & entry->lock is held by caller */
 static void insert_hash(struct audit_chunk *chunk)
 {
-       unsigned long key = chunk_to_key(chunk);
+       unsigned long key = __chunk_to_key(chunk);
        struct list_head *list;
 
        if (!key)
@@ -248,7 +263,8 @@ static void untag_chunk(struct node *p)
 
        mutex_lock(&entry->group->mark_mutex);
        spin_lock(&entry->lock);
-       if (chunk->dead || !entry->inode) {
+       if (chunk->dead || !entry->connector ||
+           !entry->connector->inode) {
                spin_unlock(&entry->lock);
                mutex_unlock(&entry->group->mark_mutex);
                if (new)
@@ -276,8 +292,8 @@ static void untag_chunk(struct node *p)
        if (!new)
                goto Fallback;
 
-       if (fsnotify_add_mark_locked(&new->mark, entry->group, entry->inode,
-                                    NULL, 1)) {
+       if (fsnotify_add_mark_locked(&new->mark, entry->group,
+                                    entry->connector->inode, NULL, 1)) {
                fsnotify_put_mark(&new->mark);
                goto Fallback;
        }
@@ -408,7 +424,7 @@ static int tag_chunk(struct inode *inode, struct audit_tree *tree)
 
        mutex_lock(&old_entry->group->mark_mutex);
        spin_lock(&old_entry->lock);
-       if (!old_entry->inode) {
+       if (!old_entry->connector || !old_entry->connector->inode) {
                /* old_entry is being shot, lets just lie */
                spin_unlock(&old_entry->lock);
                mutex_unlock(&old_entry->group->mark_mutex);
@@ -418,7 +434,7 @@ static int tag_chunk(struct inode *inode, struct audit_tree *tree)
        }
 
        if (fsnotify_add_mark_locked(chunk_entry, old_entry->group,
-                                    old_entry->inode, NULL, 1)) {
+                            old_entry->connector->inode, NULL, 1)) {
                spin_unlock(&old_entry->lock);
                mutex_unlock(&old_entry->group->mark_mutex);
                fsnotify_put_mark(chunk_entry);
kernel/auditsc.c +2 -3
index cf1fa43512c1..e990de915341 100644
@@ -1591,7 +1591,7 @@ static inline void handle_one(const struct inode *inode)
        struct audit_tree_refs *p;
        struct audit_chunk *chunk;
        int count;
-       if (likely(hlist_empty(&inode->i_fsnotify_marks)))
+       if (likely(!inode->i_fsnotify_marks))
                return;
        context = current->audit_context;
        p = context->trees;
@@ -1634,7 +1634,7 @@ static void handle_path(const struct dentry *dentry)
        seq = read_seqbegin(&rename_lock);
        for(;;) {
                struct inode *inode = d_backing_inode(d);
-               if (inode && unlikely(!hlist_empty(&inode->i_fsnotify_marks))) {
+               if (inode && unlikely(inode->i_fsnotify_marks)) {
                        struct audit_chunk *chunk;
                        chunk = audit_tree_lookup(inode);
                        if (chunk) {
--

2.10.2

#8 lore raw

Re: [PATCH 06/22] fsnotify: Attach marks to object via dedicated head structure

In reply to Jan Kara
Quoted 26 lines · Jan Kara

Currently notification marks are attached to object (inode or vfsmnt) by a hlist_head in the object. The list is also protected by a spinlock in the object. So while there is any mark attached to the list of marks, the object must be pinned in memory (and thus e.g. last iput() deleting inode cannot happen). Also for list iteration in fsnotify() to work, we must hold fsnotify_mark_srcu lock so that mark itself and mark->obj_list.next cannot get freed. Thus we are required to wait for response to fanotify events from userspace process with fsnotify_mark_srcu lock held. That causes issues when userspace process is buggy and does not reply to some event - basically the whole notification subsystem gets eventually stuck.

So to be able to drop fsnotify_mark_srcu lock while waiting for response, we have to pin the mark in memory and make sure it stays in the object list (as removing the mark waiting for response could lead to lost notification events for groups later in the list). However we don't want inode reclaim to block on such mark as that would lead to system just locking up elsewhere.

This commit tries to pave a way towards solving these conflicting lifetime needs. Instead of anchoring the list of marks directly in the object, we anchor it in a dedicated structure (fsnotify_mark_connector) and just point to that structure from the object. Also the list is protected by a spinlock contained in that structure. With this, we can detach notification marks from object without having to modify the list itself.

Quoted 2 lines

---

Looks good, except for some confusing semantics of grab/put and question about rcu_assign_pointer()

...

Quoted 55 lines
fs/notify/fsnotify.c +19 -7
index b41515d3f081..d512ef9f75fc 100644
@@ -193,6 +193,7 @@ int fsnotify(struct inode *to_tell, __u32 mask, const void *data, int data_is,
        struct hlist_node *inode_node = NULL, *vfsmount_node = NULL;
        struct fsnotify_mark *inode_mark = NULL, *vfsmount_mark = NULL;
        struct fsnotify_group *inode_group, *vfsmount_group;
+       struct fsnotify_mark_connector *inode_conn, *vfsmount_conn;
        struct mount *mnt;
        int idx, ret = 0;
        /* global tests shouldn't care about events on child only the specific event */
@@ -210,8 +211,8 @@ int fsnotify(struct inode *to_tell, __u32 mask, const void *data, int data_is,
         * SRCU because we have no references to any objects and do not
         * need SRCU to keep them "alive".
         */
-       if (hlist_empty(&to_tell->i_fsnotify_marks) &&
-           (!mnt || hlist_empty(&mnt->mnt_fsnotify_marks)))
+       if (!to_tell->i_fsnotify_marks &&
+           (!mnt || !mnt->mnt_fsnotify_marks))
                return 0;
        /*
         * if this is a modify event we may need to clear the ignored masks
@@ -226,16 +227,27 @@ int fsnotify(struct inode *to_tell, __u32 mask, const void *data, int data_is,
        idx = srcu_read_lock(&fsnotify_mark_srcu);
 
        if ((mask & FS_MODIFY) ||
-           (test_mask & to_tell->i_fsnotify_mask))
-               inode_node = srcu_dereference(to_tell->i_fsnotify_marks.first,
+           (test_mask & to_tell->i_fsnotify_mask)) {
+               inode_conn = srcu_dereference(to_tell->i_fsnotify_marks,
                                              &fsnotify_mark_srcu);
+               if (inode_conn)
+                       inode_node = srcu_dereference(inode_conn->list.first,
+                                                     &fsnotify_mark_srcu);
+       }
 
        if (mnt && ((mask & FS_MODIFY) ||
                    (test_mask & mnt->mnt_fsnotify_mask))) {
-               vfsmount_node = srcu_dereference(mnt->mnt_fsnotify_marks.first,
-                                                &fsnotify_mark_srcu);
-               inode_node = srcu_dereference(to_tell->i_fsnotify_marks.first,
+               inode_conn = srcu_dereference(to_tell->i_fsnotify_marks,
                                              &fsnotify_mark_srcu);
+               if (inode_conn)
+                       inode_node = srcu_dereference(inode_conn->list.first,
+                                                     &fsnotify_mark_srcu);
+               vfsmount_conn = srcu_dereference(mnt->mnt_fsnotify_marks,
+                                                &fsnotify_mark_srcu);
+               if (vfsmount_conn)
+                       vfsmount_node = srcu_dereference(
+                                               vfsmount_conn->list.first,
+                                               &fsnotify_mark_srcu);
        }
 

...

Quoted 4 lines
fs/notify/fsnotify.c +4 -0
+
+static struct inode *fsnotify_detach_from_object(struct fsnotify_mark *mark)
+{
+       struct fsnotify_mark_connector *conn;

fs/notify/fsnotify.c

Quoted 10 lines
fs/notify/fsnotify.c +10 -0
+       struct inode *inode = NULL;
+       bool free_conn = false;
+
+       conn = mark->connector;
+       spin_lock(&conn->lock);
+       hlist_del_init_rcu(&mark->obj_list);
+       if (hlist_empty(&conn->list)) {
+               if (conn->flags & FSNOTIFY_OBJ_TYPE_INODE) {
+                       inode = conn->inode;
+                       inode->i_fsnotify_marks = NULL;

Shouldn't that assignment be done using rcu_assign_pointer() to match srcu_dereference(to_tell->i_fsnotify_marks, &fsnotify_mark_srcu); ?

fs/notify/fsnotify.c

Quoted 5 lines
fs/notify/fsnotify.c +5 -0
+                       inode->i_fsnotify_mask = 0;
+                       conn->inode = NULL;
+                       conn->flags &= ~FSNOTIFY_OBJ_TYPE_INODE;
+               } else if (conn->flags & FSNOTIFY_OBJ_TYPE_VFSMOUNT) {
+                       real_mount(conn->mnt)->mnt_fsnotify_marks = NULL;

Same here

Quoted 123 lines
fs/notify/fsnotify.c +45 -45
+                       real_mount(conn->mnt)->mnt_fsnotify_mask = 0;
+                       conn->mnt = NULL;
+                       conn->flags &= ~FSNOTIFY_OBJ_TYPE_VFSMOUNT;
+               }
+               free_conn = true;
+       } else
+               __fsnotify_recalc_mask(conn);
+       mark->connector = NULL;
+       spin_unlock(&conn->lock);
+
+       if (free_conn) {
+               spin_lock(&destroy_lock);
+               conn->destroy_next = connector_destroy_list;
+               connector_destroy_list = conn;
+               spin_unlock(&destroy_lock);
+               queue_work(system_unbound_wq, &connector_reaper_work);
+       }
+
+       return inode;
 }
 
 /*
@@ -137,13 +227,8 @@ void fsnotify_detach_mark(struct fsnotify_mark *mark)
 
        mark->flags &= ~FSNOTIFY_MARK_FLAG_ATTACHED;
 
-       if (mark->flags & FSNOTIFY_MARK_FLAG_INODE) {
-               inode = mark->inode;
-               fsnotify_destroy_inode_mark(mark);
-       } else if (mark->flags & FSNOTIFY_MARK_FLAG_VFSMOUNT)
-               fsnotify_destroy_vfsmount_mark(mark);
-       else
-               BUG();
+       inode = fsnotify_detach_from_object(mark);
+
        /*
         * Note that we didn't update flags telling whether inode cares about
         * what's happening with children. We update these flags from
@@ -155,7 +240,7 @@ void fsnotify_detach_mark(struct fsnotify_mark *mark)
 
        spin_unlock(&mark->lock);
 
-       if (inode && (mark->flags & FSNOTIFY_MARK_FLAG_OBJECT_PINNED))
+       if (inode)
                iput(inode);
 
        atomic_dec(&group->num_marks);
@@ -220,45 +305,11 @@ void fsnotify_destroy_mark(struct fsnotify_mark *mark,
        fsnotify_free_mark(mark);
 }
 
-void fsnotify_destroy_marks(struct hlist_head *head, spinlock_t *lock)
-{
-       struct fsnotify_mark *mark;
-
-       while (1) {
-               /*
-                * We have to be careful since we can race with e.g.
-                * fsnotify_clear_marks_by_group() and once we drop 'lock',
-                * mark can get removed from the obj_list and destroyed. But
-                * we are holding mark reference so mark cannot be freed and
-                * calling fsnotify_destroy_mark() more than once is fine.
-                */
-               spin_lock(lock);
-               if (hlist_empty(head)) {
-                       spin_unlock(lock);
-                       break;
-               }
-               mark = hlist_entry(head->first, struct fsnotify_mark, obj_list);
-               /*
-                * We don't update i_fsnotify_mask / mnt_fsnotify_mask here
-                * since inode / mount is going away anyway. So just remove
-                * mark from the list.
-                */
-               hlist_del_init_rcu(&mark->obj_list);
-               fsnotify_get_mark(mark);
-               spin_unlock(lock);
-               fsnotify_destroy_mark(mark, mark->group);
-               fsnotify_put_mark(mark);
-       }
-}
-
 void fsnotify_set_mark_mask_locked(struct fsnotify_mark *mark, __u32 mask)
 {
        assert_spin_locked(&mark->lock);
 
        mark->mask = mask;
-
-       if (mark->flags & FSNOTIFY_MARK_FLAG_INODE)
-               fsnotify_set_inode_mark_mask_locked(mark, mask);
 }
 
 void fsnotify_set_mark_ignored_mask_locked(struct fsnotify_mark *mark, __u32 mask)
@@ -304,37 +355,118 @@ int fsnotify_compare_groups(struct fsnotify_group *a, struct fsnotify_group *b)
        return -1;
 }
 
-/* Add mark into proper place in given list of marks */
-int fsnotify_add_mark_list(struct hlist_head *head, struct fsnotify_mark *mark,
-                          int allow_dups)
+/*
+ * Get mark connector, make sure it is alive and return with its lock held.
+ * This is for users that get connector pointer from inode or mount. Users that
+ * hold reference to a mark on the list may directly lock connector->lock as
+ * they are sure list cannot go away under them.
+ */
+static struct fsnotify_mark_connector *fsnotify_grab_connector(
+                               struct fsnotify_mark_connector * __rcu *connp)
+{
+       struct fsnotify_mark_connector *conn;
+       int idx;
+
+       idx = srcu_read_lock(&fsnotify_mark_srcu);
+       conn = srcu_dereference(*connp, &fsnotify_mark_srcu);
+       if (!conn)
+               goto out;
+       spin_lock(&conn->lock);
+       if (!(conn->flags & (FSNOTIFY_OBJ_TYPE_INODE |
+                            FSNOTIFY_OBJ_TYPE_VFSMOUNT))) {
+               spin_unlock(&conn->lock);
+               srcu_read_unlock(&fsnotify_mark_srcu, idx);
+               return NULL;
+       }

fs/notify/fsnotify.c int fsnotify_compare_groups(struct fsnotify_group *a, struct fsnotify_group *b) · line 390

Quoted 10 lines
fs/notify/fsnotify.c +10 -0
+out:
+       srcu_read_unlock(&fsnotify_mark_srcu, idx);
+       return conn;
+}
+
+static void fsnotify_put_connector(struct fsnotify_mark_connector *conn)
+{
+       spin_unlock(&conn->lock);
+}
+

Is there a precedent in the kernel for using grab()/put() semantics for what is essentially aquire()/release() for exclusive object access?

The counterpart for grab_cache_page(), for example, is unlock_page(page); put_page(page); (and not just put_page()).

igrab() does not return with i_lock held, so igrab()/iput() sematics do not apply to this case.

I find a function that is called put_connector() and actually does unlock to be confusing and if that function is a one liner helper, I prefer that it did not exist at all and call site should use spin_unlock(&conn->lock); explicitly instead of hiding it.

Quoted 30 lines
fs/notify/fsnotify.c +27 -0
+/*
+ * Add mark into proper place in given list of marks. These marks may be used
+ * for the fsnotify backend to determine which event types should be delivered
+ * to which group and for which inodes. These marks are ordered according to
+ * priority, highest number first, and then by the group's location in memory.
+ */
+static int fsnotify_add_mark_list(struct fsnotify_mark *mark,
+                                 struct inode *inode, struct vfsmount *mnt,
+                                 int allow_dups)
 {
        struct fsnotify_mark *lmark, *last = NULL;
+       struct fsnotify_mark_connector *conn;
+       struct fsnotify_mark_connector **connp;
        int cmp;
+       int err = 0;
+
+       BUG_ON(!inode && !mnt);
+       if (inode)
+               connp = &inode->i_fsnotify_marks;
+       else
+               connp = &real_mount(mnt)->mnt_fsnotify_marks;
+restart:
+       spin_lock(&mark->lock);
+       conn = fsnotify_grab_connector(connp);
+       if (!conn) {
+               spin_unlock(&mark->lock);
+               conn = kmem_cache_alloc(fsnotify_mark_connector_cachep,
+                                       GFP_KERNEL);
+               if (!conn)
+                       return -ENOMEM;

fs/notify/fsnotify.c int fsnotify_compare_groups(struct fsnotify_group *a, struct fsnotify_group *b) · line 430

Quoted 10 lines
fs/notify/fsnotify.c +10 -0
+               spin_lock_init(&conn->lock);
+               INIT_HLIST_HEAD(&conn->list);
+               if (inode) {
+                       conn->flags = FSNOTIFY_OBJ_TYPE_INODE;
+                       conn->inode = igrab(inode);
+               } else {
+                       conn->flags = FSNOTIFY_OBJ_TYPE_VFSMOUNT;
+                       conn->mnt = mnt;
+               }
+               if (cmpxchg(connp, NULL, conn)) {

Same question as in fsnotify_detach_from_object()
Is there a need for any smb_wmb() here to match srcu_dereference() in fsnotify(), or is there no need because cmpxchg from NULL to a live object is always safe for the reader?

Quoted 153 lines
fs/notify/fsnotify.c +61 -29
+                       /* Someone else created list structure for us */
+                       if (inode)
+                               iput(inode);
+                       kmem_cache_free(fsnotify_mark_connector_cachep, conn);
+               }
+               goto restart;
+       }
 
        /* is mark the first mark? */
-       if (hlist_empty(head)) {
-               hlist_add_head_rcu(&mark->obj_list, head);
-               return 0;
+       if (hlist_empty(&conn->list)) {
+               hlist_add_head_rcu(&mark->obj_list, &conn->list);
+               goto added;
        }
 
        /* should mark be in the middle of the current list? */
-       hlist_for_each_entry(lmark, head, obj_list) {
+       hlist_for_each_entry(lmark, &conn->list, obj_list) {
                last = lmark;
 
-               if ((lmark->group == mark->group) && !allow_dups)
-                       return -EEXIST;
+               if ((lmark->group == mark->group) && !allow_dups) {
+                       err = -EEXIST;
+                       goto out_err;
+               }
 
                cmp = fsnotify_compare_groups(lmark->group, mark->group);
                if (cmp >= 0) {
                        hlist_add_before_rcu(&mark->obj_list, &lmark->obj_list);
-                       return 0;
+                       goto added;
                }
        }
 
        BUG_ON(last == NULL);
        /* mark should be the last entry.  last is the current last entry */
        hlist_add_behind_rcu(&mark->obj_list, &last->obj_list);
-       return 0;
+added:
+       mark->connector = conn;
+out_err:
+       fsnotify_put_connector(conn);
+       spin_unlock(&mark->lock);
+       return err;
 }
 
 /*
@@ -356,7 +488,7 @@ int fsnotify_add_mark_locked(struct fsnotify_mark *mark,
         * LOCKING ORDER!!!!
         * group->mark_mutex
         * mark->lock
-        * inode->i_lock
+        * mark->connector->lock
         */
        spin_lock(&mark->lock);
        mark->flags |= FSNOTIFY_MARK_FLAG_ALIVE | FSNOTIFY_MARK_FLAG_ATTACHED;
@@ -366,25 +498,14 @@ int fsnotify_add_mark_locked(struct fsnotify_mark *mark,
        list_add(&mark->g_list, &group->marks_list);
        atomic_inc(&group->num_marks);
        fsnotify_get_mark(mark); /* for i_list and g_list */
-
-       if (inode) {
-               ret = fsnotify_add_inode_mark(mark, group, inode, allow_dups);
-               if (ret)
-                       goto err;
-       } else if (mnt) {
-               ret = fsnotify_add_vfsmount_mark(mark, group, mnt, allow_dups);
-               if (ret)
-                       goto err;
-       } else {
-               BUG();
-       }
-
-       /* this will pin the object if appropriate */
-       fsnotify_set_mark_mask_locked(mark, mark->mask);
        spin_unlock(&mark->lock);
 
-       if (inode)
-               __fsnotify_update_child_dentry_flags(inode);
+       ret = fsnotify_add_mark_list(mark, inode, mnt, allow_dups);
+       if (ret)
+               goto err;
+
+       if (mark->mask)
+               fsnotify_recalc_mask(mark->connector);
 
        return ret;
 err:
@@ -419,17 +540,23 @@ int fsnotify_add_mark(struct fsnotify_mark *mark, struct fsnotify_group *group,
  * Given a list of marks, find the mark associated with given group. If found
  * take a reference to that mark and return it, else return NULL.
  */
-struct fsnotify_mark *fsnotify_find_mark(struct hlist_head *head,
+struct fsnotify_mark *fsnotify_find_mark(struct fsnotify_mark_connector **connp,
                                         struct fsnotify_group *group)
 {
        struct fsnotify_mark *mark;
+       struct fsnotify_mark_connector *conn;
 
-       hlist_for_each_entry(mark, head, obj_list) {
+       conn = fsnotify_grab_connector(connp);
+       if (!conn)
+               return NULL;
+       hlist_for_each_entry(mark, &conn->list, obj_list) {
                if (mark->group == group) {
                        fsnotify_get_mark(mark);
+                       fsnotify_put_connector(conn);
                        return mark;
                }
        }
+       fsnotify_put_connector(conn);
        return NULL;
 }
 
@@ -453,7 +580,7 @@ void fsnotify_clear_marks_by_group_flags(struct fsnotify_group *group,
         */
        mutex_lock_nested(&group->mark_mutex, SINGLE_DEPTH_NESTING);
        list_for_each_entry_safe(mark, lmark, &group->marks_list, g_list) {
-               if (mark->flags & flags)
+               if (mark->connector->flags & flags)
                        list_move(&mark->g_list, &to_free);
        }
        mutex_unlock(&group->mark_mutex);
@@ -499,6 +626,29 @@ void fsnotify_detach_group_marks(struct fsnotify_group *group)
        }
 }
 
+/* Destroy all marks attached to inode / vfsmount */
+void fsnotify_destroy_marks(struct fsnotify_mark_connector **connp)
+{
+       struct fsnotify_mark_connector *conn;
+       struct fsnotify_mark *mark;
+
+       while ((conn = fsnotify_grab_connector(connp))) {
+               /*
+                * We have to be careful since we can race with e.g.
+                * fsnotify_clear_marks_by_group() and once we drop the list
+                * lock, mark can get removed from the obj_list and destroyed.
+                * But we are holding mark reference so mark cannot be freed
+                * and calling fsnotify_destroy_mark() more than once is fine.
+                */
+               mark = hlist_entry(conn->list.first, struct fsnotify_mark,
+                                  obj_list);
+               fsnotify_get_mark(mark);
+               fsnotify_put_connector(conn);
+               fsnotify_destroy_mark(mark, mark->group);
+               fsnotify_put_mark(mark);
+       }
+}
+
author maintainer
#9 lore raw

Re: [PATCH 06/22] fsnotify: Attach marks to object via dedicated head structure

Quoted 17 lines · Amir Goldstein

fs/notify/mark.c void fsnotify_put_mark(struct fsnotify_mark *mark) · line 180

Quoted 13 lines · Jan Kara
fs/notify/mark.c +13 -0
+static struct inode *fsnotify_detach_from_object(struct fsnotify_mark *mark)
+{
+       struct fsnotify_mark_connector *conn;
+       struct inode *inode = NULL;
+       bool free_conn = false;
+
+       conn = mark->connector;
+       spin_lock(&conn->lock);
+       hlist_del_init_rcu(&mark->obj_list);
+       if (hlist_empty(&conn->list)) {
+               if (conn->flags & FSNOTIFY_OBJ_TYPE_INODE) {
+                       inode = conn->inode;
+                       inode->i_fsnotify_marks = NULL;

Shouldn't that assignment be done using rcu_assign_pointer() to match srcu_dereference(to_tell->i_fsnotify_marks, &fsnotify_mark_srcu); ?

Good catch (although this is only cosmetic - the assignment cannot escape the conn->lock section and within it it does not matter where it happens even for unlocked accesses). Done.

Quoted 40 lines
Quoted 23 lines
fs/notify/mark.c +23 -0
+/*
+ * Get mark connector, make sure it is alive and return with its lock held.
+ * This is for users that get connector pointer from inode or mount. Users that
+ * hold reference to a mark on the list may directly lock connector->lock as
+ * they are sure list cannot go away under them.
+ */
+static struct fsnotify_mark_connector *fsnotify_grab_connector(
+                               struct fsnotify_mark_connector * __rcu *connp)
+{
+       struct fsnotify_mark_connector *conn;
+       int idx;
+
+       idx = srcu_read_lock(&fsnotify_mark_srcu);
+       conn = srcu_dereference(*connp, &fsnotify_mark_srcu);
+       if (!conn)
+               goto out;
+       spin_lock(&conn->lock);
+       if (!(conn->flags & (FSNOTIFY_OBJ_TYPE_INODE |
+                            FSNOTIFY_OBJ_TYPE_VFSMOUNT))) {
+               spin_unlock(&conn->lock);
+               srcu_read_unlock(&fsnotify_mark_srcu, idx);
+               return NULL;
+       }

fs/notify/mark.c int fsnotify_compare_groups(struct fsnotify_group *a, struct fsnotify_group *b) · line 390

Quoted 10 lines
fs/notify/mark.c +10 -0
+out:
+       srcu_read_unlock(&fsnotify_mark_srcu, idx);
+       return conn;
+}
+
+static void fsnotify_put_connector(struct fsnotify_mark_connector *conn)
+{
+       spin_unlock(&conn->lock);
+}
+

Is there a precedent in the kernel for using grab()/put() semantics for what is essentially aquire()/release() for exclusive object access?

The counterpart for grab_cache_page(), for example, is unlock_page(page); put_page(page); (and not just put_page()).

Quoted 7 lines

igrab() does not return with i_lock held, so igrab()/iput() sematics do not apply to this case.

I find a function that is called put_connector() and actually does unlock to be confusing and if that function is a one liner helper, I prefer that it did not exist at all and call site should use spin_unlock(&conn->lock); explicitly instead of hiding it.

OK, probably you're right. I'll remove this function.

Quoted 37 lines
Quoted 37 lines
fs/notify/mark.c +34 -0
+/*
+ * Add mark into proper place in given list of marks. These marks may be used
+ * for the fsnotify backend to determine which event types should be delivered
+ * to which group and for which inodes. These marks are ordered according to
+ * priority, highest number first, and then by the group's location in memory.
+ */
+static int fsnotify_add_mark_list(struct fsnotify_mark *mark,
+                                 struct inode *inode, struct vfsmount *mnt,
+                                 int allow_dups)
 {
        struct fsnotify_mark *lmark, *last = NULL;
+       struct fsnotify_mark_connector *conn;
+       struct fsnotify_mark_connector **connp;
        int cmp;
+       int err = 0;
+
+       BUG_ON(!inode && !mnt);
+       if (inode)
+               connp = &inode->i_fsnotify_marks;
+       else
+               connp = &real_mount(mnt)->mnt_fsnotify_marks;
+restart:
+       spin_lock(&mark->lock);
+       conn = fsnotify_grab_connector(connp);
+       if (!conn) {
+               spin_unlock(&mark->lock);
+               conn = kmem_cache_alloc(fsnotify_mark_connector_cachep,
+                                       GFP_KERNEL);
+               if (!conn)
+                       return -ENOMEM;
+               spin_lock_init(&conn->lock);
+               INIT_HLIST_HEAD(&conn->list);
+               if (inode) {
+                       conn->flags = FSNOTIFY_OBJ_TYPE_INODE;
+                       conn->inode = igrab(inode);
+               } else {
+                       conn->flags = FSNOTIFY_OBJ_TYPE_VFSMOUNT;
Quoted 8 lines

fs/notify/mark.c int fsnotify_compare_groups(struct fsnotify_group *a, struct fsnotify_group *b) · line 430

Quoted 3 lines
fs/notify/mark.c +3 -0
+                       conn->mnt = mnt;
+               }
+               if (cmpxchg(connp, NULL, conn)) {

Same question as in fsnotify_detach_from_object()
Is there a need for any smb_wmb() here to match srcu_dereference() in fsnotify(), or is there no need because cmpxchg from NULL to a live object is always safe for the reader?

cmpxchg() is already guaranteed to contain the required barrier (see Documentation/core-api/atomic_ops.rst).

Honza

Signature · 2 lines
Jan Kara <[email protected]>
SUSE Labs, CR
author maintainer
#10 lore raw

PATCH v2 7/22 inotify: Do not drop mark reference under idr_lock

In reply to Jan Kara

Dropping mark reference can result in mark being freed. Although it should not happen in inotify_remove_from_idr() since caller should hold another reference, just don't risk lock up just after WARN_ON unnecessarily. Also fold do_inotify_remove_from_idr() into the single callsite as that function really is just two lines of real code.

---
 fs/notify/inotify/inotify_user.c | 24 ++++++------------------
 1 file changed, 6 insertions(+), 18 deletions(-)
fs/notify/inotify/inotify_user.c +6 -18
index 3697567c7897..06dae605158d 100644
@@ -397,21 +397,6 @@ static struct inotify_inode_mark *inotify_idr_find(struct fsnotify_group *group,
 	return i_mark;
 }
 
-static void do_inotify_remove_from_idr(struct fsnotify_group *group,
-				       struct inotify_inode_mark *i_mark)
-{
-	struct idr *idr = &group->inotify_data.idr;
-	spinlock_t *idr_lock = &group->inotify_data.idr_lock;
-	int wd = i_mark->wd;
-
-	assert_spin_locked(idr_lock);
-
-	idr_remove(idr, wd);
-
-	/* removed from the idr, drop that ref */
-	fsnotify_put_mark(&i_mark->fsn_mark);
-}
-
 /*
  * Remove the mark from the idr (if present) and drop the reference
  * on the mark because it was in the idr.
@@ -419,6 +404,7 @@ static void do_inotify_remove_from_idr(struct fsnotify_group *group,
 static void inotify_remove_from_idr(struct fsnotify_group *group,
 				    struct inotify_inode_mark *i_mark)
 {
+	struct idr *idr = &group->inotify_data.idr;
 	spinlock_t *idr_lock = &group->inotify_data.idr_lock;
 	struct inotify_inode_mark *found_i_mark = NULL;
 	int wd;
@@ -470,13 +456,15 @@ static void inotify_remove_from_idr(struct fsnotify_group *group,
 		BUG();
 	}
 
-	do_inotify_remove_from_idr(group, i_mark);
+	idr_remove(idr, wd);
+	/* Removed from the idr, drop that ref. */
+	fsnotify_put_mark(&i_mark->fsn_mark);
 out:
+	i_mark->wd = -1;
+	spin_unlock(idr_lock);
 	/* match the ref taken by inotify_idr_find_locked() */
 	if (found_i_mark)
 		fsnotify_put_mark(&found_i_mark->fsn_mark);
-	i_mark->wd = -1;
-	spin_unlock(idr_lock);
 }
 
 /*
Signature · 1 line
2.10.2
author maintainer
#11 lore raw

PATCH v2 8/22 fsnotify: Move queueing of mark for destruction into fsnotify_put_mark()

In reply to Jan Kara

Currently we queue mark into a list of marks for destruction in __fsnotify_free_mark() and keep the last mark reference dangling. After the worker waits for SRCU period, it drops the last reference to the mark which frees it. This scheme has the disadvantage that if we hold reference to a mark and drop and reacquire SRCU lock, the mark can get freed immediately which is slightly inconvenient and we will need to avoid this in the future.

Move to a scheme where queueing of mark into a list of marks for destruction happens when the last reference to the mark is dropped. Also drop reference to the mark held by group list already when mark is removed from that list instead of dropping it only from the destruction worker.

---
 fs/notify/mark.c | 71 ++++++++++++++++++++++----------------------------------
 1 file changed, 28 insertions(+), 43 deletions(-)
fs/notify/mark.c +28 -43
index 97c68589742e..521c4bd9b497 100644
@@ -99,15 +99,18 @@ static DECLARE_WORK(connector_reaper_work, fsnotify_connector_destroy_workfn);
 
 void fsnotify_get_mark(struct fsnotify_mark *mark)
 {
+	WARN_ON_ONCE(!atomic_read(&mark->refcnt));
 	atomic_inc(&mark->refcnt);
 }
 
 void fsnotify_put_mark(struct fsnotify_mark *mark)
 {
 	if (atomic_dec_and_test(&mark->refcnt)) {
-		if (mark->group)
-			fsnotify_put_group(mark->group);
-		mark->free_mark(mark);
+		spin_lock(&destroy_lock);
+		list_add(&mark->g_list, &destroy_list);
+		spin_unlock(&destroy_lock);
+		queue_delayed_work(system_unbound_wq, &reaper_work,
+				   FSNOTIFY_REAPER_DELAY);
 	}
 }
 
@@ -208,14 +211,18 @@ static struct inode *fsnotify_detach_from_object(struct fsnotify_mark *mark)
  * Remove mark from inode / vfsmount list, group list, drop inode reference
  * if we got one.
  *
- * Must be called with group->mark_mutex held.
+ * Must be called with group->mark_mutex held. The caller must either hold
+ * reference to the mark or be protected by fsnotify_mark_srcu.
  */
 void fsnotify_detach_mark(struct fsnotify_mark *mark)
 {
 	struct inode *inode = NULL;
 	struct fsnotify_group *group = mark->group;
 
-	BUG_ON(!mutex_is_locked(&group->mark_mutex));
+	WARN_ON_ONCE(!mutex_is_locked(&group->mark_mutex));
+	WARN_ON_ONCE(!srcu_read_lock_held(&fsnotify_mark_srcu) &&
+		     atomic_read(&mark->refcnt) < 1 +
+			!!(mark->flags & FSNOTIFY_MARK_FLAG_ATTACHED));
 
 	spin_lock(&mark->lock);
 
@@ -244,18 +251,20 @@ void fsnotify_detach_mark(struct fsnotify_mark *mark)
 		iput(inode);
 
 	atomic_dec(&group->num_marks);
+
+	/* Drop mark reference acquired in fsnotify_add_mark_locked() */
+	fsnotify_put_mark(mark);
 }
 
 /*
- * Prepare mark for freeing and add it to the list of marks prepared for
- * freeing. The actual freeing must happen after SRCU period ends and the
- * caller is responsible for this.
+ * Free fsnotify mark. The mark is actually only marked as being freed.  The
+ * freeing is actually happening only once last reference to the mark is
+ * dropped from a workqueue which first waits for srcu period end.
  *
- * The function returns true if the mark was added to the list of marks for
- * freeing. The function returns false if someone else has already called
- * __fsnotify_free_mark() for the mark.
+ * Caller must have a reference to the mark or be protected by
+ * fsnotify_mark_srcu.
  */
-static bool __fsnotify_free_mark(struct fsnotify_mark *mark)
+void fsnotify_free_mark(struct fsnotify_mark *mark)
 {
 	struct fsnotify_group *group = mark->group;
 
@@ -263,7 +272,7 @@ static bool __fsnotify_free_mark(struct fsnotify_mark *mark)
 	/* something else already called this function on this mark */
 	if (!(mark->flags & FSNOTIFY_MARK_FLAG_ALIVE)) {
 		spin_unlock(&mark->lock);
-		return false;
+		return;
 	}
 	mark->flags &= ~FSNOTIFY_MARK_FLAG_ALIVE;
 	spin_unlock(&mark->lock);
@@ -275,25 +284,6 @@ static bool __fsnotify_free_mark(struct fsnotify_mark *mark)
 	 */
 	if (group->ops->freeing_mark)
 		group->ops->freeing_mark(mark, group);
-
-	spin_lock(&destroy_lock);
-	list_add(&mark->g_list, &destroy_list);
-	spin_unlock(&destroy_lock);
-
-	return true;
-}
-
-/*
- * Free fsnotify mark. The freeing is actually happening from a workqueue which
- * first waits for srcu period end. Caller must have a reference to the mark
- * or be protected by fsnotify_mark_srcu.
- */
-void fsnotify_free_mark(struct fsnotify_mark *mark)
-{
-	if (__fsnotify_free_mark(mark)) {
-		queue_delayed_work(system_unbound_wq, &reaper_work,
-				   FSNOTIFY_REAPER_DELAY);
-	}
 }
 
 void fsnotify_destroy_mark(struct fsnotify_mark *mark,
@@ -509,20 +499,13 @@ int fsnotify_add_mark_locked(struct fsnotify_mark *mark,
 
 	return ret;
 err:
-	mark->flags &= ~FSNOTIFY_MARK_FLAG_ALIVE;
+	mark->flags &= ~(FSNOTIFY_MARK_FLAG_ALIVE |
+			 FSNOTIFY_MARK_FLAG_ATTACHED);
 	list_del_init(&mark->g_list);
-	fsnotify_put_group(group);
-	mark->group = NULL;
 	atomic_dec(&group->num_marks);
-
 	spin_unlock(&mark->lock);
 
-	spin_lock(&destroy_lock);
-	list_add(&mark->g_list, &destroy_list);
-	spin_unlock(&destroy_lock);
-	queue_delayed_work(system_unbound_wq, &reaper_work,
-				FSNOTIFY_REAPER_DELAY);
-
+	fsnotify_put_mark(mark);
 	return ret;
 }
 
@@ -679,7 +662,9 @@ void fsnotify_mark_destroy_list(void)
 
 	list_for_each_entry_safe(mark, next, &private_destroy_list, g_list) {
 		list_del_init(&mark->g_list);
-		fsnotify_put_mark(mark);
+		if (mark->group)
+			fsnotify_put_group(mark->group);
+		mark->free_mark(mark);
 	}
 }
 
Signature · 1 line
2.10.2
reviewer Reviewed-by on v2 8/22
#12 lore raw

Re: [PATCH 08/22] fsnotify: Move queueing of mark for destruction into fsnotify_put_mark()

Quoted 8 lines · Jan Kara

Currently we queue mark into a list of marks for destruction in __fsnotify_free_mark() and keep the last mark reference dangling. After the worker waits for SRCU period, it drops the last reference to the mark which frees it. This scheme has the disadvantage that if we hold reference to a mark and drop and reacquire SRCU lock, the mark can get freed immediately which is slightly inconvenient and we will need to avoid this in the future.

Quoted 7 lines

Move to a scheme where queueing of mark into a list of marks for destruction happens when the last reference to the mark is dropped. Also drop reference to the mark held by group list already when mark is removed from that list instead of dropping it only from the destruction worker.

author maintainer
#13 lore raw

PATCH v2 9/22 fsnotify: Detach mark from object list when last reference is dropped

In reply to Jan Kara

Instead of removing mark from object list from fsnotify_detach_mark(), remove the mark when last reference to the mark is dropped. This will allow fanotify to wait for userspace response to event without having to hold onto fsnotify_mark_srcu.

---
 fs/notify/mark.c                 | 198 +++++++++++++++++++++++----------------
 include/linux/fsnotify_backend.h |   4 +-
 kernel/audit_tree.c              |  20 +---
 3 files changed, 124 insertions(+), 98 deletions(-)
fs/notify/mark.c +118 -80
index 521c4bd9b497..dc94b5df7627 100644
@@ -49,7 +49,13 @@
  *
  * A list of notification marks relating to inode / mnt is contained in
  * fsnotify_mark_connector. That structure is alive as long as there are any marks
- * in the list and is also protected by fsnotify_mark_srcu.
+ * in the list and is also protected by fsnotify_mark_srcu. A mark gets
+ * detached from fsnotify_mark_connector when last reference to the mark is dropped.
+ * Thus having mark reference is enough to protect mark->connector pointer
+ * and to make sure fsnotify_mark_connector cannot disappear. Also because we remove
+ * mark from g_list before dropping mark reference associated with that, any
+ * mark found through g_list is guaranteed to have mark->connector set
+ * until we drop group->mark_mutex.
  *
  * LIFETIME:
  * Inode marks survive between when they are added to an inode and when their
@@ -103,17 +109,6 @@ void fsnotify_get_mark(struct fsnotify_mark *mark)
 	atomic_inc(&mark->refcnt);
 }
 
-void fsnotify_put_mark(struct fsnotify_mark *mark)
-{
-	if (atomic_dec_and_test(&mark->refcnt)) {
-		spin_lock(&destroy_lock);
-		list_add(&mark->g_list, &destroy_list);
-		spin_unlock(&destroy_lock);
-		queue_delayed_work(system_unbound_wq, &reaper_work,
-				   FSNOTIFY_REAPER_DELAY);
-	}
-}
-
 static void __fsnotify_recalc_mask(struct fsnotify_mark_connector *conn)
 {
 	u32 new_mask = 0;
@@ -168,55 +163,97 @@ static void fsnotify_connector_destroy_workfn(struct work_struct *work)
 	}
 }
 
-static struct inode *fsnotify_detach_from_object(struct fsnotify_mark *mark)
+static struct inode *fsnotify_detach_connector_from_object(
+					struct fsnotify_mark_connector *conn)
 {
-	struct fsnotify_mark_connector *conn;
 	struct inode *inode = NULL;
-	bool free_conn = false;
 
-	conn = mark->connector;
-	spin_lock(&conn->lock);
-	hlist_del_init_rcu(&mark->obj_list);
-	if (hlist_empty(&conn->list)) {
-		if (conn->flags & FSNOTIFY_OBJ_TYPE_INODE) {
-			inode = conn->inode;
-			inode->i_fsnotify_marks = NULL;
-			inode->i_fsnotify_mask = 0;
-			conn->inode = NULL;
-			conn->flags &= ~FSNOTIFY_OBJ_TYPE_INODE;
-		} else if (conn->flags & FSNOTIFY_OBJ_TYPE_VFSMOUNT) {
-			real_mount(conn->mnt)->mnt_fsnotify_marks = NULL;
-			real_mount(conn->mnt)->mnt_fsnotify_mask = 0;
-			conn->mnt = NULL;
-			conn->flags &= ~FSNOTIFY_OBJ_TYPE_VFSMOUNT;
-		}
-		free_conn = true;
-	} else
-		__fsnotify_recalc_mask(conn);
-	mark->connector = NULL;
-	spin_unlock(&conn->lock);
+	if (conn->flags & FSNOTIFY_OBJ_TYPE_INODE) {
+		inode = conn->inode;
+		inode->i_fsnotify_marks = NULL;
+		inode->i_fsnotify_mask = 0;
+		conn->inode = NULL;
+		conn->flags &= ~FSNOTIFY_OBJ_TYPE_INODE;
+	} else if (conn->flags & FSNOTIFY_OBJ_TYPE_VFSMOUNT) {
+		real_mount(conn->mnt)->mnt_fsnotify_marks = NULL;
+		real_mount(conn->mnt)->mnt_fsnotify_mask = 0;
+		conn->mnt = NULL;
+		conn->flags &= ~FSNOTIFY_OBJ_TYPE_VFSMOUNT;
+	}
+
+	return inode;
+}
+
+static void fsnotify_final_mark_destroy(struct fsnotify_mark *mark)
+{
+	if (mark->group)
+		fsnotify_put_group(mark->group);
+	mark->free_mark(mark);
+}
 
-	if (free_conn) {
+void fsnotify_put_mark(struct fsnotify_mark *mark)
+{
+	/* Catch marks that were actually never attached to object */
+	if (!mark->connector && atomic_dec_and_test(&mark->refcnt)) {
+		fsnotify_final_mark_destroy(mark);
+		return;
+	}
+
+	/*
+	 * We have to be careful so that traversals of obj_list under lock can
+	 * safely grab mark reference.
+	 */
+	if (atomic_dec_and_lock(&mark->refcnt, &mark->connector->lock)) {
+		struct fsnotify_mark_connector *conn;
+		struct inode *inode = NULL;
+		bool free_conn = false;
+
+		conn = mark->connector;
+		hlist_del_init_rcu(&mark->obj_list);
+		if (hlist_empty(&conn->list)) {
+			inode = fsnotify_detach_connector_from_object(conn);
+			free_conn = true;
+		} else
+			__fsnotify_recalc_mask(conn);
+		mark->connector = NULL;
+		spin_unlock(&conn->lock);
+
+		if (inode)
+			iput(inode);
+
+		if (free_conn) {
+			spin_lock(&destroy_lock);
+			conn->destroy_next = connector_destroy_list;
+			connector_destroy_list = conn;
+			spin_unlock(&destroy_lock);
+			queue_work(system_unbound_wq, &connector_reaper_work);
+		}
+		/*
+		 * Note that we didn't update flags telling whether inode cares
+		 * about what's happening with children. We update these flags
+		 * from __fsnotify_parent() lazily when next event happens on
+		 * one of our children.
+		 */
 		spin_lock(&destroy_lock);
-		conn->destroy_next = connector_destroy_list;
-		connector_destroy_list = conn;
+		list_add(&mark->g_list, &destroy_list);
 		spin_unlock(&destroy_lock);
-		queue_work(system_unbound_wq, &connector_reaper_work);
+		queue_delayed_work(system_unbound_wq, &reaper_work,
+				   FSNOTIFY_REAPER_DELAY);
 	}
-
-	return inode;
 }
 
 /*
- * Remove mark from inode / vfsmount list, group list, drop inode reference
- * if we got one.
+ * Mark mark as dead, remove it from group list. Mark still stays in object
+ * list until its last reference is dropped. Note that we rely on mark being
+ * removed from group list before corresponding reference to it is dropped. In
+ * particular we rely on mark->connector being valid while we hold
+ * group->mark_mutex if we found the mark through g_list.
  *
  * Must be called with group->mark_mutex held. The caller must either hold
  * reference to the mark or be protected by fsnotify_mark_srcu.
  */
 void fsnotify_detach_mark(struct fsnotify_mark *mark)
 {
-	struct inode *inode = NULL;
 	struct fsnotify_group *group = mark->group;
 
 	WARN_ON_ONCE(!mutex_is_locked(&group->mark_mutex));
@@ -225,31 +262,15 @@ void fsnotify_detach_mark(struct fsnotify_mark *mark)
 			!!(mark->flags & FSNOTIFY_MARK_FLAG_ATTACHED));
 
 	spin_lock(&mark->lock);
-
 	/* something else already called this function on this mark */
 	if (!(mark->flags & FSNOTIFY_MARK_FLAG_ATTACHED)) {
 		spin_unlock(&mark->lock);
 		return;
 	}
-
 	mark->flags &= ~FSNOTIFY_MARK_FLAG_ATTACHED;
-
-	inode = fsnotify_detach_from_object(mark);
-
-	/*
-	 * Note that we didn't update flags telling whether inode cares about
-	 * what's happening with children. We update these flags from
-	 * __fsnotify_parent() lazily when next event happens on one of our
-	 * children.
-	 */
-
 	list_del_init(&mark->g_list);
-
 	spin_unlock(&mark->lock);
 
-	if (inode)
-		iput(inode);
-
 	atomic_dec(&group->num_marks);
 
 	/* Drop mark reference acquired in fsnotify_add_mark_locked() */
@@ -436,7 +457,9 @@ static int fsnotify_add_mark_list(struct fsnotify_mark *mark,
 	hlist_for_each_entry(lmark, &conn->list, obj_list) {
 		last = lmark;
 
-		if ((lmark->group == mark->group) && !allow_dups) {
+		if ((lmark->group == mark->group) &&
+		    (lmark->flags & FSNOTIFY_MARK_FLAG_ATTACHED) &&
+		    !allow_dups) {
 			err = -EEXIST;
 			goto out_err;
 		}
@@ -487,7 +510,7 @@ int fsnotify_add_mark_locked(struct fsnotify_mark *mark,
 	mark->group = group;
 	list_add(&mark->g_list, &group->marks_list);
 	atomic_inc(&group->num_marks);
-	fsnotify_get_mark(mark); /* for i_list and g_list */
+	fsnotify_get_mark(mark); /* for g_list */
 	spin_unlock(&mark->lock);
 
 	ret = fsnotify_add_mark_list(mark, inode, mnt, allow_dups);
@@ -533,7 +556,8 @@ struct fsnotify_mark *fsnotify_find_mark(struct fsnotify_mark_connector **connp,
 	if (!conn)
 		return NULL;
 	hlist_for_each_entry(mark, &conn->list, obj_list) {
-		if (mark->group == group) {
+		if (mark->group == group &&
+		    (mark->flags & FSNOTIFY_MARK_FLAG_ATTACHED)) {
 			fsnotify_get_mark(mark);
 			fsnotify_put_connector(conn);
 			return mark;
@@ -613,23 +637,39 @@ void fsnotify_detach_group_marks(struct fsnotify_group *group)
 void fsnotify_destroy_marks(struct fsnotify_mark_connector **connp)
 {
 	struct fsnotify_mark_connector *conn;
-	struct fsnotify_mark *mark;
+	struct fsnotify_mark *mark, *old_mark = NULL;
+	struct inode *inode;
 
-	while ((conn = fsnotify_grab_connector(connp))) {
-		/*
-		 * We have to be careful since we can race with e.g.
-		 * fsnotify_clear_marks_by_group() and once we drop the list
-		 * lock, mark can get removed from the obj_list and destroyed.
-		 * But we are holding mark reference so mark cannot be freed
-		 * and calling fsnotify_destroy_mark() more than once is fine.
-		 */
-		mark = hlist_entry(conn->list.first, struct fsnotify_mark,
-				   obj_list);
+	conn = fsnotify_grab_connector(connp);
+	if (!conn)
+		return;
+	/*
+	 * We have to be careful since we can race with e.g.
+	 * fsnotify_clear_marks_by_group() and once we drop the conn->lock, the
+	 * list can get modified. However we are holding mark reference and
+	 * thus our mark cannot be removed from obj_list so we can continue
+	 * iteration after regaining conn->lock.
+	 */
+	hlist_for_each_entry(mark, &conn->list, obj_list) {
 		fsnotify_get_mark(mark);
-		fsnotify_put_connector(conn);
+		spin_unlock(&conn->lock);
+		if (old_mark)
+			fsnotify_put_mark(old_mark);
+		old_mark = mark;
 		fsnotify_destroy_mark(mark, mark->group);
-		fsnotify_put_mark(mark);
+		spin_lock(&conn->lock);
 	}
+	/*
+	 * Detach list from object now so that we don't pin inode until all
+	 * mark references get dropped. It would lead to strange results such
+	 * as delaying inode deletion or blocking unmount.
+	 */
+	inode = fsnotify_detach_connector_from_object(conn);
+	fsnotify_put_connector(conn);
+	if (inode)
+		iput(inode);
+	if (old_mark)
+		fsnotify_put_mark(old_mark);
 }
 
 /*
@@ -662,9 +702,7 @@ void fsnotify_mark_destroy_list(void)
 
 	list_for_each_entry_safe(mark, next, &private_destroy_list, g_list) {
 		list_del_init(&mark->g_list);
-		if (mark->group)
-			fsnotify_put_group(mark->group);
-		mark->free_mark(mark);
+		fsnotify_final_mark_destroy(mark);
 	}
 }
 
include/linux/fsnotify_backend.h +2 -2
index f3df68a64ee6..64ce249288ad 100644
@@ -244,9 +244,9 @@ struct fsnotify_mark {
 	struct list_head g_list;
 	/* Protects inode / mnt pointers, flags, masks */
 	spinlock_t lock;
-	/* List of marks for inode / vfsmount [connector->lock] */
+	/* List of marks for inode / vfsmount [connector->lock, mark ref] */
 	struct hlist_node obj_list;
-	/* Head of list of marks for an object [mark->lock, group->mark_mutex] */
+	/* Head of list of marks for an object [mark ref] */
 	struct fsnotify_mark_connector *connector;
 	/* Events types to ignore [mark->lock, group->mark_mutex] */
 	__u32 ignored_mask;
kernel/audit_tree.c +4 -16
index a878a98f55b3..6962443f2216 100644
@@ -172,27 +172,15 @@ static unsigned long inode_to_key(const struct inode *inode)
 /*
  * Function to return search key in our hash from chunk. Key 0 is special and
  * should never be present in the hash.
- *
- * Must be called with chunk->mark.lock held to protect from connector
- * becoming NULL.
  */
-static unsigned long __chunk_to_key(struct audit_chunk *chunk)
+static unsigned long chunk_to_key(struct audit_chunk *chunk)
 {
-	if (!chunk->mark.connector)
+	/* We have a reference to the mark so it should be attached. */
+	if (WARN_ON_ONCE(!chunk->mark.connector))
 		return 0;
 	return (unsigned long)chunk->mark.connector->inode;
 }
 
-static unsigned long chunk_to_key(struct audit_chunk *chunk)
-{
-	unsigned long key;
-
-	spin_lock(&chunk->mark.lock);
-	key = __chunk_to_key(chunk);
-	spin_unlock(&chunk->mark.lock);
-	return key;
-}
-
 static inline struct list_head *chunk_hash(unsigned long key)
 {
 	unsigned long n = key / L1_CACHE_BYTES;
@@ -202,7 +190,7 @@ static inline struct list_head *chunk_hash(unsigned long key)
 /* hash_lock & entry->lock is held by caller */
 static void insert_hash(struct audit_chunk *chunk)
 {
-	unsigned long key = __chunk_to_key(chunk);
+	unsigned long key = chunk_to_key(chunk);
 	struct list_head *list;
 
 	if (!key)
Signature · 1 line
2.10.2
#14 lore raw

Re: [PATCH 09/22] fsnotify: Detach mark from object list when last reference is dropped

Quoted 6 lines · Jan Kara

Instead of removing mark from object list from fsnotify_detach_mark(), remove the mark when last reference to the mark is dropped. This will allow fanotify to wait for userspace response to event without having to hold onto fsnotify_mark_srcu.

Some nits here.
and re-echoing of comments from the patch that introduces fsnotify_mark_connector, because IMO, this code makes a good example for these arguments.

Quoted 69 lines
---
 fs/notify/mark.c                 | 198 +++++++++++++++++++++++----------------
 include/linux/fsnotify_backend.h |   4 +-
 kernel/audit_tree.c              |  20 +---
 3 files changed, 124 insertions(+), 98 deletions(-)
fs/notify/mark.c +9 -29
index 521c4bd9b497..dc94b5df7627 100644
@@ -49,7 +49,13 @@
  *
  * A list of notification marks relating to inode / mnt is contained in
  * fsnotify_mark_connector. That structure is alive as long as there are any marks
- * in the list and is also protected by fsnotify_mark_srcu.
+ * in the list and is also protected by fsnotify_mark_srcu. A mark gets
+ * detached from fsnotify_mark_connector when last reference to the mark is dropped.
+ * Thus having mark reference is enough to protect mark->connector pointer
+ * and to make sure fsnotify_mark_connector cannot disappear. Also because we remove
+ * mark from g_list before dropping mark reference associated with that, any
+ * mark found through g_list is guaranteed to have mark->connector set
+ * until we drop group->mark_mutex.
  *
  * LIFETIME:
  * Inode marks survive between when they are added to an inode and when their
@@ -103,17 +109,6 @@ void fsnotify_get_mark(struct fsnotify_mark *mark)
        atomic_inc(&mark->refcnt);
 }
 
-void fsnotify_put_mark(struct fsnotify_mark *mark)
-{
-       if (atomic_dec_and_test(&mark->refcnt)) {
-               spin_lock(&destroy_lock);
-               list_add(&mark->g_list, &destroy_list);
-               spin_unlock(&destroy_lock);
-               queue_delayed_work(system_unbound_wq, &reaper_work,
-                                  FSNOTIFY_REAPER_DELAY);
-       }
-}
-
 static void __fsnotify_recalc_mask(struct fsnotify_mark_connector *conn)
 {
        u32 new_mask = 0;
@@ -168,55 +163,97 @@ static void fsnotify_connector_destroy_workfn(struct work_struct *work)
        }
 }
 
-static struct inode *fsnotify_detach_from_object(struct fsnotify_mark *mark)
+static struct inode *fsnotify_detach_connector_from_object(
+                                       struct fsnotify_mark_connector *conn)
 {
-       struct fsnotify_mark_connector *conn;
        struct inode *inode = NULL;
-       bool free_conn = false;
 
-       conn = mark->connector;
-       spin_lock(&conn->lock);
-       hlist_del_init_rcu(&mark->obj_list);
-       if (hlist_empty(&conn->list)) {
-               if (conn->flags & FSNOTIFY_OBJ_TYPE_INODE) {
-                       inode = conn->inode;
-                       inode->i_fsnotify_marks = NULL;
-                       inode->i_fsnotify_mask = 0;
-                       conn->inode = NULL;
-                       conn->flags &= ~FSNOTIFY_OBJ_TYPE_INODE;
-               } else if (conn->flags & FSNOTIFY_OBJ_TYPE_VFSMOUNT) {
-                       real_mount(conn->mnt)->mnt_fsnotify_marks = NULL;
-                       real_mount(conn->mnt)->mnt_fsnotify_mask = 0;
-                       conn->mnt = NULL;

fs/notify/mark.c static void fsnotify_connector_destroy_workfn(struct work_struct *work) · line 173

Quoted 10 lines
fs/notify/mark.c +3 -7
-                       conn->flags &= ~FSNOTIFY_OBJ_TYPE_VFSMOUNT;
-               }
-               free_conn = true;
-       } else
-               __fsnotify_recalc_mask(conn);
-       mark->connector = NULL;
-       spin_unlock(&conn->lock);
+       if (conn->flags & FSNOTIFY_OBJ_TYPE_INODE) {
+               inode = conn->inode;
+               inode->i_fsnotify_marks = NULL;

Repeating question about the need to use rcu_assign_pointer here, so you may address it in this patch instead of the patch that introduced the connector struct.

Quoted 24 lines
fs/notify/mark.c +22 -1
+               inode->i_fsnotify_mask = 0;
+               conn->inode = NULL;
+               conn->flags &= ~FSNOTIFY_OBJ_TYPE_INODE;
+       } else if (conn->flags & FSNOTIFY_OBJ_TYPE_VFSMOUNT) {
+               real_mount(conn->mnt)->mnt_fsnotify_marks = NULL;
+               real_mount(conn->mnt)->mnt_fsnotify_mask = 0;
+               conn->mnt = NULL;
+               conn->flags &= ~FSNOTIFY_OBJ_TYPE_VFSMOUNT;
+       }
+
+       return inode;
+}
+
+static void fsnotify_final_mark_destroy(struct fsnotify_mark *mark)
+{
+       if (mark->group)
+               fsnotify_put_group(mark->group);
+       mark->free_mark(mark);
+}
 
-       if (free_conn) {
+void fsnotify_put_mark(struct fsnotify_mark *mark)
+{
+       /* Catch marks that were actually never attached to object */

fs/notify/mark.c static void fsnotify_connector_destroy_workfn(struct work_struct *work) · line 206

Quoted 10 lines
fs/notify/mark.c +10 -0
+       if (!mark->connector && atomic_dec_and_test(&mark->refcnt)) {
+               fsnotify_final_mark_destroy(mark);
+               return;
+       }
+
+       /*
+        * We have to be careful so that traversals of obj_list under lock can
+        * safely grab mark reference.
+        */
+       if (atomic_dec_and_lock(&mark->refcnt, &mark->connector->lock)) {

Style nit: maybe if (!atomic_dec_and_lock(...)) return; ?

Quoted 37 lines
fs/notify/mark.c +32 -3
+               struct fsnotify_mark_connector *conn;
+               struct inode *inode = NULL;
+               bool free_conn = false;
+
+               conn = mark->connector;
+               hlist_del_init_rcu(&mark->obj_list);
+               if (hlist_empty(&conn->list)) {
+                       inode = fsnotify_detach_connector_from_object(conn);
+                       free_conn = true;
+               } else
+                       __fsnotify_recalc_mask(conn);
+               mark->connector = NULL;
+               spin_unlock(&conn->lock);
+
+               if (inode)
+                       iput(inode);
+
+               if (free_conn) {
+                       spin_lock(&destroy_lock);
+                       conn->destroy_next = connector_destroy_list;
+                       connector_destroy_list = conn;
+                       spin_unlock(&destroy_lock);
+                       queue_work(system_unbound_wq, &connector_reaper_work);
+               }
+               /*
+                * Note that we didn't update flags telling whether inode cares
+                * about what's happening with children. We update these flags
+                * from __fsnotify_parent() lazily when next event happens on
+                * one of our children.
+                */
                spin_lock(&destroy_lock);
-               conn->destroy_next = connector_destroy_list;
-               connector_destroy_list = conn;
+               list_add(&mark->g_list, &destroy_list);
                spin_unlock(&destroy_lock);
-               queue_work(system_unbound_wq, &connector_reaper_work);
+               queue_delayed_work(system_unbound_wq, &reaper_work,

fs/notify/mark.c static void fsnotify_connector_destroy_workfn(struct work_struct *work) · line 246

Quoted 10 lines
fs/notify/mark.c +2 -4
+                                  FSNOTIFY_REAPER_DELAY);
        }
-
-       return inode;
 }
 
 /*
- * Remove mark from inode / vfsmount list, group list, drop inode reference
- * if we got one.
+ * Mark mark as dead, remove it from group list. Mark still stays in object

Nit: marking mark as "dead" would imply
mark->flags &= ~FSNOTIFY_MARK_FLAG_ALIVE
which does not happen here. need to be careful with wording...

You probably meant to write "Mark mark as detached...".

Quoted 112 lines
fs/notify/mark.c +27 -32
+ * list until its last reference is dropped. Note that we rely on mark being
+ * removed from group list before corresponding reference to it is dropped. In
+ * particular we rely on mark->connector being valid while we hold
+ * group->mark_mutex if we found the mark through g_list.
  *
  * Must be called with group->mark_mutex held. The caller must either hold
  * reference to the mark or be protected by fsnotify_mark_srcu.
  */
 void fsnotify_detach_mark(struct fsnotify_mark *mark)
 {
-       struct inode *inode = NULL;
        struct fsnotify_group *group = mark->group;
 
        WARN_ON_ONCE(!mutex_is_locked(&group->mark_mutex));
@@ -225,31 +262,15 @@ void fsnotify_detach_mark(struct fsnotify_mark *mark)
                        !!(mark->flags & FSNOTIFY_MARK_FLAG_ATTACHED));
 
        spin_lock(&mark->lock);
-
        /* something else already called this function on this mark */
        if (!(mark->flags & FSNOTIFY_MARK_FLAG_ATTACHED)) {
                spin_unlock(&mark->lock);
                return;
        }
-
        mark->flags &= ~FSNOTIFY_MARK_FLAG_ATTACHED;
-
-       inode = fsnotify_detach_from_object(mark);
-
-       /*
-        * Note that we didn't update flags telling whether inode cares about
-        * what's happening with children. We update these flags from
-        * __fsnotify_parent() lazily when next event happens on one of our
-        * children.
-        */
-
        list_del_init(&mark->g_list);
-
        spin_unlock(&mark->lock);
 
-       if (inode)
-               iput(inode);
-
        atomic_dec(&group->num_marks);
 
        /* Drop mark reference acquired in fsnotify_add_mark_locked() */
@@ -436,7 +457,9 @@ static int fsnotify_add_mark_list(struct fsnotify_mark *mark,
        hlist_for_each_entry(lmark, &conn->list, obj_list) {
                last = lmark;
 
-               if ((lmark->group == mark->group) && !allow_dups) {
+               if ((lmark->group == mark->group) &&
+                   (lmark->flags & FSNOTIFY_MARK_FLAG_ATTACHED) &&
+                   !allow_dups) {
                        err = -EEXIST;
                        goto out_err;
                }
@@ -487,7 +510,7 @@ int fsnotify_add_mark_locked(struct fsnotify_mark *mark,
        mark->group = group;
        list_add(&mark->g_list, &group->marks_list);
        atomic_inc(&group->num_marks);
-       fsnotify_get_mark(mark); /* for i_list and g_list */
+       fsnotify_get_mark(mark); /* for g_list */
        spin_unlock(&mark->lock);
 
        ret = fsnotify_add_mark_list(mark, inode, mnt, allow_dups);
@@ -533,7 +556,8 @@ struct fsnotify_mark *fsnotify_find_mark(struct fsnotify_mark_connector **connp,
        if (!conn)
                return NULL;
        hlist_for_each_entry(mark, &conn->list, obj_list) {
-               if (mark->group == group) {
+               if (mark->group == group &&
+                   (mark->flags & FSNOTIFY_MARK_FLAG_ATTACHED)) {
                        fsnotify_get_mark(mark);
                        fsnotify_put_connector(conn);
                        return mark;
@@ -613,23 +637,39 @@ void fsnotify_detach_group_marks(struct fsnotify_group *group)
 void fsnotify_destroy_marks(struct fsnotify_mark_connector **connp)
 {
        struct fsnotify_mark_connector *conn;
-       struct fsnotify_mark *mark;
+       struct fsnotify_mark *mark, *old_mark = NULL;
+       struct inode *inode;
 
-       while ((conn = fsnotify_grab_connector(connp))) {
-               /*
-                * We have to be careful since we can race with e.g.
-                * fsnotify_clear_marks_by_group() and once we drop the list
-                * lock, mark can get removed from the obj_list and destroyed.
-                * But we are holding mark reference so mark cannot be freed
-                * and calling fsnotify_destroy_mark() more than once is fine.
-                */
-               mark = hlist_entry(conn->list.first, struct fsnotify_mark,
-                                  obj_list);
+       conn = fsnotify_grab_connector(connp);
+       if (!conn)
+               return;
+       /*
+        * We have to be careful since we can race with e.g.
+        * fsnotify_clear_marks_by_group() and once we drop the conn->lock, the
+        * list can get modified. However we are holding mark reference and
+        * thus our mark cannot be removed from obj_list so we can continue
+        * iteration after regaining conn->lock.
+        */
+       hlist_for_each_entry(mark, &conn->list, obj_list) {
                fsnotify_get_mark(mark);
-               fsnotify_put_connector(conn);
+               spin_unlock(&conn->lock);
+               if (old_mark)
+                       fsnotify_put_mark(old_mark);
+               old_mark = mark;
                fsnotify_destroy_mark(mark, mark->group);

fs/notify/mark.c void fsnotify_detach_group_marks(struct fsnotify_group *group) · line 668

Quoted 10 lines
fs/notify/mark.c +8 -1
-               fsnotify_put_mark(mark);
+               spin_lock(&conn->lock);
        }
+       /*
+        * Detach list from object now so that we don't pin inode until all
+        * mark references get dropped. It would lead to strange results such
+        * as delaying inode deletion or blocking unmount.
+        */
+       inode = fsnotify_detach_connector_from_object(conn);
+       fsnotify_put_connector(conn);

In this code, it is extra dissonant that spin_unlock(&conn->lock); is obfuscated by fsnotify_put_connector(conn);
since you (rightfully) used spin_unlock() inside the for loop. As I suggested in earlier patch - get rid of fsnotify_put_connector() helper is the easy road.

fs/notify/mark.c void fsnotify_detach_group_marks(struct fsnotify_group *group) · line 672

Quoted 4 lines
fs/notify/mark.c +4 -0
+       if (inode)
+               iput(inode);
+       if (old_mark)
+               fsnotify_put_mark(old_mark);

It is not clear to me from the comment above if the order of iput(inode) and fsnotify_put_mark(old_mark) is meaningful or arbitrary, because af far as I understand "until all mark references get dropped" does not refer to "old_mark".

If the order is arbitrary, to me it would have looked better to see the snippet missing from within the for loop here:

               spin_unlock(&conn->lock);
               if (old_mark)
                       fsnotify_put_mark(old_mark);

And iput(inode) as the final chord of this function.

But if order is not arbitrary, please elaborate in comment.

Quoted 14 lines
fs/notify/mark.c +1 -3
 }
 
 /*
@@ -662,9 +702,7 @@ void fsnotify_mark_destroy_list(void)
 
        list_for_each_entry_safe(mark, next, &private_destroy_list, g_list) {
                list_del_init(&mark->g_list);
-               if (mark->group)
-                       fsnotify_put_group(mark->group);
-               mark->free_mark(mark);
+               fsnotify_final_mark_destroy(mark);
        }
 }
 
author maintainer
#15 lore raw

Re: [PATCH 09/22] fsnotify: Detach mark from object list when last reference is dropped

Quoted 7 lines · Amir Goldstein
Quoted 7 lines
fs/notify/mark.c +7 -0
+void fsnotify_put_mark(struct fsnotify_mark *mark)
+{
+       /* Catch marks that were actually never attached to object */
+       if (!mark->connector && atomic_dec_and_test(&mark->refcnt)) {
+               fsnotify_final_mark_destroy(mark);
+               return;
+       }
Quoted 8 lines

fs/notify/mark.c static void fsnotify_connector_destroy_workfn(struct work_struct *work) · line 206

Quoted 6 lines
fs/notify/mark.c +6 -0
+
+       /*
+        * We have to be careful so that traversals of obj_list under lock can
+        * safely grab mark reference.
+        */
+       if (atomic_dec_and_lock(&mark->refcnt, &mark->connector->lock)) {

Style nit: maybe if (!atomic_dec_and_lock(...)) return; ?

OK, done.

Quoted 10 lines
Quoted 4 lines

/*
- * Remove mark from inode / vfsmount list, group list, drop inode reference
- * if we got one.
+ * Mark mark as dead, remove it from group list. Mark still stays in object

Nit: marking mark as "dead" would imply
mark->flags &= ~FSNOTIFY_MARK_FLAG_ALIVE
which does not happen here. need to be careful with wording...

You probably meant to write "Mark mark as detached...".

Yeah, good catch. Thanks.

Quoted 44 lines
Quoted 44 lines
fs/notify/mark.c +23 -13
@@ -613,23 +637,39 @@ void fsnotify_detach_group_marks(struct fsnotify_group *group)
 void fsnotify_destroy_marks(struct fsnotify_mark_connector **connp)
 {
        struct fsnotify_mark_connector *conn;
-       struct fsnotify_mark *mark;
+       struct fsnotify_mark *mark, *old_mark = NULL;
+       struct inode *inode;
 
-       while ((conn = fsnotify_grab_connector(connp))) {
-               /*
-                * We have to be careful since we can race with e.g.
-                * fsnotify_clear_marks_by_group() and once we drop the list
-                * lock, mark can get removed from the obj_list and destroyed.
-                * But we are holding mark reference so mark cannot be freed
-                * and calling fsnotify_destroy_mark() more than once is fine.
-                */
-               mark = hlist_entry(conn->list.first, struct fsnotify_mark,
-                                  obj_list);
+       conn = fsnotify_grab_connector(connp);
+       if (!conn)
+               return;
+       /*
+        * We have to be careful since we can race with e.g.
+        * fsnotify_clear_marks_by_group() and once we drop the conn->lock, the
+        * list can get modified. However we are holding mark reference and
+        * thus our mark cannot be removed from obj_list so we can continue
+        * iteration after regaining conn->lock.
+        */
+       hlist_for_each_entry(mark, &conn->list, obj_list) {
                fsnotify_get_mark(mark);
-               fsnotify_put_connector(conn);
+               spin_unlock(&conn->lock);
+               if (old_mark)
+                       fsnotify_put_mark(old_mark);
+               old_mark = mark;
                fsnotify_destroy_mark(mark, mark->group);
-               fsnotify_put_mark(mark);
+               spin_lock(&conn->lock);
        }
+       /*
+        * Detach list from object now so that we don't pin inode until all
+        * mark references get dropped. It would lead to strange results such
+        * as delaying inode deletion or blocking unmount.
+        */
Quoted 8 lines

fs/notify/mark.c void fsnotify_detach_group_marks(struct fsnotify_group *group) · line 668

Quoted 2 lines
fs/notify/mark.c +2 -0
+       inode = fsnotify_detach_connector_from_object(conn);
+       fsnotify_put_connector(conn);

In this code, it is extra dissonant that spin_unlock(&conn->lock); is obfuscated by fsnotify_put_connector(conn);
since you (rightfully) used spin_unlock() inside the for loop. As I suggested in earlier patch - get rid of fsnotify_put_connector() helper is the easy road.

Done.

Quoted 13 lines

fs/notify/mark.c void fsnotify_detach_group_marks(struct fsnotify_group *group) · line 672

Quoted 4 lines
fs/notify/mark.c +4 -0
+       if (inode)
+               iput(inode);
+       if (old_mark)
+               fsnotify_put_mark(old_mark);

It is not clear to me from the comment above if the order of iput(inode) and fsnotify_put_mark(old_mark) is meaningful or arbitrary, because af far as I understand "until all mark references get dropped" does not refer to "old_mark".

If the order is arbitrary, to me it would have looked better to see the snippet missing from within the for loop here:

Quoted 7 lines
               spin_unlock(&conn->lock);
               if (old_mark)
                       fsnotify_put_mark(old_mark);

And iput(inode) as the final chord of this function.

But if order is not arbitrary, please elaborate in comment.

The order is arbitrary. Frankly, I can see reasons for any ordering - my original thinking was to have iput() closer to where we get inode pointer. But whatever. Reordered.

Honza

Signature · 2 lines
Jan Kara <[email protected]>
SUSE Labs, CR
author maintainer
#16 lore raw

PATCH v2 10/22 fsnotify: Remove special handling of mark destruction on group shutdown

In reply to Jan Kara

Currently we queue all marks for destruction on group shutdown and then destroy them from fsnotify_destroy_group() instead from a worker thread which is the usual path. However worker can already be processing some list of marks to destroy so this does not make 100% all marks are really destroyed by the time group is shut down. This isn't a big problem as each mark holds group reference and thus group stays partially alive until all marks are really freed but there's no point in complicating our lives - just wait for the delayed work to be finished instead.

---
 fs/notify/fsnotify.h |  6 ++----
 fs/notify/group.c    | 10 ++++++----
 fs/notify/mark.c     |  9 +++++----
 3 files changed, 13 insertions(+), 12 deletions(-)
fs/notify/fsnotify.h +2 -4
index 24bc549e9709..cbb9df3b10d0 100644
@@ -36,10 +36,8 @@ static inline void fsnotify_clear_marks_by_mount(struct vfsmount *mnt)
 }
 /* prepare for freeing all marks associated with given group */
 extern void fsnotify_detach_group_marks(struct fsnotify_group *group);
-/*
- * wait for fsnotify_mark_srcu period to end and free all marks in destroy_list
- */
-extern void fsnotify_mark_destroy_list(void);
+/* Wait until all marks queued for destruction are destroyed */
+extern void fsnotify_wait_marks_destroyed(void);
 
 /*
  * update the dentry->d_flags of all of inode's children to indicate if inode cares
fs/notify/group.c +6 -4
index fbe3cbebec16..0fb4aadcc19f 100644
@@ -66,14 +66,16 @@ void fsnotify_destroy_group(struct fsnotify_group *group)
 	 */
 	fsnotify_group_stop_queueing(group);
 
-	/* clear all inode marks for this group, attach them to destroy_list */
+	/* Clear all marks for this group and queue them for destruction */
 	fsnotify_detach_group_marks(group);
 
 	/*
-	 * Wait for fsnotify_mark_srcu period to end and free all marks in
-	 * destroy_list
+	 * Wait until all marks get really destroyed. We could actually destroy
+	 * them ourselves instead of waiting for worker to do it, however that
+	 * would be racy as worker can already be processing some marks before
+	 * we even entered fsnotify_destroy_group().
 	 */
-	fsnotify_mark_destroy_list();
+	fsnotify_wait_marks_destroyed();
 
 	/*
 	 * Since we have waited for fsnotify_mark_srcu in
fs/notify/mark.c +5 -4
index dc94b5df7627..47162c13fc0f 100644
@@ -628,7 +628,7 @@ void fsnotify_detach_group_marks(struct fsnotify_group *group)
 		fsnotify_get_mark(mark);
 		fsnotify_detach_mark(mark);
 		mutex_unlock(&group->mark_mutex);
-		__fsnotify_free_mark(mark);
+		fsnotify_free_mark(mark);
 		fsnotify_put_mark(mark);
 	}
 }
@@ -688,7 +688,7 @@ void fsnotify_init_mark(struct fsnotify_mark *mark,
  * Destroy all marks in destroy_list, waits for SRCU period to finish before
  * actually freeing marks.
  */
-void fsnotify_mark_destroy_list(void)
+static void fsnotify_mark_destroy_workfn(struct work_struct *work)
 {
 	struct fsnotify_mark *mark, *next;
 	struct list_head private_destroy_list;
@@ -706,7 +706,8 @@ void fsnotify_mark_destroy_list(void)
 	}
 }
 
-static void fsnotify_mark_destroy_workfn(struct work_struct *work)
+/* Wait for all marks queued for destruction to be actually destroyed */
+void fsnotify_wait_marks_destroyed(void)
 {
-	fsnotify_mark_destroy_list();
+	flush_delayed_work(&reaper_work);
 }
Signature · 1 line
2.10.2
author maintainer
#17 lore raw

PATCH v2 11/22 fsnotify: Provide framework for dropping SRCU lock in ->handle_event

In reply to Jan Kara

fanotify wants to drop fsnotify_mark_srcu lock when waiting for response from userspace so that the whole notification subsystem is not blocked during that time. This patch provides a framework for safely getting mark reference for a mark found in the object list which pins the mark in that list. We can then drop fsnotify_mark_srcu, wait for userspace response and then safely continue iteration of the object list once we reaquire fsnotify_mark_srcu.

---
 fs/notify/group.c                |  1 +
 fs/notify/mark.c                 | 86 ++++++++++++++++++++++++++++++++++++++++
 include/linux/fsnotify_backend.h |  8 ++++
 3 files changed, 95 insertions(+)
fs/notify/group.c +1 -0
index 0fb4aadcc19f..79439cdf16e0 100644
@@ -126,6 +126,7 @@ struct fsnotify_group *fsnotify_alloc_group(const struct fsnotify_ops *ops)
 	/* set to 0 when there a no external references to this group */
 	atomic_set(&group->refcnt, 1);
 	atomic_set(&group->num_marks, 0);
+	atomic_set(&group->user_waits, 0);
 
 	spin_lock_init(&group->notification_lock);
 	INIT_LIST_HEAD(&group->notification_list);
fs/notify/mark.c +86 -0

104 lines not on this page · raw message

include/linux/fsnotify_backend.h +8 -0
index 64ce249288ad..786dc1cf715c 100644
@@ -162,6 +162,8 @@ struct fsnotify_group {
 	struct fsnotify_event *overflow_event;	/* Event we queue when the
 						 * notification list is too
 						 * full */
+	atomic_t user_waits;		/* Number of tasks waiting for user
+					 * response */
 
 	/* groups can define private fields here or use the void *private */
 	union {
@@ -367,6 +369,12 @@ extern void fsnotify_clear_marks_by_group_flags(struct fsnotify_group *group, un
 extern void fsnotify_get_mark(struct fsnotify_mark *mark);
 extern void fsnotify_put_mark(struct fsnotify_mark *mark);
 extern void fsnotify_unmount_inodes(struct super_block *sb);
+extern void fsnotify_finish_user_wait(struct fsnotify_mark *inode_mark,
+				      struct fsnotify_mark *vfsmount_mark,
+				      int *srcu_idx);
+extern bool fsnotify_prepare_user_wait(struct fsnotify_mark *inode_mark,
+				       struct fsnotify_mark *vfsmount_mark,
+				       int *srcu_idx);
 
 /* put here because inotify does some weird stuff when destroying watches */
 extern void fsnotify_init_event(struct fsnotify_event *event,
Signature · 1 line
2.10.2
#18 lore raw

Re: [PATCH 11/22] fsnotify: Provide framework for dropping SRCU lock in ->handle_event

Quoted 10 lines · Jan Kara

fanotify wants to drop fsnotify_mark_srcu lock when waiting for response from userspace so that the whole notification subsystem is not blocked during that time. This patch provides a framework for safely getting mark reference for a mark found in the object list which pins the mark in that list. We can then drop fsnotify_mark_srcu, wait for userspace response and then safely continue iteration of the object list once we reaquire fsnotify_mark_srcu.

Patch looks good, but I wonder out-loud:

Shouldn't this infrastructure be kept more generic and not only for the use case of
grabbing refcount before user sleep, i.e.:

fsnotify_prepare_user_wait(inode_mark, vfsmount_mark, srcu_idx) ->
fsnotify_get_marks_safe(inode_mark, vfsmount_mark, srcu_idx)

I am not sure it will ever make sense for performance, but is there an inherent reason why marks references could not be taken for any group on object list iteration (in fsnotify()) *before* handle_event() and regardless of user wait?

If there is no "inherent" reason, then I think the API should remain generic (i.e. fsnotify_get_marks_safe()) and in your implementation it can be called only for user wait case.

If you think that using this infrastructure for anything other then user sleep case, then disregard my comment.

Quoted 158 lines
---
 fs/notify/group.c                |  1 +
 fs/notify/mark.c                 | 86 ++++++++++++++++++++++++++++++++++++++++
 include/linux/fsnotify_backend.h |  8 ++++
 3 files changed, 95 insertions(+)
fs/notify/group.c +1 -0
index 0fb4aadcc19f..79439cdf16e0 100644
@@ -126,6 +126,7 @@ struct fsnotify_group *fsnotify_alloc_group(const struct fsnotify_ops *ops)
        /* set to 0 when there a no external references to this group */
        atomic_set(&group->refcnt, 1);
        atomic_set(&group->num_marks, 0);
+       atomic_set(&group->user_waits, 0);
 
        spin_lock_init(&group->notification_lock);
        INIT_LIST_HEAD(&group->notification_list);
fs/notify/mark.c +86 -0
index 47162c13fc0f..fb9b9f080da6 100644
@@ -109,6 +109,16 @@ void fsnotify_get_mark(struct fsnotify_mark *mark)
        atomic_inc(&mark->refcnt);
 }
 
+/*
+ * Get mark reference when we found the mark via lockless traversal of object
+ * list. Mark can be already removed from the list by now and on its way to be
+ * destroyed once SRCU period ends.
+ */
+static bool fsnotify_get_mark_safe(struct fsnotify_mark *mark)
+{
+       return atomic_inc_not_zero(&mark->refcnt);
+}
+
 static void __fsnotify_recalc_mask(struct fsnotify_mark_connector *conn)
 {
        u32 new_mask = 0;
@@ -242,6 +252,76 @@ void fsnotify_put_mark(struct fsnotify_mark *mark)
        }
 }
 
+bool fsnotify_prepare_user_wait(struct fsnotify_mark *inode_mark,
+                               struct fsnotify_mark *vfsmount_mark,
+                               int *srcu_idx)
+{
+       struct fsnotify_group *group;
+
+       if (WARN_ON_ONCE(!inode_mark && !vfsmount_mark))
+               return false;
+
+       if (inode_mark)
+               group = inode_mark->group;
+       else
+               group = vfsmount_mark->group;
+
+       /*
+        * Since acquisition of mark reference is an atomic op as well, we can
+        * be sure this inc is seen before any effect of refcount increment.
+        */
+       atomic_inc(&group->user_waits);
+
+       if (inode_mark) {
+               /* This can fail if mark is being removed */
+               if (!fsnotify_get_mark_safe(inode_mark))
+                       goto out_wait;
+       }
+       if (vfsmount_mark) {
+               if (!fsnotify_get_mark_safe(vfsmount_mark))
+                       goto out_inode;
+       }
+
+       /*
+        * Now that both marks are pinned by refcount in the inode / vfsmount
+        * lists, we can drop SRCU lock, and safely resume the list iteration
+        * once userspace returns.
+        */
+       srcu_read_unlock(&fsnotify_mark_srcu, *srcu_idx);
+
+       return true;
+out_inode:
+       if (inode_mark)
+               fsnotify_put_mark(inode_mark);
+out_wait:
+       if (atomic_dec_and_test(&group->user_waits) && group->shutdown)
+               wake_up(&group->notification_waitq);
+       return false;
+}
+
+void fsnotify_finish_user_wait(struct fsnotify_mark *inode_mark,
+                              struct fsnotify_mark *vfsmount_mark,
+                              int *srcu_idx)
+{
+       struct fsnotify_group *group = NULL;
+
+       *srcu_idx = srcu_read_lock(&fsnotify_mark_srcu);
+       if (inode_mark) {
+               group = inode_mark->group;
+               fsnotify_put_mark(inode_mark);
+       }
+       if (vfsmount_mark) {
+               group = vfsmount_mark->group;
+               fsnotify_put_mark(vfsmount_mark);
+       }
+       /*
+        * We abuse notification_waitq on group shutdown for waiting for all
+        * marks pinned when waiting for userspace.
+        */
+       if (atomic_dec_and_test(&group->user_waits) && group->shutdown)
+               wake_up(&group->notification_waitq);
+}
+
 /*
  * Mark mark as dead, remove it from group list. Mark still stays in object
  * list until its last reference is dropped. Note that we rely on mark being
@@ -631,6 +711,12 @@ void fsnotify_detach_group_marks(struct fsnotify_group *group)
                fsnotify_free_mark(mark);
                fsnotify_put_mark(mark);
        }
+       /*
+        * Some marks can still be pinned when waiting for response from
+        * userspace. Wait for those now. fsnotify_prepare_user_wait() will
+        * not succeed now so this wait is race-free.
+        */
+       wait_event(group->notification_waitq, !atomic_read(&group->user_waits));
 }
 
 /* Destroy all marks attached to inode / vfsmount */
include/linux/fsnotify_backend.h +8 -1
index 64ce249288ad..786dc1cf715c 100644
@@ -162,6 +162,8 @@ struct fsnotify_group {
        struct fsnotify_event *overflow_event;  /* Event we queue when the
                                                 * notification list is too
                                                 * full */
+       atomic_t user_waits;            /* Number of tasks waiting for user
+                                        * response */
 
        /* groups can define private fields here or use the void *private */
        union {
@@ -367,6 +369,12 @@ extern void fsnotify_clear_marks_by_group_flags(struct fsnotify_group *group, un
 extern void fsnotify_get_mark(struct fsnotify_mark *mark);
 extern void fsnotify_put_mark(struct fsnotify_mark *mark);
 extern void fsnotify_unmount_inodes(struct super_block *sb);
+extern void fsnotify_finish_user_wait(struct fsnotify_mark *inode_mark,
+                                     struct fsnotify_mark *vfsmount_mark,
+                                     int *srcu_idx);
+extern bool fsnotify_prepare_user_wait(struct fsnotify_mark *inode_mark,
+                                      struct fsnotify_mark *vfsmount_mark,
+                                      int *srcu_idx);
 
 /* put here because inotify does some weird stuff when destroying watches */
 extern void fsnotify_init_event(struct fsnotify_event *event,
--

2.10.2

author maintainer
#19 lore raw

Re: [PATCH 11/22] fsnotify: Provide framework for dropping SRCU lock in ->handle_event

Quoted 21 lines · Amir Goldstein
Quoted 10 lines · Jan Kara

fanotify wants to drop fsnotify_mark_srcu lock when waiting for response from userspace so that the whole notification subsystem is not blocked during that time. This patch provides a framework for safely getting mark reference for a mark found in the object list which pins the mark in that list. We can then drop fsnotify_mark_srcu, wait for userspace response and then safely continue iteration of the object list once we reaquire fsnotify_mark_srcu.

Patch looks good, but I wonder out-loud:

Shouldn't this infrastructure be kept more generic and not only for the use case of
grabbing refcount before user sleep, i.e.:

fsnotify_prepare_user_wait(inode_mark, vfsmount_mark, srcu_idx) ->
fsnotify_get_marks_safe(inode_mark, vfsmount_mark, srcu_idx)

Quoted 8 lines

I am not sure it will ever make sense for performance, but is there an inherent reason why marks references could not be taken for any group on object list iteration (in fsnotify()) *before* handle_event() and regardless of user wait?

If there is no "inherent" reason, then I think the API should remain generic (i.e. fsnotify_get_marks_safe()) and in your implementation it can be called only for user wait case.

So there's no inherent reason (except for performance as you noted). However the SRCU handling and user_waits counter in the notification group handling are quite special so if anybody wanted to use it somewhere else, he'd better give it a good thought. So for now I'd leave the naming as is and if we ever come with another use for the framework, we can easily rename the functions...

Honza

Quoted 158 lines
Quoted 158 lines
---
 fs/notify/group.c                |  1 +
 fs/notify/mark.c                 | 86 ++++++++++++++++++++++++++++++++++++++++
 include/linux/fsnotify_backend.h |  8 ++++
 3 files changed, 95 insertions(+)
fs/notify/group.c +1 -0
index 0fb4aadcc19f..79439cdf16e0 100644
@@ -126,6 +126,7 @@ struct fsnotify_group *fsnotify_alloc_group(const struct fsnotify_ops *ops)
        /* set to 0 when there a no external references to this group */
        atomic_set(&group->refcnt, 1);
        atomic_set(&group->num_marks, 0);
+       atomic_set(&group->user_waits, 0);
 
        spin_lock_init(&group->notification_lock);
        INIT_LIST_HEAD(&group->notification_list);
fs/notify/mark.c +86 -0
index 47162c13fc0f..fb9b9f080da6 100644
@@ -109,6 +109,16 @@ void fsnotify_get_mark(struct fsnotify_mark *mark)
        atomic_inc(&mark->refcnt);
 }
 
+/*
+ * Get mark reference when we found the mark via lockless traversal of object
+ * list. Mark can be already removed from the list by now and on its way to be
+ * destroyed once SRCU period ends.
+ */
+static bool fsnotify_get_mark_safe(struct fsnotify_mark *mark)
+{
+       return atomic_inc_not_zero(&mark->refcnt);
+}
+
 static void __fsnotify_recalc_mask(struct fsnotify_mark_connector *conn)
 {
        u32 new_mask = 0;
@@ -242,6 +252,76 @@ void fsnotify_put_mark(struct fsnotify_mark *mark)
        }
 }
 
+bool fsnotify_prepare_user_wait(struct fsnotify_mark *inode_mark,
+                               struct fsnotify_mark *vfsmount_mark,
+                               int *srcu_idx)
+{
+       struct fsnotify_group *group;
+
+       if (WARN_ON_ONCE(!inode_mark && !vfsmount_mark))
+               return false;
+
+       if (inode_mark)
+               group = inode_mark->group;
+       else
+               group = vfsmount_mark->group;
+
+       /*
+        * Since acquisition of mark reference is an atomic op as well, we can
+        * be sure this inc is seen before any effect of refcount increment.
+        */
+       atomic_inc(&group->user_waits);
+
+       if (inode_mark) {
+               /* This can fail if mark is being removed */
+               if (!fsnotify_get_mark_safe(inode_mark))
+                       goto out_wait;
+       }
+       if (vfsmount_mark) {
+               if (!fsnotify_get_mark_safe(vfsmount_mark))
+                       goto out_inode;
+       }
+
+       /*
+        * Now that both marks are pinned by refcount in the inode / vfsmount
+        * lists, we can drop SRCU lock, and safely resume the list iteration
+        * once userspace returns.
+        */
+       srcu_read_unlock(&fsnotify_mark_srcu, *srcu_idx);
+
+       return true;
+out_inode:
+       if (inode_mark)
+               fsnotify_put_mark(inode_mark);
+out_wait:
+       if (atomic_dec_and_test(&group->user_waits) && group->shutdown)
+               wake_up(&group->notification_waitq);
+       return false;
+}
+
+void fsnotify_finish_user_wait(struct fsnotify_mark *inode_mark,
+                              struct fsnotify_mark *vfsmount_mark,
+                              int *srcu_idx)
+{
+       struct fsnotify_group *group = NULL;
+
+       *srcu_idx = srcu_read_lock(&fsnotify_mark_srcu);
+       if (inode_mark) {
+               group = inode_mark->group;
+               fsnotify_put_mark(inode_mark);
+       }
+       if (vfsmount_mark) {
+               group = vfsmount_mark->group;
+               fsnotify_put_mark(vfsmount_mark);
+       }
+       /*
+        * We abuse notification_waitq on group shutdown for waiting for all
+        * marks pinned when waiting for userspace.
+        */
+       if (atomic_dec_and_test(&group->user_waits) && group->shutdown)
+               wake_up(&group->notification_waitq);
+}
+
 /*
  * Mark mark as dead, remove it from group list. Mark still stays in object
  * list until its last reference is dropped. Note that we rely on mark being
@@ -631,6 +711,12 @@ void fsnotify_detach_group_marks(struct fsnotify_group *group)
                fsnotify_free_mark(mark);
                fsnotify_put_mark(mark);
        }
+       /*
+        * Some marks can still be pinned when waiting for response from
+        * userspace. Wait for those now. fsnotify_prepare_user_wait() will
+        * not succeed now so this wait is race-free.
+        */
+       wait_event(group->notification_waitq, !atomic_read(&group->user_waits));
 }
 
 /* Destroy all marks attached to inode / vfsmount */
include/linux/fsnotify_backend.h +8 -1
index 64ce249288ad..786dc1cf715c 100644
@@ -162,6 +162,8 @@ struct fsnotify_group {
        struct fsnotify_event *overflow_event;  /* Event we queue when the
                                                 * notification list is too
                                                 * full */
+       atomic_t user_waits;            /* Number of tasks waiting for user
+                                        * response */
 
        /* groups can define private fields here or use the void *private */
        union {
@@ -367,6 +369,12 @@ extern void fsnotify_clear_marks_by_group_flags(struct fsnotify_group *group, un
 extern void fsnotify_get_mark(struct fsnotify_mark *mark);
 extern void fsnotify_put_mark(struct fsnotify_mark *mark);
 extern void fsnotify_unmount_inodes(struct super_block *sb);
+extern void fsnotify_finish_user_wait(struct fsnotify_mark *inode_mark,
+                                     struct fsnotify_mark *vfsmount_mark,
+                                     int *srcu_idx);
+extern bool fsnotify_prepare_user_wait(struct fsnotify_mark *inode_mark,
+                                      struct fsnotify_mark *vfsmount_mark,
+                                      int *srcu_idx);
 
 /* put here because inotify does some weird stuff when destroying watches */
 extern void fsnotify_init_event(struct fsnotify_event *event,
--

2.10.2

Signature · 2 lines
Jan Kara <[email protected]>
SUSE Labs, CR
author maintainer
#20 lore raw

PATCH v2 12/22 fsnotify: Pass SRCU index into handle_event handler

In reply to Jan Kara

Pass index acquired from srcu_read_lock into ->handle_event() handler so that it can release and reacquire SRCU lock via fsnotify_prepare_user_wait() and fsnotify_finish_user_wait() functions. These functions also make sure current marks are appropriately pinned so that iteration protected by srcu in fsnotify() stays safe.

---
 fs/notify/dnotify/dnotify.c          | 3 ++-
 fs/notify/fanotify/fanotify.c        | 3 ++-
 fs/notify/fsnotify.c                 | 7 ++++---
 fs/notify/inotify/inotify.h          | 3 ++-
 fs/notify/inotify/inotify_fsnotify.c | 3 ++-
 fs/notify/inotify/inotify_user.c     | 2 +-
 include/linux/fsnotify_backend.h     | 3 ++-
 kernel/audit_fsnotify.c              | 3 ++-
 kernel/audit_tree.c                  | 3 ++-
 kernel/audit_watch.c                 | 3 ++-
 10 files changed, 21 insertions(+), 12 deletions(-)
fs/notify/dnotify/dnotify.c +2 -1
index 41b2a070761c..19abc5f717dd 100644
@@ -85,7 +85,8 @@ static int dnotify_handle_event(struct fsnotify_group *group,
 				struct fsnotify_mark *inode_mark,
 				struct fsnotify_mark *vfsmount_mark,
 				u32 mask, const void *data, int data_type,
-				const unsigned char *file_name, u32 cookie)
+				const unsigned char *file_name, u32 cookie,
+				int *srcu_idx)
 {
 	struct dnotify_mark *dn_mark;
 	struct dnotify_struct *dn;
fs/notify/fanotify/fanotify.c +2 -1
index bbc175d4213d..2e8ca885fb3e 100644
@@ -178,7 +178,8 @@ static int fanotify_handle_event(struct fsnotify_group *group,
 				 struct fsnotify_mark *inode_mark,
 				 struct fsnotify_mark *fanotify_mark,
 				 u32 mask, const void *data, int data_type,
-				 const unsigned char *file_name, u32 cookie)
+				 const unsigned char *file_name, u32 cookie,
+				 int *srcu_idx)
 {
 	int ret = 0;
 	struct fanotify_event_info *event;
fs/notify/fsnotify.c +4 -3
index d512ef9f75fc..f9920e4acd10 100644
@@ -127,7 +127,8 @@ static int send_to_group(struct inode *to_tell,
 			 struct fsnotify_mark *vfsmount_mark,
 			 __u32 mask, const void *data,
 			 int data_is, u32 cookie,
-			 const unsigned char *file_name)
+			 const unsigned char *file_name,
+			 int *srcu_idx)
 {
 	struct fsnotify_group *group = NULL;
 	__u32 inode_test_mask = 0;
@@ -178,7 +179,7 @@ static int send_to_group(struct inode *to_tell,
 
 	return group->ops->handle_event(group, to_tell, inode_mark,
 					vfsmount_mark, mask, data, data_is,
-					file_name, cookie);
+					file_name, cookie, srcu_idx);
 }
 
 /*
@@ -285,7 +286,7 @@ int fsnotify(struct inode *to_tell, __u32 mask, const void *data, int data_is,
 			}
 		}
 		ret = send_to_group(to_tell, inode_mark, vfsmount_mark, mask,
-				    data, data_is, cookie, file_name);
+				    data, data_is, cookie, file_name, &idx);
 
 		if (ret && (mask & ALL_FSNOTIFY_PERM_EVENTS))
 			goto out;
fs/notify/inotify/inotify.h +2 -1
index a6f5907a3fee..507840969edc 100644
@@ -27,6 +27,7 @@ extern int inotify_handle_event(struct fsnotify_group *group,
 				struct fsnotify_mark *inode_mark,
 				struct fsnotify_mark *vfsmount_mark,
 				u32 mask, const void *data, int data_type,
-				const unsigned char *file_name, u32 cookie);
+				const unsigned char *file_name, u32 cookie,
+				int *srcu_idx);
 
 extern const struct fsnotify_ops inotify_fsnotify_ops;
fs/notify/inotify/inotify_fsnotify.c +2 -1
index 8421f44b3cb3..35f2f39514b8 100644
@@ -67,7 +67,8 @@ int inotify_handle_event(struct fsnotify_group *group,
 			 struct fsnotify_mark *inode_mark,
 			 struct fsnotify_mark *vfsmount_mark,
 			 u32 mask, const void *data, int data_type,
-			 const unsigned char *file_name, u32 cookie)
+			 const unsigned char *file_name, u32 cookie,
+			 int *srcu_idx)
 {
 	struct inotify_inode_mark *i_mark;
 	struct inotify_event_info *event;
fs/notify/inotify/inotify_user.c +1 -1
index 06dae605158d..9fe125f58113 100644
@@ -477,7 +477,7 @@ void inotify_ignored_and_remove_idr(struct fsnotify_mark *fsn_mark,
 
 	/* Queue ignore event for the watch */
 	inotify_handle_event(group, NULL, fsn_mark, NULL, FS_IN_IGNORED,
-			     NULL, FSNOTIFY_EVENT_NONE, NULL, 0);
+			     NULL, FSNOTIFY_EVENT_NONE, NULL, 0, NULL);
 
 	i_mark = container_of(fsn_mark, struct inotify_inode_mark, fsn_mark);
 	/* remove this mark from the idr */
include/linux/fsnotify_backend.h +2 -1
index 786dc1cf715c..b944f084cb95 100644
@@ -97,7 +97,8 @@ struct fsnotify_ops {
 			    struct fsnotify_mark *inode_mark,
 			    struct fsnotify_mark *vfsmount_mark,
 			    u32 mask, const void *data, int data_type,
-			    const unsigned char *file_name, u32 cookie);
+			    const unsigned char *file_name, u32 cookie,
+			    int *srcu_idx);
 	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);
kernel/audit_fsnotify.c +2 -1
index 7ea57e516029..ae8599c7aa81 100644
@@ -168,7 +168,8 @@ static int audit_mark_handle_event(struct fsnotify_group *group,
 				    struct fsnotify_mark *inode_mark,
 				    struct fsnotify_mark *vfsmount_mark,
 				    u32 mask, const void *data, int data_type,
-				    const unsigned char *dname, u32 cookie)
+				    const unsigned char *dname, u32 cookie,
+				    int *srcu_idx)
 {
 	struct audit_fsnotify_mark *audit_mark;
 	const struct inode *inode = NULL;
kernel/audit_tree.c +2 -1
index 6962443f2216..0fe77336a2cd 100644
@@ -979,7 +979,8 @@ static int audit_tree_handle_event(struct fsnotify_group *group,
 				   struct fsnotify_mark *inode_mark,
 				   struct fsnotify_mark *vfsmount_mark,
 				   u32 mask, const void *data, int data_type,
-				   const unsigned char *file_name, u32 cookie)
+				   const unsigned char *file_name, u32 cookie,
+				   int *srcu_idx)
 {
 	return 0;
 }
kernel/audit_watch.c +2 -1
index f79e4658433d..4c06e961e4ba 100644
@@ -472,7 +472,8 @@ static int audit_watch_handle_event(struct fsnotify_group *group,
 				    struct fsnotify_mark *inode_mark,
 				    struct fsnotify_mark *vfsmount_mark,
 				    u32 mask, const void *data, int data_type,
-				    const unsigned char *dname, u32 cookie)
+				    const unsigned char *dname, u32 cookie,
+				    int *srcu_idx)
 {
 	const struct inode *inode;
 	struct audit_parent *parent;
Signature · 1 line
2.10.2
author maintainer
#21 lore raw

PATCH v2 13/22 fanotify: Release SRCU lock when waiting for userspace response

In reply to Jan Kara

When userspace task processing fanotify permission events screws up and does not respond, fsnotify_mark_srcu SRCU is held indefinitely which causes further hangs in the whole notification subsystem. Although we cannot easily solve the problem of operations blocked waiting for response from userspace, we can at least somewhat localize the damage by dropping SRCU lock before waiting for userspace response and reacquiring it when userspace responds.

---
 fs/notify/fanotify/fanotify.c | 21 +++++++++++++++++++--
 1 file changed, 19 insertions(+), 2 deletions(-)
fs/notify/fanotify/fanotify.c +19 -2
index 2e8ca885fb3e..1e1c4cf2e6db 100644
@@ -61,7 +61,10 @@ static int fanotify_merge(struct list_head *list, struct fsnotify_event *event)
 
 #ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS
 static int fanotify_get_response(struct fsnotify_group *group,
-				 struct fanotify_perm_event_info *event)
+				 struct fsnotify_mark *inode_mark,
+				 struct fsnotify_mark *vfsmount_mark,
+				 struct fanotify_perm_event_info *event,
+				 int *srcu_idx)
 {
 	int ret;
 
@@ -69,6 +72,19 @@ static int fanotify_get_response(struct fsnotify_group *group,
 
 	wait_event(group->fanotify_data.access_waitq, event->response);
 
+	/*
+	 * fsnotify_prepare_user_wait() fails if we race with mark deletion.
+	 * Just let the operation pass in that case.
+	 */
+	if (!fsnotify_prepare_user_wait(inode_mark, vfsmount_mark, srcu_idx)) {
+		event->response = FAN_ALLOW;
+		goto out;
+	}
+
+	wait_event(group->fanotify_data.access_waitq, event->response);
+
+	fsnotify_finish_user_wait(inode_mark, vfsmount_mark, srcu_idx);
+out:
 	/* userspace responded, convert to something usable */
 	switch (event->response) {
 	case FAN_ALLOW:
@@ -220,7 +236,8 @@ static int fanotify_handle_event(struct fsnotify_group *group,
 
 #ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS
 	if (mask & FAN_ALL_PERM_EVENTS) {
-		ret = fanotify_get_response(group, FANOTIFY_PE(fsn_event));
+		ret = fanotify_get_response(group, inode_mark, fanotify_mark,
+					    FANOTIFY_PE(fsn_event), srcu_idx);
 		fsnotify_destroy_event(group, fsn_event);
 	}
 #endif
Signature · 1 line
2.10.2
author maintainer
#22 lore raw

PATCH v2 14/22 fsnotify: Remove fsnotify_set_mark_{,ignored_}mask_locked()

In reply to Jan Kara

These helpers are now only a simple assignment and just obfuscate what is going on. Remove them.

---
 fs/notify/dnotify/dnotify.c        |  9 +++------
 fs/notify/fanotify/fanotify_user.c |  9 ++++-----
 fs/notify/inotify/inotify_user.c   |  6 ++----
 fs/notify/mark.c                   | 14 --------------
 include/linux/fsnotify_backend.h   |  4 ----
 5 files changed, 9 insertions(+), 33 deletions(-)
fs/notify/dnotify/dnotify.c +3 -6
index 19abc5f717dd..2f89ed821ebc 100644
@@ -52,7 +52,7 @@ struct dnotify_mark {
  */
 static void dnotify_recalc_inode_mask(struct fsnotify_mark *fsn_mark)
 {
-	__u32 new_mask, old_mask;
+	__u32 new_mask = 0;
 	struct dnotify_struct *dn;
 	struct dnotify_mark *dn_mark  = container_of(fsn_mark,
 						     struct dnotify_mark,
@@ -60,14 +60,11 @@ static void dnotify_recalc_inode_mask(struct fsnotify_mark *fsn_mark)
 
 	assert_spin_locked(&fsn_mark->lock);
 
-	old_mask = fsn_mark->mask;
-	new_mask = 0;
 	for (dn = dn_mark->dn; dn != NULL; dn = dn->dn_next)
 		new_mask |= (dn->dn_mask & ~FS_DN_MULTISHOT);
-	fsnotify_set_mark_mask_locked(fsn_mark, new_mask);
-
-	if (old_mask == new_mask)
+	if (fsn_mark->mask == new_mask)
 		return;
+	fsn_mark->mask = new_mask;
 
 	fsnotify_recalc_mask(fsn_mark->connector);
 }
fs/notify/fanotify/fanotify_user.c +4 -5
index 8dcec9eecafd..14a1036eee06 100644
@@ -510,13 +510,12 @@ static __u32 fanotify_mark_remove_from_mask(struct fsnotify_mark *fsn_mark,
 			tmask &= ~FAN_ONDIR;
 
 		oldmask = fsn_mark->mask;
-		fsnotify_set_mark_mask_locked(fsn_mark, tmask);
+		fsn_mark->mask = tmask;
 	} else {
 		__u32 tmask = fsn_mark->ignored_mask & ~mask;
 		if (flags & FAN_MARK_ONDIR)
 			tmask &= ~FAN_ONDIR;
-
-		fsnotify_set_mark_ignored_mask_locked(fsn_mark, tmask);
+		fsn_mark->ignored_mask = tmask;
 	}
 	*destroy = !(fsn_mark->mask | fsn_mark->ignored_mask);
 	spin_unlock(&fsn_mark->lock);
@@ -598,13 +597,13 @@ static __u32 fanotify_mark_add_to_mask(struct fsnotify_mark *fsn_mark,
 			tmask |= FAN_ONDIR;
 
 		oldmask = fsn_mark->mask;
-		fsnotify_set_mark_mask_locked(fsn_mark, tmask);
+		fsn_mark->mask = tmask;
 	} else {
 		__u32 tmask = fsn_mark->ignored_mask | mask;
 		if (flags & FAN_MARK_ONDIR)
 			tmask |= FAN_ONDIR;
 
-		fsnotify_set_mark_ignored_mask_locked(fsn_mark, tmask);
+		fsn_mark->ignored_mask = tmask;
 		if (flags & FAN_MARK_IGNORED_SURV_MODIFY)
 			fsn_mark->flags |= FSNOTIFY_MARK_FLAG_IGNORED_SURV_MODIFY;
 	}
fs/notify/inotify/inotify_user.c +2 -4
index 9fe125f58113..ee12b8f01c01 100644
@@ -516,14 +516,12 @@ static int inotify_update_existing_watch(struct fsnotify_group *group,
 	i_mark = container_of(fsn_mark, struct inotify_inode_mark, fsn_mark);
 
 	spin_lock(&fsn_mark->lock);
-
 	old_mask = fsn_mark->mask;
 	if (add)
-		fsnotify_set_mark_mask_locked(fsn_mark, (fsn_mark->mask | mask));
+		fsn_mark->mask |= mask;
 	else
-		fsnotify_set_mark_mask_locked(fsn_mark, mask);
+		fsn_mark->mask = mask;
 	new_mask = fsn_mark->mask;
-
 	spin_unlock(&fsn_mark->lock);
 
 	if (old_mask != new_mask) {
fs/notify/mark.c +0 -14
index fb9b9f080da6..8b6d135ac711 100644
@@ -396,20 +396,6 @@ void fsnotify_destroy_mark(struct fsnotify_mark *mark,
 	fsnotify_free_mark(mark);
 }
 
-void fsnotify_set_mark_mask_locked(struct fsnotify_mark *mark, __u32 mask)
-{
-	assert_spin_locked(&mark->lock);
-
-	mark->mask = mask;
-}
-
-void fsnotify_set_mark_ignored_mask_locked(struct fsnotify_mark *mark, __u32 mask)
-{
-	assert_spin_locked(&mark->lock);
-
-	mark->ignored_mask = mask;
-}
-
 /*
  * Sorting function for lists of fsnotify marks.
  *
include/linux/fsnotify_backend.h +0 -4
index b944f084cb95..c41afada7fe9 100644
@@ -345,10 +345,6 @@ extern void fsnotify_init_mark(struct fsnotify_mark *mark, void (*free_mark)(str
 extern struct fsnotify_mark *fsnotify_find_inode_mark(struct fsnotify_group *group, struct inode *inode);
 /* find (and take a reference) to a mark associated with group and vfsmount */
 extern struct fsnotify_mark *fsnotify_find_vfsmount_mark(struct fsnotify_group *group, struct vfsmount *mnt);
-/* set the ignored_mask of a mark */
-extern void fsnotify_set_mark_ignored_mask_locked(struct fsnotify_mark *mark, __u32 mask);
-/* set the mask of a mark (might pin the object into memory */
-extern void fsnotify_set_mark_mask_locked(struct fsnotify_mark *mark, __u32 mask);
 /* attach the mark to both the group and the inode */
 extern int fsnotify_add_mark(struct fsnotify_mark *mark, struct fsnotify_group *group,
 			     struct inode *inode, struct vfsmount *mnt, int allow_dups);
Signature · 1 line
2.10.2
author maintainer
#23 lore raw

PATCH v2 15/22 fsnotify: Remove fsnotify_recalc_{inode|vfsmount}_mask()

In reply to Jan Kara

These helpers are just very thin wrappers now. Remove them.

---
 fs/notify/fanotify/fanotify_user.c | 8 ++++----
 fs/notify/inode_mark.c             | 5 -----
 fs/notify/inotify/inotify_user.c   | 2 +-
 fs/notify/vfsmount_mark.c          | 5 -----
 include/linux/fsnotify_backend.h   | 4 ----
 5 files changed, 5 insertions(+), 19 deletions(-)
fs/notify/fanotify/fanotify_user.c +4 -4
index 14a1036eee06..b68cec253a21 100644
@@ -541,7 +541,7 @@ static int fanotify_remove_vfsmount_mark(struct fsnotify_group *group,
 	removed = fanotify_mark_remove_from_mask(fsn_mark, mask, flags,
 						 &destroy_mark);
 	if (removed & real_mount(mnt)->mnt_fsnotify_mask)
-		fsnotify_recalc_vfsmount_mask(mnt);
+		fsnotify_recalc_mask(real_mount(mnt)->mnt_fsnotify_marks);
 	if (destroy_mark)
 		fsnotify_detach_mark(fsn_mark);
 	mutex_unlock(&group->mark_mutex);
@@ -570,7 +570,7 @@ static int fanotify_remove_inode_mark(struct fsnotify_group *group,
 	removed = fanotify_mark_remove_from_mask(fsn_mark, mask, flags,
 						 &destroy_mark);
 	if (removed & inode->i_fsnotify_mask)
-		fsnotify_recalc_inode_mask(inode);
+		fsnotify_recalc_mask(inode->i_fsnotify_marks);
 	if (destroy_mark)
 		fsnotify_detach_mark(fsn_mark);
 	mutex_unlock(&group->mark_mutex);
@@ -655,7 +655,7 @@ static int fanotify_add_vfsmount_mark(struct fsnotify_group *group,
 	}
 	added = fanotify_mark_add_to_mask(fsn_mark, mask, flags);
 	if (added & ~real_mount(mnt)->mnt_fsnotify_mask)
-		fsnotify_recalc_vfsmount_mask(mnt);
+		fsnotify_recalc_mask(real_mount(mnt)->mnt_fsnotify_marks);
 	mutex_unlock(&group->mark_mutex);
 
 	fsnotify_put_mark(fsn_mark);
@@ -692,7 +692,7 @@ static int fanotify_add_inode_mark(struct fsnotify_group *group,
 	}
 	added = fanotify_mark_add_to_mask(fsn_mark, mask, flags);
 	if (added & ~inode->i_fsnotify_mask)
-		fsnotify_recalc_inode_mask(inode);
+		fsnotify_recalc_mask(inode->i_fsnotify_marks);
 	mutex_unlock(&group->mark_mutex);
 
 	fsnotify_put_mark(fsn_mark);
fs/notify/inode_mark.c +0 -5
index b9370316727e..2188329da3c2 100644
@@ -30,11 +30,6 @@
 
 #include "../internal.h"
 
-void fsnotify_recalc_inode_mask(struct inode *inode)
-{
-	fsnotify_recalc_mask(inode->i_fsnotify_marks);
-}
-
 /*
  * Given a group clear all of the inode marks associated with that group.
  */
fs/notify/inotify/inotify_user.c +1 -1
index ee12b8f01c01..bbcebf6beeb9 100644
@@ -532,7 +532,7 @@ static int inotify_update_existing_watch(struct fsnotify_group *group,
 
 		/* update the inode with this new fsn_mark */
 		if (dropped || do_inode)
-			fsnotify_recalc_inode_mask(inode);
+			fsnotify_recalc_mask(inode->i_fsnotify_marks);
 
 	}
 
fs/notify/vfsmount_mark.c +0 -5
index 8fc1aca21bcf..41bff46576c2 100644
@@ -29,11 +29,6 @@
 #include <linux/fsnotify_backend.h>
 #include "fsnotify.h"
 
-void fsnotify_recalc_vfsmount_mask(struct vfsmount *mnt)
-{
-	fsnotify_recalc_mask(real_mount(mnt)->mnt_fsnotify_marks);
-}
-
 void fsnotify_clear_vfsmount_marks_by_group(struct fsnotify_group *group)
 {
 	fsnotify_clear_marks_by_group_flags(group, FSNOTIFY_OBJ_TYPE_VFSMOUNT);
include/linux/fsnotify_backend.h +0 -4
index c41afada7fe9..606b24e6d2a9 100644
@@ -336,10 +336,6 @@ extern struct fsnotify_event *fsnotify_remove_first_event(struct fsnotify_group
 
 /* Calculate mask of events for a list of marks */
 extern void fsnotify_recalc_mask(struct fsnotify_mark_connector *conn);
-/* run all marks associated with a vfsmount and update mnt->mnt_fsnotify_mask */
-extern void fsnotify_recalc_vfsmount_mask(struct vfsmount *mnt);
-/* run all marks associated with an inode and update inode->i_fsnotify_mask */
-extern void fsnotify_recalc_inode_mask(struct inode *inode);
 extern void fsnotify_init_mark(struct fsnotify_mark *mark, void (*free_mark)(struct fsnotify_mark *mark));
 /* find (and take a reference) to a mark associated with group and inode */
 extern struct fsnotify_mark *fsnotify_find_inode_mark(struct fsnotify_group *group, struct inode *inode);
Signature · 1 line
2.10.2
author maintainer
#24 lore raw

PATCH v2 16/22 fsnotify: Inline fsnotify_clear_{inode|vfsmount}_mark_group()

In reply to Jan Kara

Inline these helpers as they are very thin. We still keep them as we don't want to expose details about how list type is determined.

---
 fs/notify/inode_mark.c           |  8 --------
 fs/notify/vfsmount_mark.c        |  5 -----
 include/linux/fsnotify_backend.h | 14 ++++++++++----
 3 files changed, 10 insertions(+), 17 deletions(-)
fs/notify/inode_mark.c +0 -8
index 2188329da3c2..bdc15f736082 100644
@@ -31,14 +31,6 @@
 #include "../internal.h"
 
 /*
- * Given a group clear all of the inode marks associated with that group.
- */
-void fsnotify_clear_inode_marks_by_group(struct fsnotify_group *group)
-{
-	fsnotify_clear_marks_by_group_flags(group, FSNOTIFY_OBJ_TYPE_INODE);
-}
-
-/*
  * given a group and inode, find the mark associated with that combination.
  * if found take a reference to that mark and return it, else return NULL
  */
fs/notify/vfsmount_mark.c +0 -5
index 41bff46576c2..1e692c56deec 100644
@@ -29,11 +29,6 @@
 #include <linux/fsnotify_backend.h>
 #include "fsnotify.h"
 
-void fsnotify_clear_vfsmount_marks_by_group(struct fsnotify_group *group)
-{
-	fsnotify_clear_marks_by_group_flags(group, FSNOTIFY_OBJ_TYPE_VFSMOUNT);
-}
-
 /*
  * given a group and vfsmount, find the mark associated with that combination.
  * if found take a reference to that mark and return it, else return NULL
include/linux/fsnotify_backend.h +10 -4
index 606b24e6d2a9..86586aa022ce 100644
@@ -353,12 +353,18 @@ extern void fsnotify_destroy_mark(struct fsnotify_mark *mark,
 extern void fsnotify_detach_mark(struct fsnotify_mark *mark);
 /* free mark */
 extern void fsnotify_free_mark(struct fsnotify_mark *mark);
-/* run all the marks in a group, and clear all of the vfsmount marks */
-extern void fsnotify_clear_vfsmount_marks_by_group(struct fsnotify_group *group);
-/* run all the marks in a group, and clear all of the inode marks */
-extern void fsnotify_clear_inode_marks_by_group(struct fsnotify_group *group);
 /* run all the marks in a group, and clear all of the marks attached to given object type */
 extern void fsnotify_clear_marks_by_group_flags(struct fsnotify_group *group, unsigned int flags);
+/* run all the marks in a group, and clear all of the vfsmount marks */
+static inline void fsnotify_clear_vfsmount_marks_by_group(struct fsnotify_group *group)
+{
+	fsnotify_clear_marks_by_group_flags(group, FSNOTIFY_OBJ_TYPE_VFSMOUNT);
+}
+/* run all the marks in a group, and clear all of the inode marks */
+static inline void fsnotify_clear_inode_marks_by_group(struct fsnotify_group *group)
+{
+	fsnotify_clear_marks_by_group_flags(group, FSNOTIFY_OBJ_TYPE_INODE);
+}
 extern void fsnotify_get_mark(struct fsnotify_mark *mark);
 extern void fsnotify_put_mark(struct fsnotify_mark *mark);
 extern void fsnotify_unmount_inodes(struct super_block *sb);
Signature · 1 line
2.10.2
author maintainer
#25 lore raw

PATCH v2 17/22 fsnotify: Rename fsnotify_clear_marks_by_group_flags()

In reply to Jan Kara

The _flags() suffix in the function name was more confusing than explaining so just remove it. Also rename the argument from 'flags' to 'type' to better explain what the function expects.

---
 fs/notify/mark.c                 | 12 +++++-------
 include/linux/fsnotify_backend.h |  6 +++---
 2 files changed, 8 insertions(+), 10 deletions(-)
fs/notify/mark.c +5 -7
index 8b6d135ac711..bce92c44578c 100644
@@ -67,7 +67,7 @@
  * - The fs the inode is on is unmounted.  (fsnotify_inode_delete/fsnotify_unmount_inodes)
  * - Something explicitly requests that it be removed.  (fsnotify_destroy_mark)
  * - The fsnotify_group associated with the mark is going away and all such marks
- *   need to be cleaned up. (fsnotify_clear_marks_by_group)
+ *   need to be cleaned up. (fsnotify_detach_group_marks)
  *
  * This has the very interesting property of being able to run concurrently with
  * any (or all) other directions.
@@ -633,11 +633,9 @@ struct fsnotify_mark *fsnotify_find_mark(struct fsnotify_mark_connector **connp,
 	return NULL;
 }
 
-/*
- * clear any marks in a group in which mark->flags & flags is true
- */
-void fsnotify_clear_marks_by_group_flags(struct fsnotify_group *group,
-					 unsigned int flags)
+/* Clear any marks in a group with given type */
+void fsnotify_clear_marks_by_group(struct fsnotify_group *group,
+				   unsigned int type)
 {
 	struct fsnotify_mark *lmark, *mark;
 	LIST_HEAD(to_free);
@@ -653,7 +651,7 @@ void fsnotify_clear_marks_by_group_flags(struct fsnotify_group *group,
 	 */
 	mutex_lock_nested(&group->mark_mutex, SINGLE_DEPTH_NESTING);
 	list_for_each_entry_safe(mark, lmark, &group->marks_list, g_list) {
-		if (mark->connector->flags & flags)
+		if (mark->connector->flags & type)
 			list_move(&mark->g_list, &to_free);
 	}
 	mutex_unlock(&group->mark_mutex);
include/linux/fsnotify_backend.h +3 -3
index 86586aa022ce..680b7e92101b 100644
@@ -354,16 +354,16 @@ extern void fsnotify_detach_mark(struct fsnotify_mark *mark);
 /* free mark */
 extern void fsnotify_free_mark(struct fsnotify_mark *mark);
 /* run all the marks in a group, and clear all of the marks attached to given object type */
-extern void fsnotify_clear_marks_by_group_flags(struct fsnotify_group *group, unsigned int flags);
+extern void fsnotify_clear_marks_by_group(struct fsnotify_group *group, unsigned int type);
 /* run all the marks in a group, and clear all of the vfsmount marks */
 static inline void fsnotify_clear_vfsmount_marks_by_group(struct fsnotify_group *group)
 {
-	fsnotify_clear_marks_by_group_flags(group, FSNOTIFY_OBJ_TYPE_VFSMOUNT);
+	fsnotify_clear_marks_by_group(group, FSNOTIFY_OBJ_TYPE_VFSMOUNT);
 }
 /* run all the marks in a group, and clear all of the inode marks */
 static inline void fsnotify_clear_inode_marks_by_group(struct fsnotify_group *group)
 {
-	fsnotify_clear_marks_by_group_flags(group, FSNOTIFY_OBJ_TYPE_INODE);
+	fsnotify_clear_marks_by_group(group, FSNOTIFY_OBJ_TYPE_INODE);
 }
 extern void fsnotify_get_mark(struct fsnotify_mark *mark);
 extern void fsnotify_put_mark(struct fsnotify_mark *mark);
Signature · 1 line
2.10.2
reviewer Reviewed-by on v2 17/22
#26 lore raw

Re: [PATCH 17/22] fsnotify: Rename fsnotify_clear_marks_by_group_flags()

Quoted 7 lines · Jan Kara

The _flags() suffix in the function name was more confusing than explaining so just remove it. Also rename the argument from 'flags' to 'type' to better explain what the function expects.

---

author maintainer
#27 lore raw

PATCH v2 18/22 fsnotify: Remove fsnotify_detach_group_marks()

In reply to Jan Kara

The function is already mostly contained in what fsnotify_clear_marks_by_group() does. Just update that function to not select marks when all of them should be destroyed and remove fsnotify_detach_group_marks().

---
 fs/notify/fsnotify.h             |  2 --
 fs/notify/group.c                |  9 +++++++-
 fs/notify/mark.c                 | 45 +++++++++-------------------------------
 include/linux/fsnotify_backend.h |  2 ++
 4 files changed, 20 insertions(+), 38 deletions(-)
fs/notify/fsnotify.h +0 -2
index cbb9df3b10d0..da28dc44b244 100644
@@ -34,8 +34,6 @@ static inline void fsnotify_clear_marks_by_mount(struct vfsmount *mnt)
 {
 	fsnotify_destroy_marks(&real_mount(mnt)->mnt_fsnotify_marks);
 }
-/* prepare for freeing all marks associated with given group */
-extern void fsnotify_detach_group_marks(struct fsnotify_group *group);
 /* Wait until all marks queued for destruction are destroyed */
 extern void fsnotify_wait_marks_destroyed(void);
 
fs/notify/group.c +8 -1
index 79439cdf16e0..32357534de18 100644
@@ -67,7 +67,14 @@ void fsnotify_destroy_group(struct fsnotify_group *group)
 	fsnotify_group_stop_queueing(group);
 
 	/* Clear all marks for this group and queue them for destruction */
-	fsnotify_detach_group_marks(group);
+	fsnotify_clear_marks_by_group(group, FSNOTIFY_OBJ_ALL_TYPES);
+
+	/*
+	 * Some marks can still be pinned when waiting for response from
+	 * userspace. Wait for those now. fsnotify_prepare_user_wait() will
+	 * not succeed now so this wait is race-free.
+	 */
+	wait_event(group->notification_waitq, !atomic_read(&group->user_waits));
 
 	/*
 	 * Wait until all marks get really destroyed. We could actually destroy
fs/notify/mark.c +10 -35

75 lines not on this page · raw message

include/linux/fsnotify_backend.h +2 -0
index 680b7e92101b..812b1b151020 100644
@@ -206,6 +206,8 @@ struct fsnotify_mark_connector {
 	spinlock_t lock;
 #define FSNOTIFY_OBJ_TYPE_INODE		0x01
 #define FSNOTIFY_OBJ_TYPE_VFSMOUNT	0x02
+#define FSNOTIFY_OBJ_ALL_TYPES		(FSNOTIFY_OBJ_TYPE_INODE | \
+					 FSNOTIFY_OBJ_TYPE_VFSMOUNT)
 	unsigned int flags;	/* Type of object [lock] */
 	union {	/* Object pointer [lock] */
 		struct inode *inode;
Signature · 1 line
2.10.2
reviewer Reviewed-by on v2 18/22
#28 lore raw

Re: [PATCH 18/22] fsnotify: Remove fsnotify_detach_group_marks()

Quoted 6 lines · Jan Kara

The function is already mostly contained in what fsnotify_clear_marks_by_group() does. Just update that function to not select marks when all of them should be destroyed and remove fsnotify_detach_group_marks().

author maintainer
#29 lore raw

PATCH v2 19/22 fsnotify: Remove fsnotify_find_{inode|vfsmount}_mark()

In reply to Jan Kara

These are very thin wrappers, just remove them. Drop fs/notify/vfsmount_mark.c as it is empty now.

---
 fs/notify/Makefile                 |  2 +-
 fs/notify/dnotify/dnotify.c        |  4 ++--
 fs/notify/fanotify/fanotify_user.c | 12 ++++++-----
 fs/notify/fsnotify.h               |  4 ----
 fs/notify/inode_mark.c             | 10 ---------
 fs/notify/inotify/inotify_user.c   |  2 +-
 fs/notify/vfsmount_mark.c          | 42 --------------------------------------
 include/linux/fsnotify_backend.h   |  8 ++++----
 kernel/audit_tree.c                |  3 ++-
 kernel/audit_watch.c               |  2 +-
 10 files changed, 18 insertions(+), 71 deletions(-)
 delete mode 100644 fs/notify/vfsmount_mark.c
fs/notify/Makefile +1 -1
index 96d3420d0242..ebb64a0282d1 100644
@@ -1,5 +1,5 @@
 obj-$(CONFIG_FSNOTIFY)		+= fsnotify.o notification.o group.o inode_mark.o \
-				   mark.o vfsmount_mark.o fdinfo.o
+				   mark.o fdinfo.o
 
 obj-y			+= dnotify/
 obj-y			+= inotify/
fs/notify/dnotify/dnotify.c +2 -2
index 2f89ed821ebc..4c3bb4059f88 100644
@@ -157,7 +157,7 @@ void dnotify_flush(struct file *filp, fl_owner_t id)
 	if (!S_ISDIR(inode->i_mode))
 		return;
 
-	fsn_mark = fsnotify_find_inode_mark(dnotify_group, inode);
+	fsn_mark = fsnotify_find_mark(&inode->i_fsnotify_marks, dnotify_group);
 	if (!fsn_mark)
 		return;
 	dn_mark = container_of(fsn_mark, struct dnotify_mark, fsn_mark);
@@ -313,7 +313,7 @@ int fcntl_dirnotify(int fd, struct file *filp, unsigned long arg)
 	mutex_lock(&dnotify_group->mark_mutex);
 
 	/* add the new_fsn_mark or find an old one. */
-	fsn_mark = fsnotify_find_inode_mark(dnotify_group, inode);
+	fsn_mark = fsnotify_find_mark(&inode->i_fsnotify_marks, dnotify_group);
 	if (fsn_mark) {
 		dn_mark = container_of(fsn_mark, struct dnotify_mark, fsn_mark);
 		spin_lock(&fsn_mark->lock);
fs/notify/fanotify/fanotify_user.c +7 -5
index b68cec253a21..7b4d9d67f4f9 100644
@@ -532,7 +532,8 @@ static int fanotify_remove_vfsmount_mark(struct fsnotify_group *group,
 	int destroy_mark;
 
 	mutex_lock(&group->mark_mutex);
-	fsn_mark = fsnotify_find_vfsmount_mark(group, mnt);
+	fsn_mark = fsnotify_find_mark(&real_mount(mnt)->mnt_fsnotify_marks,
+				      group);
 	if (!fsn_mark) {
 		mutex_unlock(&group->mark_mutex);
 		return -ENOENT;
@@ -561,7 +562,7 @@ static int fanotify_remove_inode_mark(struct fsnotify_group *group,
 	int destroy_mark;
 
 	mutex_lock(&group->mark_mutex);
-	fsn_mark = fsnotify_find_inode_mark(group, inode);
+	fsn_mark = fsnotify_find_mark(&inode->i_fsnotify_marks, group);
 	if (!fsn_mark) {
 		mutex_unlock(&group->mark_mutex);
 		return -ENOENT;
@@ -577,7 +578,7 @@ static int fanotify_remove_inode_mark(struct fsnotify_group *group,
 	if (destroy_mark)
 		fsnotify_free_mark(fsn_mark);
 
-	/* matches the fsnotify_find_inode_mark() */
+	/* matches the fsnotify_find_mark() */
 	fsnotify_put_mark(fsn_mark);
 
 	return 0;
@@ -645,7 +646,8 @@ static int fanotify_add_vfsmount_mark(struct fsnotify_group *group,
 	__u32 added;
 
 	mutex_lock(&group->mark_mutex);
-	fsn_mark = fsnotify_find_vfsmount_mark(group, mnt);
+	fsn_mark = fsnotify_find_mark(&real_mount(mnt)->mnt_fsnotify_marks,
+				      group);
 	if (!fsn_mark) {
 		fsn_mark = fanotify_add_new_mark(group, NULL, mnt);
 		if (IS_ERR(fsn_mark)) {
@@ -682,7 +684,7 @@ static int fanotify_add_inode_mark(struct fsnotify_group *group,
 		return 0;
 
 	mutex_lock(&group->mark_mutex);
-	fsn_mark = fsnotify_find_inode_mark(group, inode);
+	fsn_mark = fsnotify_find_mark(&inode->i_fsnotify_marks, group);
 	if (!fsn_mark) {
 		fsn_mark = fanotify_add_new_mark(group, inode, NULL);
 		if (IS_ERR(fsn_mark)) {
fs/notify/fsnotify.h +0 -4
index da28dc44b244..797daadad0bb 100644
@@ -18,10 +18,6 @@ extern struct srcu_struct fsnotify_mark_srcu;
 extern int fsnotify_compare_groups(struct fsnotify_group *a,
 				   struct fsnotify_group *b);
 
-/* Find mark belonging to given group attached to given connector */
-extern struct fsnotify_mark *fsnotify_find_mark(
-					struct fsnotify_mark_connector **connp,
-					struct fsnotify_group *group);
 /* Destroy all marks connected via given connector */
 extern void fsnotify_destroy_marks(struct fsnotify_mark_connector **connp);
 /* run the list of all marks associated with inode and destroy them */
fs/notify/inode_mark.c +0 -10
index bdc15f736082..5cc317bad082 100644
@@ -30,16 +30,6 @@
 
 #include "../internal.h"
 
-/*
- * given a group and inode, find the mark associated with that combination.
- * if found take a reference to that mark and return it, else return NULL
- */
-struct fsnotify_mark *fsnotify_find_inode_mark(struct fsnotify_group *group,
-					       struct inode *inode)
-{
-	return fsnotify_find_mark(&inode->i_fsnotify_marks, group);
-}
-
 /**
  * fsnotify_unmount_inodes - an sb is unmounting.  handle any watched inodes.
  * @sb: superblock being unmounted.
fs/notify/inotify/inotify_user.c +1 -1
index bbcebf6beeb9..546a4c7d0f03 100644
@@ -509,7 +509,7 @@ static int inotify_update_existing_watch(struct fsnotify_group *group,
 
 	mask = inotify_arg_to_mask(arg);
 
-	fsn_mark = fsnotify_find_inode_mark(group, inode);
+	fsn_mark = fsnotify_find_mark(&inode->i_fsnotify_marks, group);
 	if (!fsn_mark)
 		return -ENOENT;
 
fs/notify/vfsmount_mark.c deleted +0 -42

42 lines not on this page · raw message

include/linux/fsnotify_backend.h +4 -4
index 812b1b151020..093f66818c6f 100644
@@ -339,10 +339,10 @@ extern struct fsnotify_event *fsnotify_remove_first_event(struct fsnotify_group
 /* Calculate mask of events for a list of marks */
 extern void fsnotify_recalc_mask(struct fsnotify_mark_connector *conn);
 extern void fsnotify_init_mark(struct fsnotify_mark *mark, void (*free_mark)(struct fsnotify_mark *mark));
-/* find (and take a reference) to a mark associated with group and inode */
-extern struct fsnotify_mark *fsnotify_find_inode_mark(struct fsnotify_group *group, struct inode *inode);
-/* find (and take a reference) to a mark associated with group and vfsmount */
-extern struct fsnotify_mark *fsnotify_find_vfsmount_mark(struct fsnotify_group *group, struct vfsmount *mnt);
+/* Find mark belonging to given group in the list of marks */
+extern struct fsnotify_mark *fsnotify_find_mark(
+					struct fsnotify_mark_connector **connp,
+					struct fsnotify_group *group);
 /* attach the mark to both the group and the inode */
 extern int fsnotify_add_mark(struct fsnotify_mark *mark, struct fsnotify_group *group,
 			     struct inode *inode, struct vfsmount *mnt, int allow_dups);
kernel/audit_tree.c +2 -1
index 0fe77336a2cd..b6785489fd3d 100644
@@ -385,7 +385,8 @@ static int tag_chunk(struct inode *inode, struct audit_tree *tree)
 	struct node *p;
 	int n;
 
-	old_entry = fsnotify_find_inode_mark(audit_tree_group, inode);
+	old_entry = fsnotify_find_mark(&inode->i_fsnotify_marks,
+				       audit_tree_group);
 	if (!old_entry)
 		return create_chunk(inode, tree);
 
kernel/audit_watch.c +1 -1
index 4c06e961e4ba..800084cf0539 100644
@@ -102,7 +102,7 @@ static inline struct audit_parent *audit_find_parent(struct inode *inode)
 	struct audit_parent *parent = NULL;
 	struct fsnotify_mark *entry;
 
-	entry = fsnotify_find_inode_mark(audit_watch_group, inode);
+	entry = fsnotify_find_mark(&inode->i_fsnotify_marks, audit_watch_group);
 	if (entry)
 		parent = container_of(entry, struct audit_parent, mark);
 
Signature · 1 line
2.10.2
author maintainer
#30 lore raw

PATCH v2 20/22 fsnotify: Drop inode_mark.c

In reply to Jan Kara

inode_mark.c now contains only a single function. Move it to fs/notify/fsnotify.c and remove inode_mark.c.

---
 fs/notify/Makefile     |  4 +--
 fs/notify/fsnotify.c   | 57 ++++++++++++++++++++++++++++++++
 fs/notify/inode_mark.c | 88 --------------------------------------------------
 3 files changed, 59 insertions(+), 90 deletions(-)
 delete mode 100644 fs/notify/inode_mark.c
fs/notify/Makefile +2 -2
index ebb64a0282d1..3e969ae91b60 100644
@@ -1,5 +1,5 @@
-obj-$(CONFIG_FSNOTIFY)		+= fsnotify.o notification.o group.o inode_mark.o \
-				   mark.o fdinfo.o
+obj-$(CONFIG_FSNOTIFY)		+= fsnotify.o notification.o group.o mark.o \
+				   fdinfo.o
 
 obj-y			+= dnotify/
 obj-y			+= inotify/
fs/notify/fsnotify.c +57 -0

63 lines not on this page · raw message

fs/notify/inode_mark.c deleted +0 -88

88 lines not on this page · raw message

Signature · 1 line
2.10.2
author maintainer
#31 lore raw

PATCH v2 21/22 fsnotify: Add group pointer in fsnotify_init_mark()

In reply to Jan Kara

Currently we initialize mark->group only in fsnotify_add_mark_lock(). However we will need to access fsnotify_ops of corresponding group from fsnotify_put_mark() so we need mark->group initialized earlier. Do that in fsnotify_init_mark() which has a consequence that once fsnotify_init_mark() is called on a mark, the mark has to be destroyed by fsnotify_put_mark().

---
 fs/notify/dnotify/dnotify.c        |  5 ++---
 fs/notify/fanotify/fanotify_user.c |  4 ++--
 fs/notify/inotify/inotify_user.c   |  5 ++---
 fs/notify/mark.c                   | 17 ++++++++++-------
 include/linux/fsnotify_backend.h   | 12 +++++++-----
 kernel/audit_fsnotify.c            |  7 ++++---
 kernel/audit_tree.c                | 15 ++++++++-------
 kernel/audit_watch.c               |  5 +++--
 8 files changed, 38 insertions(+), 32 deletions(-)
fs/notify/dnotify/dnotify.c +2 -3
index 4c3bb4059f88..eb8ee2cbdb8f 100644
@@ -305,7 +305,7 @@ int fcntl_dirnotify(int fd, struct file *filp, unsigned long arg)
 
 	/* set up the new_fsn_mark and new_dn_mark */
 	new_fsn_mark = &new_dn_mark->fsn_mark;
-	fsnotify_init_mark(new_fsn_mark, dnotify_free_mark);
+	fsnotify_init_mark(new_fsn_mark, dnotify_group, dnotify_free_mark);
 	new_fsn_mark->mask = mask;
 	new_dn_mark->dn = NULL;
 
@@ -318,8 +318,7 @@ int fcntl_dirnotify(int fd, struct file *filp, unsigned long arg)
 		dn_mark = container_of(fsn_mark, struct dnotify_mark, fsn_mark);
 		spin_lock(&fsn_mark->lock);
 	} else {
-		fsnotify_add_mark_locked(new_fsn_mark, dnotify_group, inode,
-					 NULL, 0);
+		fsnotify_add_mark_locked(new_fsn_mark, inode, NULL, 0);
 		spin_lock(&new_fsn_mark->lock);
 		fsn_mark = new_fsn_mark;
 		dn_mark = new_dn_mark;
fs/notify/fanotify/fanotify_user.c +2 -2
index 7b4d9d67f4f9..4ba51b836a44 100644
@@ -627,8 +627,8 @@ static struct fsnotify_mark *fanotify_add_new_mark(struct fsnotify_group *group,
 	if (!mark)
 		return ERR_PTR(-ENOMEM);
 
-	fsnotify_init_mark(mark, fanotify_free_mark);
-	ret = fsnotify_add_mark_locked(mark, group, inode, mnt, 0);
+	fsnotify_init_mark(mark, group, fanotify_free_mark);
+	ret = fsnotify_add_mark_locked(mark, inode, mnt, 0);
 	if (ret) {
 		fsnotify_put_mark(mark);
 		return ERR_PTR(ret);
fs/notify/inotify/inotify_user.c +2 -3
index 546a4c7d0f03..38e66d497b3b 100644
@@ -561,7 +561,7 @@ static int inotify_new_watch(struct fsnotify_group *group,
 	if (unlikely(!tmp_i_mark))
 		return -ENOMEM;
 
-	fsnotify_init_mark(&tmp_i_mark->fsn_mark, inotify_free_mark);
+	fsnotify_init_mark(&tmp_i_mark->fsn_mark, group, inotify_free_mark);
 	tmp_i_mark->fsn_mark.mask = mask;
 	tmp_i_mark->wd = -1;
 
@@ -574,8 +574,7 @@ static int inotify_new_watch(struct fsnotify_group *group,
 		goto out_err;
 
 	/* we are on the idr, now get on the inode */
-	ret = fsnotify_add_mark_locked(&tmp_i_mark->fsn_mark, group, inode,
-				       NULL, 0);
+	ret = fsnotify_add_mark_locked(&tmp_i_mark->fsn_mark, inode, NULL, 0);
 	if (ret) {
 		/* we failed to get on the inode, get off the idr */
 		inotify_remove_from_idr(group, tmp_i_mark);
fs/notify/mark.c +10 -7
index de71030f4bd2..5f8b2c725105 100644
@@ -553,10 +553,10 @@ static int fsnotify_add_mark_list(struct fsnotify_mark *mark,
  * These marks may be used for the fsnotify backend to determine which
  * event types should be delivered to which group.
  */
-int fsnotify_add_mark_locked(struct fsnotify_mark *mark,
-			     struct fsnotify_group *group, struct inode *inode,
+int fsnotify_add_mark_locked(struct fsnotify_mark *mark, struct inode *inode,
 			     struct vfsmount *mnt, int allow_dups)
 {
+	struct fsnotify_group *group = mark->group;
 	int ret = 0;
 
 	BUG_ON(inode && mnt);
@@ -572,8 +572,6 @@ int fsnotify_add_mark_locked(struct fsnotify_mark *mark,
 	spin_lock(&mark->lock);
 	mark->flags |= FSNOTIFY_MARK_FLAG_ALIVE | FSNOTIFY_MARK_FLAG_ATTACHED;
 
-	fsnotify_get_group(group);
-	mark->group = group;
 	list_add(&mark->g_list, &group->marks_list);
 	atomic_inc(&group->num_marks);
 	fsnotify_get_mark(mark); /* for g_list */
@@ -598,12 +596,14 @@ int fsnotify_add_mark_locked(struct fsnotify_mark *mark,
 	return ret;
 }
 
-int fsnotify_add_mark(struct fsnotify_mark *mark, struct fsnotify_group *group,
-		      struct inode *inode, struct vfsmount *mnt, int allow_dups)
+int fsnotify_add_mark(struct fsnotify_mark *mark, struct inode *inode,
+		      struct vfsmount *mnt, int allow_dups)
 {
 	int ret;
+	struct fsnotify_group *group = mark->group;
+
 	mutex_lock(&group->mark_mutex);
-	ret = fsnotify_add_mark_locked(mark, group, inode, mnt, allow_dups);
+	ret = fsnotify_add_mark_locked(mark, inode, mnt, allow_dups);
 	mutex_unlock(&group->mark_mutex);
 	return ret;
 }
@@ -721,12 +721,15 @@ void fsnotify_destroy_marks(struct fsnotify_mark_connector **connp)
  * Nothing fancy, just initialize lists and locks and counters.
  */
 void fsnotify_init_mark(struct fsnotify_mark *mark,
+			struct fsnotify_group *group,
 			void (*free_mark)(struct fsnotify_mark *mark))
 {
 	memset(mark, 0, sizeof(*mark));
 	spin_lock_init(&mark->lock);
 	atomic_set(&mark->refcnt, 1);
 	mark->free_mark = free_mark;
+	fsnotify_get_group(group);
+	mark->group = group;
 }
 
 /*
include/linux/fsnotify_backend.h +7 -5
index 093f66818c6f..f87d447c1457 100644
@@ -338,15 +338,17 @@ extern struct fsnotify_event *fsnotify_remove_first_event(struct fsnotify_group
 
 /* Calculate mask of events for a list of marks */
 extern void fsnotify_recalc_mask(struct fsnotify_mark_connector *conn);
-extern void fsnotify_init_mark(struct fsnotify_mark *mark, void (*free_mark)(struct fsnotify_mark *mark));
+extern void fsnotify_init_mark(struct fsnotify_mark *mark,
+			       struct fsnotify_group *group,
+			       void (*free_mark)(struct fsnotify_mark *mark));
 /* Find mark belonging to given group in the list of marks */
 extern struct fsnotify_mark *fsnotify_find_mark(
 					struct fsnotify_mark_connector **connp,
 					struct fsnotify_group *group);
-/* attach the mark to both the group and the inode */
-extern int fsnotify_add_mark(struct fsnotify_mark *mark, struct fsnotify_group *group,
-			     struct inode *inode, struct vfsmount *mnt, int allow_dups);
-extern int fsnotify_add_mark_locked(struct fsnotify_mark *mark, struct fsnotify_group *group,
+/* attach the mark to the inode or vfsmount */
+extern int fsnotify_add_mark(struct fsnotify_mark *mark, struct inode *inode,
+			     struct vfsmount *mnt, int allow_dups);
+extern int fsnotify_add_mark_locked(struct fsnotify_mark *mark,
 				    struct inode *inode, struct vfsmount *mnt, int allow_dups);
 /* given a group and a mark, flag mark to be freed when all references are dropped */
 extern void fsnotify_destroy_mark(struct fsnotify_mark *mark,
kernel/audit_fsnotify.c +4 -3
index ae8599c7aa81..5bb7e920f126 100644
@@ -103,15 +103,16 @@ struct audit_fsnotify_mark *audit_alloc_mark(struct audit_krule *krule, char *pa
 		goto out;
 	}
 
-	fsnotify_init_mark(&audit_mark->mark, audit_fsnotify_free_mark);
+	fsnotify_init_mark(&audit_mark->mark, audit_fsnotify_group,
+			   audit_fsnotify_free_mark);
 	audit_mark->mark.mask = AUDIT_FS_EVENTS;
 	audit_mark->path = pathname;
 	audit_update_mark(audit_mark, dentry->d_inode);
 	audit_mark->rule = krule;
 
-	ret = fsnotify_add_mark(&audit_mark->mark, audit_fsnotify_group, inode, NULL, true);
+	ret = fsnotify_add_mark(&audit_mark->mark, inode, NULL, true);
 	if (ret < 0) {
-		audit_fsnotify_mark_free(audit_mark);
+		fsnotify_put_mark(&audit_mark->mark);
 		audit_mark = ERR_PTR(ret);
 	}
 out:
kernel/audit_tree.c +8 -7
index b6785489fd3d..a799cea717de 100644
@@ -154,7 +154,8 @@ static struct audit_chunk *alloc_chunk(int count)
 		INIT_LIST_HEAD(&chunk->owners[i].list);
 		chunk->owners[i].index = i;
 	}
-	fsnotify_init_mark(&chunk->mark, audit_tree_destroy_watch);
+	fsnotify_init_mark(&chunk->mark, audit_tree_group,
+			   audit_tree_destroy_watch);
 	chunk->mark.mask = FS_IN_IGNORED;
 	return chunk;
 }
@@ -256,7 +257,7 @@ static void untag_chunk(struct node *p)
 		spin_unlock(&entry->lock);
 		mutex_unlock(&entry->group->mark_mutex);
 		if (new)
-			free_chunk(new);
+			fsnotify_put_mark(&new->mark);
 		goto out;
 	}
 
@@ -280,8 +281,8 @@ static void untag_chunk(struct node *p)
 	if (!new)
 		goto Fallback;
 
-	if (fsnotify_add_mark_locked(&new->mark, entry->group,
-				     entry->connector->inode, NULL, 1)) {
+	if (fsnotify_add_mark_locked(&new->mark, entry->connector->inode,
+				     NULL, 1)) {
 		fsnotify_put_mark(&new->mark);
 		goto Fallback;
 	}
@@ -346,7 +347,7 @@ static int create_chunk(struct inode *inode, struct audit_tree *tree)
 		return -ENOMEM;
 
 	entry = &chunk->mark;
-	if (fsnotify_add_mark(entry, audit_tree_group, inode, NULL, 0)) {
+	if (fsnotify_add_mark(entry, inode, NULL, 0)) {
 		fsnotify_put_mark(entry);
 		return -ENOSPC;
 	}
@@ -418,11 +419,11 @@ static int tag_chunk(struct inode *inode, struct audit_tree *tree)
 		spin_unlock(&old_entry->lock);
 		mutex_unlock(&old_entry->group->mark_mutex);
 		fsnotify_put_mark(old_entry);
-		free_chunk(chunk);
+		fsnotify_put_mark(&chunk->mark);
 		return -ENOENT;
 	}
 
-	if (fsnotify_add_mark_locked(chunk_entry, old_entry->group,
+	if (fsnotify_add_mark_locked(chunk_entry,
 			     old_entry->connector->inode, NULL, 1)) {
 		spin_unlock(&old_entry->lock);
 		mutex_unlock(&old_entry->group->mark_mutex);
kernel/audit_watch.c +3 -2
index 800084cf0539..0f355086215a 100644
@@ -157,9 +157,10 @@ static struct audit_parent *audit_init_parent(struct path *path)
 
 	INIT_LIST_HEAD(&parent->watches);
 
-	fsnotify_init_mark(&parent->mark, audit_watch_free_mark);
+	fsnotify_init_mark(&parent->mark, audit_watch_group,
+			   audit_watch_free_mark);
 	parent->mark.mask = AUDIT_FS_WATCH;
-	ret = fsnotify_add_mark(&parent->mark, audit_watch_group, inode, NULL, 0);
+	ret = fsnotify_add_mark(&parent->mark, inode, NULL, 0);
 	if (ret < 0) {
 		audit_free_parent(parent);
 		return ERR_PTR(ret);
Signature · 1 line
2.10.2
#32 lore raw

Re: [PATCH 21/22] fsnotify: Add group pointer in fsnotify_init_mark()

Quoted 8 lines · Jan Kara

Currently we initialize mark->group only in fsnotify_add_mark_lock(). However we will need to access fsnotify_ops of corresponding group from fsnotify_put_mark() so we need mark->group initialized earlier. Do that in fsnotify_init_mark() which has a consequence that once fsnotify_init_mark() is called on a mark, the mark has to be destroyed by fsnotify_put_mark().

The API change looks good to me, but as I wrote on v1, I rather that Paul reviews the changes in the audit code, which is the code that was missing the fsnotify_put_mark() calls.

Quoted 99 lines
kernel/audit_fsnotify.c +4 -3
@@ -103,15 +103,16 @@ struct audit_fsnotify_mark *audit_alloc_mark(struct audit_krule *krule, char *pa
                goto out;
        }
 
-       fsnotify_init_mark(&audit_mark->mark, audit_fsnotify_free_mark);
+       fsnotify_init_mark(&audit_mark->mark, audit_fsnotify_group,
+                          audit_fsnotify_free_mark);
        audit_mark->mark.mask = AUDIT_FS_EVENTS;
        audit_mark->path = pathname;
        audit_update_mark(audit_mark, dentry->d_inode);
        audit_mark->rule = krule;
 
-       ret = fsnotify_add_mark(&audit_mark->mark, audit_fsnotify_group, inode, NULL, true);
+       ret = fsnotify_add_mark(&audit_mark->mark, inode, NULL, true);
        if (ret < 0) {
-               audit_fsnotify_mark_free(audit_mark);
+               fsnotify_put_mark(&audit_mark->mark);
                audit_mark = ERR_PTR(ret);
        }
 out:
kernel/audit_tree.c +8 -7
index b6785489fd3d..a799cea717de 100644
@@ -154,7 +154,8 @@ static struct audit_chunk *alloc_chunk(int count)
                INIT_LIST_HEAD(&chunk->owners[i].list);
                chunk->owners[i].index = i;
        }
-       fsnotify_init_mark(&chunk->mark, audit_tree_destroy_watch);
+       fsnotify_init_mark(&chunk->mark, audit_tree_group,
+                          audit_tree_destroy_watch);
        chunk->mark.mask = FS_IN_IGNORED;
        return chunk;
 }
@@ -256,7 +257,7 @@ static void untag_chunk(struct node *p)
                spin_unlock(&entry->lock);
                mutex_unlock(&entry->group->mark_mutex);
                if (new)
-                       free_chunk(new);
+                       fsnotify_put_mark(&new->mark);
                goto out;
        }
 
@@ -280,8 +281,8 @@ static void untag_chunk(struct node *p)
        if (!new)
                goto Fallback;
 
-       if (fsnotify_add_mark_locked(&new->mark, entry->group,
-                                    entry->connector->inode, NULL, 1)) {
+       if (fsnotify_add_mark_locked(&new->mark, entry->connector->inode,
+                                    NULL, 1)) {
                fsnotify_put_mark(&new->mark);
                goto Fallback;
        }
@@ -346,7 +347,7 @@ static int create_chunk(struct inode *inode, struct audit_tree *tree)
                return -ENOMEM;
 
        entry = &chunk->mark;
-       if (fsnotify_add_mark(entry, audit_tree_group, inode, NULL, 0)) {
+       if (fsnotify_add_mark(entry, inode, NULL, 0)) {
                fsnotify_put_mark(entry);
                return -ENOSPC;
        }
@@ -418,11 +419,11 @@ static int tag_chunk(struct inode *inode, struct audit_tree *tree)
                spin_unlock(&old_entry->lock);
                mutex_unlock(&old_entry->group->mark_mutex);
                fsnotify_put_mark(old_entry);
-               free_chunk(chunk);
+               fsnotify_put_mark(&chunk->mark);
                return -ENOENT;
        }
 
-       if (fsnotify_add_mark_locked(chunk_entry, old_entry->group,
+       if (fsnotify_add_mark_locked(chunk_entry,
                             old_entry->connector->inode, NULL, 1)) {
                spin_unlock(&old_entry->lock);
                mutex_unlock(&old_entry->group->mark_mutex);
kernel/audit_watch.c +3 -3
index 800084cf0539..0f355086215a 100644
@@ -157,9 +157,10 @@ static struct audit_parent *audit_init_parent(struct path *path)
 
        INIT_LIST_HEAD(&parent->watches);
 
-       fsnotify_init_mark(&parent->mark, audit_watch_free_mark);
+       fsnotify_init_mark(&parent->mark, audit_watch_group,
+                          audit_watch_free_mark);
        parent->mark.mask = AUDIT_FS_WATCH;
-       ret = fsnotify_add_mark(&parent->mark, audit_watch_group, inode, NULL, 0);
+       ret = fsnotify_add_mark(&parent->mark, inode, NULL, 0);
        if (ret < 0) {
                audit_free_parent(parent);
                return ERR_PTR(ret);
--

2.10.2

author maintainer
#33 lore raw

Re: [PATCH 21/22] fsnotify: Add group pointer in fsnotify_init_mark()

Quoted 8 lines · Amir Goldstein
Quoted 7 lines · Jan Kara

Currently we initialize mark->group only in fsnotify_add_mark_lock(). However we will need to access fsnotify_ops of corresponding group from fsnotify_put_mark() so we need mark->group initialized earlier. Do that in fsnotify_init_mark() which has a consequence that once fsnotify_init_mark() is called on a mark, the mark has to be destroyed by fsnotify_put_mark().

Quoted 6 lines
Quoted 1 line

The API change looks good to me, but as I wrote on v1, I rather that Paul reviews the changes in the audit code, which is the code that was missing the fsnotify_put_mark() calls.

OK. Paul?

Honza

Signature · 2 lines
Jan Kara <[email protected]>
SUSE Labs, CR
author maintainer
#34 lore raw

PATCH v2 22/22 fsnotify: Move ->free_mark callback to fsnotify_ops

In reply to Jan Kara

Pointer to ->free_mark callback unnecessarily occupies one long in each fsnotify_mark although they are the same for all marks from one notification group. Move the callback pointer to fsnotify_ops.

---
 fs/notify/dnotify/dnotify.c          |  3 ++-
 fs/notify/fanotify/fanotify.c        |  6 ++++++
 fs/notify/fanotify/fanotify.h        |  1 +
 fs/notify/fanotify/fanotify_user.c   |  9 ++-------
 fs/notify/inotify/inotify.h          |  2 ++
 fs/notify/inotify/inotify_fsnotify.c | 11 +++++++++++
 fs/notify/inotify/inotify_user.c     | 14 ++------------
 fs/notify/mark.c                     | 13 +++++++------
 include/linux/fsnotify_backend.h     |  6 +++---
 kernel/audit_fsnotify.c              |  4 ++--
 kernel/audit_tree.c                  |  4 ++--
 kernel/audit_watch.c                 |  4 ++--
 12 files changed, 42 insertions(+), 35 deletions(-)
fs/notify/dnotify/dnotify.c +2 -1
index eb8ee2cbdb8f..7ff92308aa54 100644
@@ -135,6 +135,7 @@ static void dnotify_free_mark(struct fsnotify_mark *fsn_mark)
 
 static struct fsnotify_ops dnotify_fsnotify_ops = {
 	.handle_event = dnotify_handle_event,
+	.free_mark = dnotify_free_mark,
 };
 
 /*
@@ -305,7 +306,7 @@ int fcntl_dirnotify(int fd, struct file *filp, unsigned long arg)
 
 	/* set up the new_fsn_mark and new_dn_mark */
 	new_fsn_mark = &new_dn_mark->fsn_mark;
-	fsnotify_init_mark(new_fsn_mark, dnotify_group, dnotify_free_mark);
+	fsnotify_init_mark(new_fsn_mark, dnotify_group);
 	new_fsn_mark->mask = mask;
 	new_dn_mark->dn = NULL;
 
fs/notify/fanotify/fanotify.c +6 -0
index 1e1c4cf2e6db..3e446db466ac 100644
@@ -270,8 +270,14 @@ static void fanotify_free_event(struct fsnotify_event *fsn_event)
 	kmem_cache_free(fanotify_event_cachep, event);
 }
 
+static void fanotify_free_mark(struct fsnotify_mark *fsn_mark)
+{
+	kmem_cache_free(fanotify_mark_cache, fsn_mark);
+}
+
 const struct fsnotify_ops fanotify_fsnotify_ops = {
 	.handle_event = fanotify_handle_event,
 	.free_group_priv = fanotify_free_group_priv,
 	.free_event = fanotify_free_event,
+	.free_mark = fanotify_free_mark,
 };
fs/notify/fanotify/fanotify.h +1 -0
index 4500a74f8d38..4eb6f5efa282 100644
@@ -2,6 +2,7 @@
 #include <linux/path.h>
 #include <linux/slab.h>
 
+extern struct kmem_cache *fanotify_mark_cache;
 extern struct kmem_cache *fanotify_event_cachep;
 extern struct kmem_cache *fanotify_perm_event_cachep;
 
fs/notify/fanotify/fanotify_user.c +2 -7
index 4ba51b836a44..a1d5b121fdf8 100644
@@ -40,7 +40,7 @@
 
 extern const struct fsnotify_ops fanotify_fsnotify_ops;
 
-static struct kmem_cache *fanotify_mark_cache __read_mostly;
+struct kmem_cache *fanotify_mark_cache __read_mostly;
 struct kmem_cache *fanotify_event_cachep __read_mostly;
 struct kmem_cache *fanotify_perm_event_cachep __read_mostly;
 
@@ -444,11 +444,6 @@ static const struct file_operations fanotify_fops = {
 	.llseek		= noop_llseek,
 };
 
-static void fanotify_free_mark(struct fsnotify_mark *fsn_mark)
-{
-	kmem_cache_free(fanotify_mark_cache, fsn_mark);
-}
-
 static int fanotify_find_path(int dfd, const char __user *filename,
 			      struct path *path, unsigned int flags)
 {
@@ -627,7 +622,7 @@ static struct fsnotify_mark *fanotify_add_new_mark(struct fsnotify_group *group,
 	if (!mark)
 		return ERR_PTR(-ENOMEM);
 
-	fsnotify_init_mark(mark, group, fanotify_free_mark);
+	fsnotify_init_mark(mark, group);
 	ret = fsnotify_add_mark_locked(mark, inode, mnt, 0);
 	if (ret) {
 		fsnotify_put_mark(mark);
fs/notify/inotify/inotify.h +2 -0
index 507840969edc..049e15da5564 100644
@@ -31,3 +31,5 @@ extern int inotify_handle_event(struct fsnotify_group *group,
 				int *srcu_idx);
 
 extern const struct fsnotify_ops inotify_fsnotify_ops;
+
+extern struct kmem_cache *inotify_inode_mark_cachep;
fs/notify/inotify/inotify_fsnotify.c +11 -0
index 35f2f39514b8..a33aa3173a2d 100644
@@ -177,9 +177,20 @@ static void inotify_free_event(struct fsnotify_event *fsn_event)
 	kfree(INOTIFY_E(fsn_event));
 }
 
+/* ding dong the mark is dead */
+static void inotify_free_mark(struct fsnotify_mark *fsn_mark)
+{
+	struct inotify_inode_mark *i_mark;
+
+	i_mark = container_of(fsn_mark, struct inotify_inode_mark, fsn_mark);
+
+	kmem_cache_free(inotify_inode_mark_cachep, i_mark);
+}
+
 const struct fsnotify_ops inotify_fsnotify_ops = {
 	.handle_event = inotify_handle_event,
 	.free_group_priv = inotify_free_group_priv,
 	.free_event = inotify_free_event,
 	.freeing_mark = inotify_freeing_mark,
+	.free_mark = inotify_free_mark,
 };
fs/notify/inotify/inotify_user.c +2 -12
index 38e66d497b3b..f16d591f0b41 100644
@@ -49,7 +49,7 @@ static int inotify_max_user_instances __read_mostly;
 static int inotify_max_queued_events __read_mostly;
 static int inotify_max_user_watches __read_mostly;
 
-static struct kmem_cache *inotify_inode_mark_cachep __read_mostly;
+struct kmem_cache *inotify_inode_mark_cachep __read_mostly;
 
 #ifdef CONFIG_SYSCTL
 
@@ -486,16 +486,6 @@ void inotify_ignored_and_remove_idr(struct fsnotify_mark *fsn_mark,
 	atomic_dec(&group->inotify_data.user->inotify_watches);
 }
 
-/* ding dong the mark is dead */
-static void inotify_free_mark(struct fsnotify_mark *fsn_mark)
-{
-	struct inotify_inode_mark *i_mark;
-
-	i_mark = container_of(fsn_mark, struct inotify_inode_mark, fsn_mark);
-
-	kmem_cache_free(inotify_inode_mark_cachep, i_mark);
-}
-
 static int inotify_update_existing_watch(struct fsnotify_group *group,
 					 struct inode *inode,
 					 u32 arg)
@@ -561,7 +551,7 @@ static int inotify_new_watch(struct fsnotify_group *group,
 	if (unlikely(!tmp_i_mark))
 		return -ENOMEM;
 
-	fsnotify_init_mark(&tmp_i_mark->fsn_mark, group, inotify_free_mark);
+	fsnotify_init_mark(&tmp_i_mark->fsn_mark, group);
 	tmp_i_mark->fsn_mark.mask = mask;
 	tmp_i_mark->wd = -1;
 
fs/notify/mark.c +7 -6
index 5f8b2c725105..334620e38222 100644
@@ -196,9 +196,12 @@ static struct inode *fsnotify_detach_connector_from_object(
 
 static void fsnotify_final_mark_destroy(struct fsnotify_mark *mark)
 {
-	if (mark->group)
-		fsnotify_put_group(mark->group);
-	mark->free_mark(mark);
+	struct fsnotify_group *group = mark->group;
+
+	if (WARN_ON_ONCE(!group))
+		return;
+	group->ops->free_mark(mark);
+	fsnotify_put_group(group);
 }
 
 void fsnotify_put_mark(struct fsnotify_mark *mark)
@@ -721,13 +724,11 @@ void fsnotify_destroy_marks(struct fsnotify_mark_connector **connp)
  * Nothing fancy, just initialize lists and locks and counters.
  */
 void fsnotify_init_mark(struct fsnotify_mark *mark,
-			struct fsnotify_group *group,
-			void (*free_mark)(struct fsnotify_mark *mark))
+			struct fsnotify_group *group)
 {
 	memset(mark, 0, sizeof(*mark));
 	spin_lock_init(&mark->lock);
 	atomic_set(&mark->refcnt, 1);
-	mark->free_mark = free_mark;
 	fsnotify_get_group(group);
 	mark->group = group;
 }
include/linux/fsnotify_backend.h +3 -3
index f87d447c1457..0239741b0dc8 100644
@@ -102,6 +102,8 @@ struct fsnotify_ops {
 	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);
+	/* called on final put+free to free memory */
+	void (*free_mark)(struct fsnotify_mark *mark);
 };
 
 /*
@@ -259,7 +261,6 @@ struct fsnotify_mark {
 #define FSNOTIFY_MARK_FLAG_ALIVE		0x02
 #define FSNOTIFY_MARK_FLAG_ATTACHED		0x04
 	unsigned int flags;		/* flags [mark->lock] */
-	void (*free_mark)(struct fsnotify_mark *mark); /* called on final put+free */
 };
 
 #ifdef CONFIG_FSNOTIFY
@@ -339,8 +340,7 @@ extern struct fsnotify_event *fsnotify_remove_first_event(struct fsnotify_group
 /* Calculate mask of events for a list of marks */
 extern void fsnotify_recalc_mask(struct fsnotify_mark_connector *conn);
 extern void fsnotify_init_mark(struct fsnotify_mark *mark,
-			       struct fsnotify_group *group,
-			       void (*free_mark)(struct fsnotify_mark *mark));
+			       struct fsnotify_group *group);
 /* Find mark belonging to given group in the list of marks */
 extern struct fsnotify_mark *fsnotify_find_mark(
 					struct fsnotify_mark_connector **connp,
kernel/audit_fsnotify.c +2 -2
index 5bb7e920f126..7c724b59fe7d 100644
@@ -103,8 +103,7 @@ struct audit_fsnotify_mark *audit_alloc_mark(struct audit_krule *krule, char *pa
 		goto out;
 	}
 
-	fsnotify_init_mark(&audit_mark->mark, audit_fsnotify_group,
-			   audit_fsnotify_free_mark);
+	fsnotify_init_mark(&audit_mark->mark, audit_fsnotify_group);
 	audit_mark->mark.mask = AUDIT_FS_EVENTS;
 	audit_mark->path = pathname;
 	audit_update_mark(audit_mark, dentry->d_inode);
@@ -203,6 +202,7 @@ static int audit_mark_handle_event(struct fsnotify_group *group,
 
 static const struct fsnotify_ops audit_mark_fsnotify_ops = {
 	.handle_event =	audit_mark_handle_event,
+	.free_mark = audit_fsnotify_free_mark,
 };
 
 static int __init audit_fsnotify_init(void)
kernel/audit_tree.c +2 -2
index a799cea717de..b625908b835c 100644
@@ -154,8 +154,7 @@ static struct audit_chunk *alloc_chunk(int count)
 		INIT_LIST_HEAD(&chunk->owners[i].list);
 		chunk->owners[i].index = i;
 	}
-	fsnotify_init_mark(&chunk->mark, audit_tree_group,
-			   audit_tree_destroy_watch);
+	fsnotify_init_mark(&chunk->mark, audit_tree_group);
 	chunk->mark.mask = FS_IN_IGNORED;
 	return chunk;
 }
@@ -1003,6 +1002,7 @@ static void audit_tree_freeing_mark(struct fsnotify_mark *entry, struct fsnotify
 static const struct fsnotify_ops audit_tree_ops = {
 	.handle_event = audit_tree_handle_event,
 	.freeing_mark = audit_tree_freeing_mark,
+	.free_mark = audit_tree_destroy_watch,
 };
 
 static int __init audit_tree_init(void)
kernel/audit_watch.c +2 -2
index 0f355086215a..d32b68b10cf7 100644
@@ -157,8 +157,7 @@ static struct audit_parent *audit_init_parent(struct path *path)
 
 	INIT_LIST_HEAD(&parent->watches);
 
-	fsnotify_init_mark(&parent->mark, audit_watch_group,
-			   audit_watch_free_mark);
+	fsnotify_init_mark(&parent->mark, audit_watch_group);
 	parent->mark.mask = AUDIT_FS_WATCH;
 	ret = fsnotify_add_mark(&parent->mark, inode, NULL, 0);
 	if (ret < 0) {
@@ -508,6 +507,7 @@ static int audit_watch_handle_event(struct fsnotify_group *group,
 
 static const struct fsnotify_ops audit_watch_fsnotify_ops = {
 	.handle_event = 	audit_watch_handle_event,
+	.free_mark =		audit_watch_free_mark,
 };
 
 static int __init audit_watch_init(void)
Signature · 1 line
2.10.2
#35 lore raw
In reply to Jan Kara
Quoted 6 lines · Jan Kara

Hello,

This is the second revision of my patches to avoid SRCU stalls when fanotify waits for response to permission events from userspace processes. Thanks to Amir and Paul for review!

Quoted 9 lines

Changes since v1:
* renamed fsnotify_mark_list to fsnotify_mark_connector and couple other things
* updated some comments and changelogs to better explain what is going on
* made audit use inode pointer as a key again
* added Reviewed-by tags
* dropped two audit fixes that got already merged
* added cleanup of mark destruction functions

Went over the entire series again (also quick pass on the Reviewed patches). Looking good.
Some minor nits on patches 6 and 9.

Quoted 36 lines

Patch set overview
------------------

Currently, fanotify waits for response to a permission even from userspace process while holding fsnotify_mark_srcu lock. That has a consequence that when userspace process takes long to respond or does not respond at all, fsnotify_mark_srcu period cannot ever complete blocking reclaim of any notification marks and also blocking any process that did synchronize_srcu() on fsnotify_mark_srcu. Effectively, this eventually blocks anybody interacting with the notification subsystem. Miklos has some real world reports of this happening. Although this in principle a problem of broken userspace application (which futhermore has to have CAP_SYS_ADMIN in init_user_ns, so it is not a security problem), it is still nasty that a simple error can block the kernel like this.

This patch set solves this problem. The basic idea of the solution is that when fanotify needs to wait for response from userspace process, it grabs reference to the mark which generated the event and drops fsnotify_mark_srcu lock. When userspace responds, we grab fsnotify_mark_srcu again, drop the mark reference, and continue iterating the list of marks attached to the inode / vfsmount delivering the event to other notification groups. What complicates this simple approach is that the mark for which we wait for response has to stay pinned in the list of marks attached to the inode / vfsmount so that we can resume iteration of the list when userspace responds but on the other hand when the inode gets unlinked while we wait for userspace reponse, we need to destroy the mark (or at least detach it from the inode).

The first 3 patches contain some initial fixes and cleanups. Patches 4-6 implement attaching of marks to inode / vfsmount via a dedicated structure which allows us to detach list of marks from the object without having to destroy the list itself. Patches 7-9 implement removal of mark from the list of marks attached to an object when last mark reference is dropped. Patches 10-13 then implement dropping of SRCU lock when waiting on response from userspace. Patches 14-22 are mostly trivial cleanups that get rid of trivial wrappers and one pointer in the mark structure.

Quoted 1 line

Patches have survived testing with inotify/fanotify tests in LTP.

Did you already write an LTP test from Miklos' test program that ignited this work? Would you like to take this small task?

My head hurts from thinking about all the corner cases we need to stress test with this work... but I'll try to pick myself up and write a list of test coverage as a starting point.

Quoted 8 lines

I didn't test
audit - Paul can you give these patches some testing? Since some of the changes are really non-trivial, I'd welcome if someone reviewed the patch set. Thanks!

Finally, to ease experimenting with the patches I've pushed them out to
git://git.kernel.org/pub/scm/linux/kernel/git/jack/linux-fs.git for_testing

I was going to ask that from you.
Thanks!

Amir.