Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit c28f7e56 authored by Eric Paris's avatar Eric Paris
Browse files

fsnotify: parent event notification 



inotify and dnotify both use a similar parent notification mechanism.  We
add a generic parent notification mechanism to fsnotify for both of these
to use.  This new machanism also adds the dentry flag optimization which
exists for inotify to dnotify.

Signed-off-by: default avatarEric Paris <eparis@redhat.com>
Acked-by: default avatarAl Viro <viro@zeniv.linux.org.uk>
Cc: Christoph Hellwig <hch@lst.de>
parent 3be25f49

fs/notify/fsnotify.c

+91 −0
Original line number Diff line number Diff line
@@ -34,6 +34,97 @@ void __fsnotify_inode_delete(struct inode *inode) 
}

EXPORT_SYMBOL_GPL(__fsnotify_inode_delete);



/*

 * Given an inode, first check if we care what happens to our children.  Inotify

 * and dnotify both tell their parents about events.  If we care about any event

 * on a child we run all of our children and set a dentry flag saying that the

 * parent cares.  Thus when an event happens on a child it can quickly tell if

 * if there is a need to find a parent and send the event to the parent.

 */

void __fsnotify_update_child_dentry_flags(struct inode *inode)

{

	struct dentry *alias;

	int watched;



	if (!S_ISDIR(inode->i_mode))

		return;



	/* determine if the children should tell inode about their events */

	watched = fsnotify_inode_watches_children(inode);



	spin_lock(&dcache_lock);

	/* run all of the dentries associated with this inode.  Since this is a

	 * directory, there damn well better only be one item on this list */

	list_for_each_entry(alias, &inode->i_dentry, d_alias) {

		struct dentry *child;



		/* run all of the children of the original inode and fix their

		 * d_flags to indicate parental interest (their parent is the

		 * original inode) */

		list_for_each_entry(child, &alias->d_subdirs, d_u.d_child) {

			if (!child->d_inode)

				continue;



			spin_lock(&child->d_lock);

			if (watched)

				child->d_flags |= DCACHE_FSNOTIFY_PARENT_WATCHED;

			else

				child->d_flags &= ~DCACHE_FSNOTIFY_PARENT_WATCHED;

			spin_unlock(&child->d_lock);

		}

	}

	spin_unlock(&dcache_lock);

}



/* Notify this dentry's parent about a child's events. */

void __fsnotify_parent(struct dentry *dentry, __u32 mask)

{

	struct dentry *parent;

	struct inode *p_inode;

	bool send = false;

	bool should_update_children = false;



	if (!(dentry->d_flags & DCACHE_FSNOTIFY_PARENT_WATCHED))

		return;



	spin_lock(&dentry->d_lock);

	parent = dentry->d_parent;

	p_inode = parent->d_inode;



	if (fsnotify_inode_watches_children(p_inode)) {

		if (p_inode->i_fsnotify_mask & mask) {

			dget(parent);

			send = true;

		}

	} else {

		/*

		 * The parent doesn't care about events on it's children but

		 * at least one child thought it did.  We need to run all the

		 * children and update their d_flags to let them know p_inode

		 * doesn't care about them any more.

		 */

		dget(parent);

		should_update_children = true;

	}



	spin_unlock(&dentry->d_lock);



	if (send) {

		/* we are notifying a parent so come up with the new mask which

		 * specifies these are events which came from a child. */

		mask |= FS_EVENT_ON_CHILD;



		fsnotify(p_inode, mask, dentry->d_inode, FSNOTIFY_EVENT_INODE);

		dput(parent);

	}



	if (unlikely(should_update_children)) {

		__fsnotify_update_child_dentry_flags(p_inode);

		dput(parent);

	}

}

EXPORT_SYMBOL_GPL(__fsnotify_parent);



