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

fsnotify: rename fsnotify_mark_entry to just fsnotify_mark 



The name is long and it serves no real purpose.  So rename
fsnotify_mark_entry to just fsnotify_mark.

Signed-off-by: default avatarEric Paris <eparis@redhat.com>
parent 72acc854

fs/inode.c

+1 −1
Original line number Diff line number Diff line
@@ -264,7 +264,7 @@ void inode_init_once(struct inode *inode) 
	INIT_LIST_HEAD(&inode->i_data.i_mmap_nonlinear);

	i_size_ordered_init(inode);

#ifdef CONFIG_FSNOTIFY

	INIT_HLIST_HEAD(&inode->i_fsnotify_mark_entries);

	INIT_HLIST_HEAD(&inode->i_fsnotify_marks);

#endif

}

EXPORT_SYMBOL(inode_init_once);

fs/notify/dnotify/dnotify.c

+12 −12
Original line number Diff line number Diff line
@@ -34,12 +34,12 @@ static struct fsnotify_group *dnotify_group __read_mostly; 
static DEFINE_MUTEX(dnotify_mark_mutex);



/*

 * dnotify will attach one of these to each inode (i_fsnotify_mark_entries) which

 * dnotify will attach one of these to each inode (i_fsnotify_marks) which

 * is being watched by dnotify.  If multiple userspace applications are watching

 * the same directory with dnotify their information is chained in dn

 */

struct dnotify_mark_entry {

	struct fsnotify_mark_entry fsn_entry;

	struct fsnotify_mark fsn_entry;

