Commit 7b129323 authored by Jan Kara's avatar Jan Kara
Browse files

fsnotify: Add group pointer in fsnotify_init_mark() 



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().

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 ebb3b47e

fs/notify/dnotify/dnotify.c

+2 −3
Original line number Diff line number Diff line
@@ -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
Original line number Diff line number Diff line
@@ -628,8 +628,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
Original line number Diff line number Diff line
@@ -558,7 +558,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, 
	}



	/* 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
Original line number Diff line number Diff line
@@ -563,10 +563,10 @@ out_err: 
 * 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);
@@ -582,8 +582,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 */
@@ -608,12 +606,14 @@ err: 
	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;

}
@@ -732,12 +732,15 @@ void fsnotify_destroy_marks(struct fsnotify_mark_connector __rcu **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
Original line number Diff line number Diff line
@@ -340,15 +340,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 __rcu **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,

CRA Git | Maintained and supported by SUSTech CRA and CCSE