Commit 9dd813c1 authored by Jan Kara's avatar Jan Kara
Browse files

fsnotify: Move mark list head from object into dedicated structure 



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 is the first in the series that paves 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. The following commits will also add spinlock protecting the list
and object pointer to the structure.

Reviewed-by: default avatarMiklos Szeredi <mszeredi@redhat.com>
Reviewed-by: default avatarAmir Goldstein <amir73il@gmail.com>
Signed-off-by: default avatarJan Kara <jack@suse.cz>
parent c1f33073

fs/inode.c

+3 −3
Original line number Diff line number Diff line
@@ -234,6 +234,9 @@ void __destroy_inode(struct inode *inode) 
	inode_detach_wb(inode);

	security_inode_free(inode);

	fsnotify_inode_delete(inode);

#ifdef CONFIG_FSNOTIFY

	fsnotify_connector_free(&inode->i_fsnotify_marks);

#endif

	locks_free_lock_context(inode);

	if (!inode->i_nlink) {

		WARN_ON(atomic_long_read(&inode->i_sb->s_remove_count) == 0);
@@ -371,9 +374,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
Original line number Diff line number Diff line
@@ -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 *mnt_fsnotify_marks;

	__u32 mnt_fsnotify_mask;

#endif

	int mnt_id;			/* mount identifier */

fs/namespace.c

+3 −3
Original line number Diff line number Diff line
@@ -236,9 +236,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;
@@ -1111,6 +1108,9 @@ static void cleanup_mnt(struct mount *mnt) 
	if (unlikely(mnt->mnt_pins.first))

		mnt_pin_kill(mnt);

	fsnotify_vfsmount_delete(&mnt->mnt);

#ifdef CONFIG_FSNOTIFY

	fsnotify_connector_free(&mnt->mnt_fsnotify_marks);

#endif

	dput(mnt->mnt.mnt_root);

	deactivate_super(mnt->mnt.mnt_sb);

	mnt_free_id(mnt);

fs/notify/fsnotify.c

+23 −9
Original line number Diff line number Diff line
@@ -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,15 +227,23 @@ 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 = lockless_dereference(to_tell->i_fsnotify_marks);

		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,

		inode_conn = lockless_dereference(to_tell->i_fsnotify_marks);

		if (inode_conn)

			inode_node = srcu_dereference(inode_conn->list.first,

						      &fsnotify_mark_srcu);

		inode_node = srcu_dereference(to_tell->i_fsnotify_marks.first,

		vfsmount_conn = lockless_dereference(mnt->mnt_fsnotify_marks);

		if (vfsmount_conn)

			vfsmount_node = srcu_dereference(

						vfsmount_conn->list.first,

						&fsnotify_mark_srcu);

	}
@@ -293,6 +302,8 @@ out: 
}

EXPORT_SYMBOL_GPL(fsnotify);



extern struct kmem_cache *fsnotify_mark_connector_cachep;



static __init int fsnotify_init(void)

{

	int ret;
@@ -303,6 +314,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

+9 −7
Original line number Diff line number Diff line
@@ -15,7 +15,7 @@ extern void fsnotify_flush_notify(struct fsnotify_group *group); 
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);

extern u32 fsnotify_recalc_mask(struct fsnotify_mark_connector *conn);



/* compare two groups for sorting of marks lists */

extern int fsnotify_compare_groups(struct fsnotify_group *a,
@@ -24,7 +24,7 @@ extern int fsnotify_compare_groups(struct fsnotify_group *a, 
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,

extern int fsnotify_add_mark_list(struct fsnotify_mark_connector **connp,

				  struct fsnotify_mark *mark,

				  int allow_dups);

/* add a mark to an inode */
@@ -41,19 +41,21 @@ 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,

extern struct fsnotify_mark *fsnotify_find_mark(

					struct fsnotify_mark_connector *conn,

					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);

extern void fsnotify_destroy_marks(struct fsnotify_mark_connector *conn,

				   spinlock_t *lock);

/* 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, &inode->i_lock);

}

/* 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,

	fsnotify_destroy_marks(real_mount(mnt)->mnt_fsnotify_marks,

			       &mnt->mnt_root->d_lock);

}

/* prepare for freeing all marks associated with given group */

CRA Git | Maintained and supported by SUSTech CRA and CCSE