	struct dnotify_struct *dn;

};
@@ -51,7 +51,7 @@ struct dnotify_mark_entry { 
 * it calls the fsnotify function so it can update the set of all events relevant

 * to this inode.

 */

static void dnotify_recalc_inode_mask(struct fsnotify_mark_entry *entry)

static void dnotify_recalc_inode_mask(struct fsnotify_mark *entry)

{

	__u32 new_mask, old_mask;

	struct dnotify_struct *dn;
@@ -85,7 +85,7 @@ static void dnotify_recalc_inode_mask(struct fsnotify_mark_entry *entry) 
static int dnotify_handle_event(struct fsnotify_group *group,

				struct fsnotify_event *event)

{

	struct fsnotify_mark_entry *entry = NULL;

	struct fsnotify_mark *entry = NULL;

	struct dnotify_mark_entry *dnentry;

	struct inode *to_tell;

	struct dnotify_struct *dn;
@@ -136,7 +136,7 @@ static bool dnotify_should_send_event(struct fsnotify_group *group, 
				      struct inode *inode, struct vfsmount *mnt,

				      __u32 mask, void *data, int data_type)

{

	struct fsnotify_mark_entry *entry;

	struct fsnotify_mark *entry;

	bool send;



	/* !dir_notify_enable should never get here, don't waste time checking
@@ -163,7 +163,7 @@ static bool dnotify_should_send_event(struct fsnotify_group *group, 
	return send;

}



static void dnotify_free_mark(struct fsnotify_mark_entry *entry)

static void dnotify_free_mark(struct fsnotify_mark *entry)

{

	struct dnotify_mark_entry *dnentry = container_of(entry,

							  struct dnotify_mark_entry,
@@ -184,14 +184,14 @@ static struct fsnotify_ops dnotify_fsnotify_ops = { 


/*

 * Called every time a file is closed.  Looks first for a dnotify mark on the

 * inode.  If one is found run all of the ->dn entries attached to that

 * inode.  If one is found run all of the ->dn structures attached to that

 * mark for one relevant to this process closing the file and remove that

 * dnotify_struct.  If that was the last dnotify_struct also remove the

 * fsnotify_mark_entry.

 * fsnotify_mark.

 */

void dnotify_flush(struct file *filp, fl_owner_t id)

{

	struct fsnotify_mark_entry *entry;

	struct fsnotify_mark *entry;

	struct dnotify_mark_entry *dnentry;

	struct dnotify_struct *dn;

	struct dnotify_struct **prev;
@@ -260,7 +260,7 @@ static __u32 convert_arg(unsigned long arg) 


/*

 * If multiple processes watch the same inode with dnotify there is only one

 * dnotify mark in inode->i_fsnotify_mark_entries but we chain a dnotify_struct

 * dnotify mark in inode->i_fsnotify_marks but we chain a dnotify_struct

 * onto that mark.  This function either attaches the new dnotify_struct onto

 * that list, or it |= the mask onto an existing dnofiy_struct.

 */
@@ -298,7 +298,7 @@ static int attach_dn(struct dnotify_struct *dn, struct dnotify_mark_entry *dnent 
int fcntl_dirnotify(int fd, struct file *filp, unsigned long arg)

{

	struct dnotify_mark_entry *new_dnentry, *dnentry;

	struct fsnotify_mark_entry *new_entry, *entry;

	struct fsnotify_mark *new_entry, *entry;

	struct dnotify_struct *dn;

	struct inode *inode;

	fl_owner_t id = current->files;
@@ -378,7 +378,7 @@ int fcntl_dirnotify(int fd, struct file *filp, unsigned long arg) 
	/* if (f != filp) means that we lost a race and another task/thread

	 * actually closed the fd we are still playing with before we grabbed

	 * the dnotify_mark_mutex and entry->lock.  Since closing the fd is the

	 * only time we clean up the mark entries we need to get our mark off

	 * only time we clean up the marks we need to get our mark off

	 * the list. */

	if (f != filp) {

		/* if we added ourselves, shoot ourselves, it's possible that

fs/notify/group.c

+4 −4
Original line number Diff line number Diff line
@@ -74,10 +74,10 @@ void fsnotify_recalc_group_mask(struct fsnotify_group *group) 
{

	__u32 mask = 0;

	__u32 old_mask = group->mask;

	struct fsnotify_mark_entry *entry;

	struct fsnotify_mark *entry;



	spin_lock(&group->mark_lock);

	list_for_each_entry(entry, &group->mark_entries, g_list)

	list_for_each_entry(entry, &group->marks_list, g_list)

		mask |= entry->mask;

	spin_unlock(&group->mark_lock);
@@ -133,7 +133,7 @@ void fsnotify_final_destroy_group(struct fsnotify_group *group) 
 */

static void fsnotify_destroy_group(struct fsnotify_group *group)

{

	/* clear all inode mark entries for this group */

	/* clear all inode marks for this group */

	fsnotify_clear_marks_by_group(group);



	/* past the point of no return, matches the initial value of 1 */
@@ -224,7 +224,7 @@ struct fsnotify_group *fsnotify_alloc_group(const struct fsnotify_ops *ops) 
	INIT_LIST_HEAD(&group->vfsmount_group_list);



	spin_lock_init(&group->mark_lock);

	INIT_LIST_HEAD(&group->mark_entries);

	INIT_LIST_HEAD(&group->marks_list);



	group->ops = ops;

fs/notify/inode_mark.c

+24 −24
Original line number Diff line number Diff line
@@ -38,12 +38,12 @@ 
 * that lock to dereference either of these things (they could be NULL even with

 * the lock)

 *

 * group->mark_lock protects the mark_entries list anchored inside a given group

 * group->mark_lock protects the marks_list anchored inside a given group

 * and each entry is hooked via the g_list.  It also sorta protects the

 * free_g_list, which when used is anchored by a private list on the stack of the

 * task which held the group->mark_lock.

 *

 * inode->i_lock protects the i_fsnotify_mark_entries list anchored inside a

 * inode->i_lock protects the i_fsnotify_marks list anchored inside a

 * given inode and each entry is hooked via the i_list. (and sorta the

 * free_i_list)

 *
@@ -61,7 +61,7 @@ 
 *   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_mark_entries safely.  For each

 * 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;  At this point we no
@@ -95,12 +95,12 @@ 
#include <linux/fsnotify_backend.h>

#include "fsnotify.h"



void fsnotify_get_mark(struct fsnotify_mark_entry *entry)

void fsnotify_get_mark(struct fsnotify_mark *entry)

{

	atomic_inc(&entry->refcnt);

}



void fsnotify_put_mark(struct fsnotify_mark_entry *entry)

void fsnotify_put_mark(struct fsnotify_mark *entry)

{

	if (atomic_dec_and_test(&entry->refcnt))

		entry->free_mark(entry);
@@ -111,13 +111,13 @@ void fsnotify_put_mark(struct fsnotify_mark_entry *entry) 
 */

static void fsnotify_recalc_inode_mask_locked(struct inode *inode)

{

	struct fsnotify_mark_entry *entry;

	struct fsnotify_mark *entry;

	struct hlist_node *pos;

	__u32 new_mask = 0;



	assert_spin_locked(&inode->i_lock);



	hlist_for_each_entry(entry, pos, &inode->i_fsnotify_mark_entries, i.i_list)

	hlist_for_each_entry(entry, pos, &inode->i_fsnotify_marks, i.i_list)

		new_mask |= entry->mask;

	inode->i_fsnotify_mask = new_mask;

}
@@ -140,7 +140,7 @@ void fsnotify_recalc_inode_mask(struct inode *inode) 
 * The caller had better be holding a reference to this mark so we don't actually

 * do the final put under the entry->lock

 */

void fsnotify_destroy_mark_by_entry(struct fsnotify_mark_entry *entry)

void fsnotify_destroy_mark_by_entry(struct fsnotify_mark *entry)

{

	struct fsnotify_group *group;

	struct inode *inode;
@@ -174,7 +174,7 @@ void fsnotify_destroy_mark_by_entry(struct fsnotify_mark_entry *entry) 
	fsnotify_put_mark(entry); /* for i_list and g_list */



	/*

	 * this mark is now off the inode->i_fsnotify_mark_entries list and we

	 * 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

	 */
@@ -221,11 +221,11 @@ void fsnotify_destroy_mark_by_entry(struct fsnotify_mark_entry *entry) 
 */

void fsnotify_clear_marks_by_group(struct fsnotify_group *group)

{

	struct fsnotify_mark_entry *lentry, *entry;

	struct fsnotify_mark *lentry, *entry;

	LIST_HEAD(free_list);



	spin_lock(&group->mark_lock);

	list_for_each_entry_safe(entry, lentry, &group->mark_entries, g_list) {

	list_for_each_entry_safe(entry, lentry, &group->marks_list, g_list) {

		list_add(&entry->free_g_list, &free_list);

		list_del_init(&entry->g_list);

		fsnotify_get_mark(entry);
@@ -243,12 +243,12 @@ void fsnotify_clear_marks_by_group(struct fsnotify_group *group) 
 */

void fsnotify_clear_marks_by_inode(struct inode *inode)

{

	struct fsnotify_mark_entry *entry, *lentry;

	struct fsnotify_mark *entry, *lentry;

	struct hlist_node *pos, *n;

	LIST_HEAD(free_list);



	spin_lock(&inode->i_lock);

	hlist_for_each_entry_safe(entry, pos, n, &inode->i_fsnotify_mark_entries, i.i_list) {

	hlist_for_each_entry_safe(entry, pos, n, &inode->i_fsnotify_marks, i.i_list) {

		list_add(&entry->i.free_i_list, &free_list);

		hlist_del_init(&entry->i.i_list);

		fsnotify_get_mark(entry);
@@ -265,15 +265,15 @@ void fsnotify_clear_marks_by_inode(struct inode *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

 */

struct fsnotify_mark_entry *fsnotify_find_mark_entry(struct fsnotify_group *group,

struct fsnotify_mark *fsnotify_find_mark_entry(struct fsnotify_group *group,

					       struct inode *inode)

{

	struct fsnotify_mark_entry *entry;

	struct fsnotify_mark *entry;

	struct hlist_node *pos;



	assert_spin_locked(&inode->i_lock);



	hlist_for_each_entry(entry, pos, &inode->i_fsnotify_mark_entries, i.i_list) {

	hlist_for_each_entry(entry, pos, &inode->i_fsnotify_marks, i.i_list) {

		if (entry->group == group) {

			fsnotify_get_mark(entry);

			return entry;
@@ -282,7 +282,7 @@ struct fsnotify_mark_entry *fsnotify_find_mark_entry(struct fsnotify_group *grou 
	return NULL;

}



void fsnotify_duplicate_mark(struct fsnotify_mark_entry *new, struct fsnotify_mark_entry *old)

void fsnotify_duplicate_mark(struct fsnotify_mark *new, struct fsnotify_mark *old)

{

	assert_spin_locked(&old->lock);

	new->i.inode = old->i.inode;
@@ -294,8 +294,8 @@ void fsnotify_duplicate_mark(struct fsnotify_mark_entry *new, struct fsnotify_ma 
/*

 * Nothing fancy, just initialize lists and locks and counters.

 */

void fsnotify_init_mark(struct fsnotify_mark_entry *entry,

			void (*free_mark)(struct fsnotify_mark_entry *entry))

void fsnotify_init_mark(struct fsnotify_mark *entry,

			void (*free_mark)(struct fsnotify_mark *entry))

{

	spin_lock_init(&entry->lock);

	atomic_set(&entry->refcnt, 1);
@@ -311,11 +311,11 @@ void fsnotify_init_mark(struct fsnotify_mark_entry *entry, 
 * These marks may be used for the fsnotify backend to determine which

 * event types should be delivered to which group and for which inodes.

 */

int fsnotify_add_mark(struct fsnotify_mark_entry *entry,

int fsnotify_add_mark(struct fsnotify_mark *entry,

		      struct fsnotify_group *group, struct inode *inode,

		      int allow_dups)

{

	struct fsnotify_mark_entry *lentry = NULL;

	struct fsnotify_mark *lentry = NULL;

	int ret = 0;



	inode = igrab(inode);
@@ -354,8 +354,8 @@ int fsnotify_add_mark(struct fsnotify_mark_entry *entry, 
		entry->group = group;

		entry->i.inode = inode;



		hlist_add_head(&entry->i.i_list, &inode->i_fsnotify_mark_entries);

		list_add(&entry->g_list, &group->mark_entries);

		hlist_add_head(&entry->i.i_list, &inode->i_fsnotify_marks);

		list_add(&entry->g_list, &group->marks_list);



		fsnotify_get_mark(entry); /* for i_list and g_list */

fs/notify/inotify/inotify.h

+3 −3
Original line number Diff line number Diff line
@@ -10,12 +10,12 @@ struct inotify_event_private_data { 
};



struct inotify_inode_mark_entry {

	/* fsnotify_mark_entry MUST be the first thing */

	struct fsnotify_mark_entry fsn_entry;

	/* fsnotify_mark MUST be the first thing */

	struct fsnotify_mark fsn_entry;

	int wd;

};



extern void inotify_ignored_and_remove_idr(struct fsnotify_mark_entry *entry,

extern void inotify_ignored_and_remove_idr(struct fsnotify_mark *entry,

					   struct fsnotify_group *group);

extern void inotify_free_event_priv(struct fsnotify_event_private_data *event_priv);