/*

 * This is the main call to fsnotify.  The VFS calls into hook specific functions

 * in linux/fsnotify.h.  Those functions then in turn call here.  Here will call

fs/notify/fsnotify.h

+5 −0
Original line number Diff line number Diff line
@@ -17,4 +17,9 @@ extern __u32 fsnotify_mask; 
extern void fsnotify_final_destroy_group(struct fsnotify_group *group);

/* run the list of all marks associated with inode and flag them to be freed */

extern void fsnotify_clear_marks_by_inode(struct inode *inode);

/*

 * update the dentry->d_flags of all of inode's children to indicate if inode cares

 * about events that happen to its children.

 */

extern void __fsnotify_update_child_dentry_flags(struct inode *inode);

#endif	/* __FS_NOTIFY_FSNOTIFY_H_ */

fs/notify/inode_mark.c

+17 −0
Original line number Diff line number Diff line
@@ -131,6 +131,8 @@ void fsnotify_recalc_inode_mask(struct inode *inode) 
	spin_lock(&inode->i_lock);

	fsnotify_recalc_inode_mask_locked(inode);

	spin_unlock(&inode->i_lock);



	__fsnotify_update_child_dentry_flags(inode);

}



/*
@@ -189,6 +191,19 @@ void fsnotify_destroy_mark_by_entry(struct fsnotify_mark_entry *entry) 
	 */

	group->ops->freeing_mark(entry, group);



	/*

	 * __fsnotify_update_child_dentry_flags(inode);

	 *

	 * I really want to call that, but we can't, we have no idea if the inode

	 * still exists the second we drop the entry->lock.

	 *

	 * The next time an event arrive to this inode from one of it's children

	 * __fsnotify_parent will see that the inode doesn't care about it's

	 * children and will update all of these flags then.  So really this

	 * is just a lazy update (and could be a perf win...)

	 */





	/*

	 * it's possible that this group tried to destroy itself, but this

	 * this mark was simultaneously being freed by inode.  If that's the
@@ -323,6 +338,8 @@ int fsnotify_add_mark(struct fsnotify_mark_entry *entry, 
	if (lentry) {

		ret = -EEXIST;

		fsnotify_put_mark(lentry);

	} else {

		__fsnotify_update_child_dentry_flags(inode);

	}



	return ret;

include/linux/dcache.h

+3 −1
Original line number Diff line number Diff line
@@ -180,10 +180,12 @@ d_iput: no no no yes 
#define DCACHE_REFERENCED	0x0008  /* Recently used, don't discard. */

#define DCACHE_UNHASHED		0x0010	



#define DCACHE_INOTIFY_PARENT_WATCHED	0x0020 /* Parent inode is watched */

#define DCACHE_INOTIFY_PARENT_WATCHED	0x0020 /* Parent inode is watched by inotify */



#define DCACHE_COOKIE		0x0040	/* For use by dcookie subsystem */



#define DCACHE_FSNOTIFY_PARENT_WATCHED	0x0080 /* Parent inode is watched by some fsnotify listener */



extern spinlock_t dcache_lock;

extern seqlock_t rename_lock;

include/linux/fsnotify.h

+25 −9
Original line number Diff line number Diff line
@@ -23,15 +23,31 @@ 
static inline void fsnotify_d_instantiate(struct dentry *entry,

						struct inode *inode)

{

	__fsnotify_d_instantiate(entry, inode);



	inotify_d_instantiate(entry, inode);

}



/* Notify this dentry's parent about a child's events. */

static inline void fsnotify_parent(struct dentry *dentry, __u32 mask)

{

	__fsnotify_parent(dentry, mask);



	inotify_dentry_parent_queue_event(dentry, mask, 0, dentry->d_name.name);

}



/*

 * fsnotify_d_move - entry has been moved

 * Called with dcache_lock and entry->d_lock held.

 */

static inline void fsnotify_d_move(struct dentry *entry)

