fsnotify: rename fsnotify_mark_entry to just fsnotify_mark (e61ce867) · Commits · e / devices / android_kernel_xiaomi_markw

fs/inode.c

+1 −1

Original line number	Original line	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);		INIT_LIST_HEAD(&inode->i_data.i_mmap_nonlinear);
	i_size_ordered_init(inode);		i_size_ordered_init(inode);
	#ifdef CONFIG_FSNOTIFY		#ifdef CONFIG_FSNOTIFY
	INIT_HLIST_HEAD(&inode->i_fsnotify_mark_entries);		INIT_HLIST_HEAD(&inode->i_fsnotify_marks);
	#endif		#endif
	}		}
	EXPORT_SYMBOL(inode_init_once);		EXPORT_SYMBOL(inode_init_once);

fs/notify/dnotify/dnotify.c

+12 −12

Original line number	Original line	Diff line number	Diff line
	@@ -34,12 +34,12 @@ static struct fsnotify_group *dnotify_group __read_mostly;
	static DEFINE_MUTEX(dnotify_mark_mutex);		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		* is being watched by dnotify. If multiple userspace applications are watching
	* the same directory with dnotify their information is chained in dn		* the same directory with dnotify their information is chained in dn
	*/		*/
	struct dnotify_mark_entry {		struct dnotify_mark_entry {
	struct fsnotify_mark_entry fsn_entry;		struct fsnotify_mark fsn_entry;
	struct dnotify_struct *dn;		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		* it calls the fsnotify function so it can update the set of all events relevant
	* to this inode.		* 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;		__u32 new_mask, old_mask;
	struct dnotify_struct *dn;		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,		static int dnotify_handle_event(struct fsnotify_group *group,
	struct fsnotify_event *event)		struct fsnotify_event *event)
	{		{
	struct fsnotify_mark_entry *entry = NULL;		struct fsnotify_mark *entry = NULL;
	struct dnotify_mark_entry *dnentry;		struct dnotify_mark_entry *dnentry;
	struct inode *to_tell;		struct inode *to_tell;
	struct dnotify_struct *dn;		struct dnotify_struct *dn;
	@@ -136,7 +136,7 @@ static bool dnotify_should_send_event(struct fsnotify_group *group,
	struct inode inode, struct vfsmount mnt,		struct inode inode, struct vfsmount mnt,
	__u32 mask, void *data, int data_type)		__u32 mask, void *data, int data_type)
	{		{
	struct fsnotify_mark_entry *entry;		struct fsnotify_mark *entry;
	bool send;		bool send;

	/* !dir_notify_enable should never get here, don't waste time checking		/* !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;		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 *dnentry = container_of(entry,
	struct dnotify_mark_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		* 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		* 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		* 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)		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_mark_entry *dnentry;
	struct dnotify_struct *dn;		struct dnotify_struct *dn;
	struct dnotify_struct **prev;		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		* 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		* onto that mark. This function either attaches the new dnotify_struct onto
	* that list, or it \|= the mask onto an existing dnofiy_struct.		* 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)		int fcntl_dirnotify(int fd, struct file *filp, unsigned long arg)
	{		{
	struct dnotify_mark_entry new_dnentry, dnentry;		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 dnotify_struct *dn;
	struct inode *inode;		struct inode *inode;
	fl_owner_t id = current->files;		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		/* 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		* 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		* 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. */		* the list. */
	if (f != filp) {		if (f != filp) {
	/* if we added ourselves, shoot ourselves, it's possible that		/* if we added ourselves, shoot ourselves, it's possible that

fs/notify/group.c

+4 −4

Original line number	Original line	Diff line number	Diff line
	@@ -74,10 +74,10 @@ void fsnotify_recalc_group_mask(struct fsnotify_group *group)
	{		{
	__u32 mask = 0;		__u32 mask = 0;
	__u32 old_mask = group->mask;		__u32 old_mask = group->mask;
	struct fsnotify_mark_entry *entry;		struct fsnotify_mark *entry;

	spin_lock(&group->mark_lock);		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;		mask \|= entry->mask;
	spin_unlock(&group->mark_lock);		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)		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);		fsnotify_clear_marks_by_group(group);

	/* past the point of no return, matches the initial value of 1 */		/* 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);		INIT_LIST_HEAD(&group->vfsmount_group_list);

	spin_lock_init(&group->mark_lock);		spin_lock_init(&group->mark_lock);
	INIT_LIST_HEAD(&group->mark_entries);		INIT_LIST_HEAD(&group->marks_list);

	group->ops = ops;		group->ops = ops;

fs/notify/inode_mark.c

+24 −24

Original line number	Original line	Diff line number	Diff line
	@@ -38,12 +38,12 @@
	* that lock to dereference either of these things (they could be NULL even with		* that lock to dereference either of these things (they could be NULL even with
	* the lock)		* 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		* 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		* free_g_list, which when used is anchored by a private list on the stack of the
	* task which held the group->mark_lock.		* 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		* given inode and each entry is hooked via the i_list. (and sorta the
	* free_i_list)		* free_i_list)
	*		*
	@@ -61,7 +61,7 @@
	* need to be cleaned up. (fsnotify_clear_marks_by_group)		* 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		* 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).		* 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		* 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		* 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 <linux/fsnotify_backend.h>
	#include "fsnotify.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);		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))		if (atomic_dec_and_test(&entry->refcnt))
	entry->free_mark(entry);		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)		static void fsnotify_recalc_inode_mask_locked(struct inode *inode)
	{		{
	struct fsnotify_mark_entry *entry;		struct fsnotify_mark *entry;
	struct hlist_node *pos;		struct hlist_node *pos;
	__u32 new_mask = 0;		__u32 new_mask = 0;

	assert_spin_locked(&inode->i_lock);		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;		new_mask \|= entry->mask;
	inode->i_fsnotify_mask = new_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		* The caller had better be holding a reference to this mark so we don't actually
	* do the final put under the entry->lock		* 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 fsnotify_group *group;
	struct inode *inode;		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 */		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		* hold the inode->i_lock, so this is the perfect time to update the
	* inode->i_fsnotify_mask		* 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)		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);		LIST_HEAD(free_list);

	spin_lock(&group->mark_lock);		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_add(&entry->free_g_list, &free_list);
	list_del_init(&entry->g_list);		list_del_init(&entry->g_list);
	fsnotify_get_mark(entry);		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)		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;		struct hlist_node pos, n;
	LIST_HEAD(free_list);		LIST_HEAD(free_list);

	spin_lock(&inode->i_lock);		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);		list_add(&entry->i.free_i_list, &free_list);
	hlist_del_init(&entry->i.i_list);		hlist_del_init(&entry->i.i_list);
	fsnotify_get_mark(entry);		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.		* 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		* 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 inode *inode)
	{		{
	struct fsnotify_mark_entry *entry;		struct fsnotify_mark *entry;
	struct hlist_node *pos;		struct hlist_node *pos;

	assert_spin_locked(&inode->i_lock);		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) {		if (entry->group == group) {
	fsnotify_get_mark(entry);		fsnotify_get_mark(entry);
	return entry;		return entry;
	@@ -282,7 +282,7 @@ struct fsnotify_mark_entry fsnotify_find_mark_entry(struct fsnotify_group grou
	return NULL;		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);		assert_spin_locked(&old->lock);
	new->i.inode = old->i.inode;		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.		* Nothing fancy, just initialize lists and locks and counters.
	*/		*/
	void fsnotify_init_mark(struct fsnotify_mark_entry *entry,		void fsnotify_init_mark(struct fsnotify_mark *entry,
	void (free_mark)(struct fsnotify_mark_entry entry))		void (free_mark)(struct fsnotify_mark entry))
	{		{
	spin_lock_init(&entry->lock);		spin_lock_init(&entry->lock);
	atomic_set(&entry->refcnt, 1);		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		* These marks may be used for the fsnotify backend to determine which
	* event types should be delivered to which group and for which inodes.		* 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,		struct fsnotify_group group, struct inode inode,
	int allow_dups)		int allow_dups)
	{		{
	struct fsnotify_mark_entry *lentry = NULL;		struct fsnotify_mark *lentry = NULL;
	int ret = 0;		int ret = 0;

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

	hlist_add_head(&entry->i.i_list, &inode->i_fsnotify_mark_entries);		hlist_add_head(&entry->i.i_list, &inode->i_fsnotify_marks);
	list_add(&entry->g_list, &group->mark_entries);		list_add(&entry->g_list, &group->marks_list);

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

fs/notify/inotify/inotify.h

+3 −3

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

	struct inotify_inode_mark_entry {		struct inotify_inode_mark_entry {
	/* fsnotify_mark_entry MUST be the first thing */		/* fsnotify_mark MUST be the first thing */
	struct fsnotify_mark_entry fsn_entry;		struct fsnotify_mark fsn_entry;
	int wd;		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);		struct fsnotify_group *group);
	extern void inotify_free_event_priv(struct fsnotify_event_private_data *event_priv);		extern void inotify_free_event_priv(struct fsnotify_event_private_data *event_priv);