{

	/*

	 * On move we need to update entry->d_flags to indicate if the new parent

	 * cares about events from this entry.

	 */

	__fsnotify_update_dcache_flags(entry);



	inotify_d_move(entry);

}
@@ -117,7 +133,8 @@ static inline void fsnotify_nameremove(struct dentry *dentry, int isdir) 
	if (isdir)

		mask |= FS_IN_ISDIR;

	dnotify_parent(dentry, DN_DELETE);

	inotify_dentry_parent_queue_event(dentry, mask, 0, dentry->d_name.name);



	fsnotify_parent(dentry, mask);

}



/*
@@ -188,9 +205,9 @@ static inline void fsnotify_access(struct dentry *dentry) 
		mask |= FS_IN_ISDIR;



	dnotify_parent(dentry, DN_ACCESS);

	inotify_dentry_parent_queue_event(dentry, mask, 0, dentry->d_name.name);

	inotify_inode_queue_event(inode, mask, 0, NULL, NULL);



	fsnotify_parent(dentry, mask);

	fsnotify(inode, mask, inode, FSNOTIFY_EVENT_INODE);

}
@@ -206,9 +223,9 @@ static inline void fsnotify_modify(struct dentry *dentry) 
		mask |= FS_IN_ISDIR;



	dnotify_parent(dentry, DN_MODIFY);

	inotify_dentry_parent_queue_event(dentry, mask, 0, dentry->d_name.name);

	inotify_inode_queue_event(inode, mask, 0, NULL, NULL);



	fsnotify_parent(dentry, mask);

	fsnotify(inode, mask, inode, FSNOTIFY_EVENT_INODE);

}
@@ -223,9 +240,9 @@ static inline void fsnotify_open(struct dentry *dentry) 
	if (S_ISDIR(inode->i_mode))

		mask |= FS_IN_ISDIR;



	inotify_dentry_parent_queue_event(dentry, mask, 0, dentry->d_name.name);

	inotify_inode_queue_event(inode, mask, 0, NULL, NULL);



	fsnotify_parent(dentry, mask);

	fsnotify(inode, mask, inode, FSNOTIFY_EVENT_INODE);

}
@@ -236,16 +253,15 @@ static inline void fsnotify_close(struct file *file) 
{

	struct dentry *dentry = file->f_path.dentry;

	struct inode *inode = dentry->d_inode;

	const char *name = dentry->d_name.name;

	fmode_t mode = file->f_mode;

	__u32 mask = (mode & FMODE_WRITE) ? FS_CLOSE_WRITE : FS_CLOSE_NOWRITE;



	if (S_ISDIR(inode->i_mode))

		mask |= FS_IN_ISDIR;



	inotify_dentry_parent_queue_event(dentry, mask, 0, name);

	inotify_inode_queue_event(inode, mask, 0, NULL, NULL);



	fsnotify_parent(dentry, mask);

	fsnotify(inode, mask, file, FSNOTIFY_EVENT_FILE);

}
@@ -260,9 +276,9 @@ static inline void fsnotify_xattr(struct dentry *dentry) 
	if (S_ISDIR(inode->i_mode))

		mask |= FS_IN_ISDIR;



	inotify_dentry_parent_queue_event(dentry, mask, 0, dentry->d_name.name);

	inotify_inode_queue_event(inode, mask, 0, NULL, NULL);



	fsnotify_parent(dentry, mask);

	fsnotify(inode, mask, inode, FSNOTIFY_EVENT_INODE);

}
@@ -311,8 +327,8 @@ static inline void fsnotify_change(struct dentry *dentry, unsigned int ia_valid) 
		if (S_ISDIR(inode->i_mode))

			in_mask |= FS_IN_ISDIR;

		inotify_inode_queue_event(inode, in_mask, 0, NULL, NULL);

		inotify_dentry_parent_queue_event(dentry, in_mask, 0,

						  dentry->d_name.name);



		fsnotify_parent(dentry, in_mask);

		fsnotify(inode, in_mask, inode, FSNOTIFY_EVENT_INODE);

	}

}