fsnotify: rename fsnotify_find_mark_entry to fsnotify_find_mark

the _entry portion of fsnotify functions is useless.  Drop it.

Signed-off-by: Eric Paris <eparis@redhat.com>

7 files changed, 31 insertions, 31 deletions

diff --git a/fs/notify/dnotify/dnotify.c b/fs/notify/dnotify/dnotify.c
index e6edae60894d..b202bc590c61 100644
--- a/fs/notify/dnotify/dnotify.c
+++ b/fs/notify/dnotify/dnotify.c
@@ -96,7 +96,7 @@ static int dnotify_handle_event(struct fsnotify_group *group,
         to_tell = event->to_tell;
 
         spin_lock(&to_tell->i_lock);
-        entry = fsnotify_find_mark_entry(group, to_tell);
+        entry = fsnotify_find_mark(group, to_tell);
         spin_unlock(&to_tell->i_lock);
 
         /* unlikely since we alreay passed dnotify_should_send_event() */
@@ -148,7 +148,7 @@ static bool dnotify_should_send_event(struct fsnotify_group *group,
                 return false;
 
         spin_lock(&inode->i_lock);
-        entry = fsnotify_find_mark_entry(group, inode);
+        entry = fsnotify_find_mark(group, inode);
         spin_unlock(&inode->i_lock);
 
         /* no mark means no dnotify watch */
@@ -158,7 +158,7 @@ static bool dnotify_should_send_event(struct fsnotify_group *group,
         mask = (mask & ~FS_EVENT_ON_CHILD);
         send = (mask & entry->mask);
 
-        fsnotify_put_mark(entry); /* matches fsnotify_find_mark_entry */
+        fsnotify_put_mark(entry); /* matches fsnotify_find_mark */
 
         return send;
 }
@@ -202,7 +202,7 @@ void dnotify_flush(struct file *filp, fl_owner_t id)
                 return;
 
         spin_lock(&inode->i_lock);
-        entry = fsnotify_find_mark_entry(dnotify_group, inode);
+        entry = fsnotify_find_mark(dnotify_group, inode);
         spin_unlock(&inode->i_lock);
         if (!entry)
                 return;
@@ -226,7 +226,7 @@ void dnotify_flush(struct file *filp, fl_owner_t id)
 
         /* nothing else could have found us thanks to the dnotify_mark_mutex */
         if (dnentry->dn == NULL)
-                fsnotify_destroy_mark_by_entry(entry);
+                fsnotify_destroy_mark(entry);
 
         fsnotify_recalc_group_mask(dnotify_group);
 
@@ -357,7 +357,7 @@ int fcntl_dirnotify(int fd, struct file *filp, unsigned long arg)
 
         /* add the new_entry or find an old one. */
         spin_lock(&inode->i_lock);
-        entry = fsnotify_find_mark_entry(dnotify_group, inode);
+        entry = fsnotify_find_mark(dnotify_group, inode);
         spin_unlock(&inode->i_lock);
         if (entry) {
                 dnentry = container_of(entry, struct dnotify_mark_entry, fsn_entry);
@@ -414,7 +414,7 @@ out:
         spin_unlock(&entry->lock);
 
         if (destroy)
-                fsnotify_destroy_mark_by_entry(entry);
+                fsnotify_destroy_mark(entry);
 
         fsnotify_recalc_group_mask(dnotify_group);
 
diff --git a/fs/notify/inode_mark.c b/fs/notify/inode_mark.c
index 7e69f6b08d4e..01c42632eb2a 100644
--- a/fs/notify/inode_mark.c
+++ b/fs/notify/inode_mark.c
@@ -56,7 +56,7 @@
  * - The inode is unlinked for the last time.  (fsnotify_inode_remove)
  * - The inode is being evicted from cache. (fsnotify_inode_delete)
  * - The fs the inode is on is unmounted.  (fsnotify_inode_delete/fsnotify_unmount_inodes)
- * - Something explicitly requests that it be removed.  (fsnotify_destroy_mark_by_entry)
+ * - Something explicitly requests that it be removed.  (fsnotify_destroy_mark)
  * - The fsnotify_group associated with the mark is going away and all such marks
  *   need to be cleaned up. (fsnotify_clear_marks_by_group)
  *
@@ -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)
+void fsnotify_destroy_mark(struct fsnotify_mark *entry)
 {
         struct fsnotify_group *group;
         struct inode *inode;
@@ -233,7 +233,7 @@ void fsnotify_clear_marks_by_group(struct fsnotify_group *group)
         spin_unlock(&group->mark_lock);
 
         list_for_each_entry_safe(entry, lentry, &free_list, free_g_list) {
-                fsnotify_destroy_mark_by_entry(entry);
+                fsnotify_destroy_mark(entry);
                 fsnotify_put_mark(entry);
         }
 }
@@ -256,7 +256,7 @@ void fsnotify_clear_marks_by_inode(struct inode *inode)
         spin_unlock(&inode->i_lock);
 
         list_for_each_entry_safe(entry, lentry, &free_list, i.free_i_list) {
-                fsnotify_destroy_mark_by_entry(entry);
+                fsnotify_destroy_mark(entry);
                 fsnotify_put_mark(entry);
         }
 }
@@ -265,8 +265,8 @@ 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 *fsnotify_find_mark_entry(struct fsnotify_group *group,
-                                               struct inode *inode)
+struct fsnotify_mark *fsnotify_find_mark(struct fsnotify_group *group,
+                                         struct inode *inode)
 {
         struct fsnotify_mark *entry;
         struct hlist_node *pos;
@@ -349,7 +349,7 @@ int fsnotify_add_mark(struct fsnotify_mark *entry,
         spin_lock(&inode->i_lock);
 
         if (!allow_dups)
-                lentry = fsnotify_find_mark_entry(group, inode);
+                lentry = fsnotify_find_mark(group, inode);
         if (!lentry) {
                 entry->group = group;
                 entry->i.inode = inode;
diff --git a/fs/notify/inotify/inotify_fsnotify.c b/fs/notify/inotify/inotify_fsnotify.c
index f33a9bd32e5d..f8a2a6eda133 100644
--- a/fs/notify/inotify/inotify_fsnotify.c
+++ b/fs/notify/inotify/inotify_fsnotify.c
@@ -98,7 +98,7 @@ static int inotify_handle_event(struct fsnotify_group *group, struct fsnotify_ev
         to_tell = event->to_tell;
 
         spin_lock(&to_tell->i_lock);
-        entry = fsnotify_find_mark_entry(group, to_tell);
+        entry = fsnotify_find_mark(group, to_tell);
         spin_unlock(&to_tell->i_lock);
         /* race with watch removal?  We already passes should_send */
         if (unlikely(!entry))
@@ -148,7 +148,7 @@ static bool inotify_should_send_event(struct fsnotify_group *group, struct inode
         bool send;
 
         spin_lock(&inode->i_lock);
-        entry = fsnotify_find_mark_entry(group, inode);
+        entry = fsnotify_find_mark(group, inode);
         spin_unlock(&inode->i_lock);
         if (!entry)
                 return false;
diff --git a/fs/notify/inotify/inotify_user.c b/fs/notify/inotify/inotify_user.c
index 7be5dcf07ac7..118085c9d2d9 100644
--- a/fs/notify/inotify/inotify_user.c
+++ b/fs/notify/inotify/inotify_user.c
@@ -567,7 +567,7 @@ static int inotify_update_existing_watch(struct fsnotify_group *group,
                 return -EINVAL;
 
         spin_lock(&inode->i_lock);
-        entry = fsnotify_find_mark_entry(group, inode);
+        entry = fsnotify_find_mark(group, inode);
         spin_unlock(&inode->i_lock);
         if (!entry)
                 return -ENOENT;
@@ -607,7 +607,7 @@ static int inotify_update_existing_watch(struct fsnotify_group *group,
         /* return the wd */
         ret = ientry->wd;
 
-        /* match the get from fsnotify_find_mark_entry() */
+        /* match the get from fsnotify_find_mark() */
         fsnotify_put_mark(entry);
 
         return ret;
@@ -823,7 +823,7 @@ SYSCALL_DEFINE2(inotify_rm_watch, int, fd, __s32, wd)
 
         ret = 0;
 
-        fsnotify_destroy_mark_by_entry(&ientry->fsn_entry);
+        fsnotify_destroy_mark(&ientry->fsn_entry);
 
         /* match ref taken by inotify_idr_find */
         fsnotify_put_mark(&ientry->fsn_entry);
diff --git a/include/linux/fsnotify_backend.h b/include/linux/fsnotify_backend.h
index 59c072e8fddd..83b6bfeb2d66 100644
--- a/include/linux/fsnotify_backend.h
+++ b/include/linux/fsnotify_backend.h
@@ -363,13 +363,13 @@ extern struct fsnotify_event *fsnotify_remove_notify_event(struct fsnotify_group
 extern void fsnotify_recalc_inode_mask(struct inode *inode);
 extern void fsnotify_init_mark(struct fsnotify_mark *entry, void (*free_mark)(struct fsnotify_mark *entry));
 /* find (and take a reference) to a mark associated with group and inode */
-extern struct fsnotify_mark *fsnotify_find_mark_entry(struct fsnotify_group *group, struct inode *inode);
+extern struct fsnotify_mark *fsnotify_find_mark(struct fsnotify_group *group, struct inode *inode);
 /* copy the values from old into new */
 extern void fsnotify_duplicate_mark(struct fsnotify_mark *new, struct fsnotify_mark *old);
 /* attach the mark to both the group and the inode */
 extern int fsnotify_add_mark(struct fsnotify_mark *entry, struct fsnotify_group *group, struct inode *inode, int allow_dups);
 /* given a mark, flag it to be freed when all references are dropped */
-extern void fsnotify_destroy_mark_by_entry(struct fsnotify_mark *entry);
+extern void fsnotify_destroy_mark(struct fsnotify_mark *entry);
 /* run all the marks in a group, and flag them to be freed */
 extern void fsnotify_clear_marks_by_group(struct fsnotify_group *group);
 extern void fsnotify_get_mark(struct fsnotify_mark *entry);
diff --git a/kernel/audit_tree.c b/kernel/audit_tree.c
index f16f909fbbc1..b20fb055d712 100644
--- a/kernel/audit_tree.c
+++ b/kernel/audit_tree.c
@@ -250,7 +250,7 @@ static void untag_chunk(struct node *p)
                 list_del_rcu(&chunk->hash);
                 spin_unlock(&hash_lock);
                 spin_unlock(&entry->lock);
-                fsnotify_destroy_mark_by_entry(entry);
+                fsnotify_destroy_mark(entry);
                 fsnotify_put_mark(entry);
                 goto out;
         }
@@ -293,7 +293,7 @@ static void untag_chunk(struct node *p)
                 owner->root = new;
         spin_unlock(&hash_lock);
         spin_unlock(&entry->lock);
-        fsnotify_destroy_mark_by_entry(entry);
+        fsnotify_destroy_mark(entry);
         fsnotify_put_mark(entry);
         goto out;
 
@@ -333,7 +333,7 @@ static int create_chunk(struct inode *inode, struct audit_tree *tree)
                 spin_unlock(&hash_lock);
                 chunk->dead = 1;
                 spin_unlock(&entry->lock);
-                fsnotify_destroy_mark_by_entry(entry);
+                fsnotify_destroy_mark(entry);
                 fsnotify_put_mark(entry);
                 return 0;
         }
@@ -361,7 +361,7 @@ static int tag_chunk(struct inode *inode, struct audit_tree *tree)
         int n;
 
         spin_lock(&inode->i_lock);
-        old_entry = fsnotify_find_mark_entry(audit_tree_group, inode);
+        old_entry = fsnotify_find_mark(audit_tree_group, inode);
         spin_unlock(&inode->i_lock);
         if (!old_entry)
                 return create_chunk(inode, tree);
@@ -415,7 +415,7 @@ static int tag_chunk(struct inode *inode, struct audit_tree *tree)
                 spin_unlock(&chunk_entry->lock);
                 spin_unlock(&old_entry->lock);
 
-                fsnotify_destroy_mark_by_entry(chunk_entry);
+                fsnotify_destroy_mark(chunk_entry);
 
                 fsnotify_put_mark(chunk_entry);
                 fsnotify_put_mark(old_entry);
@@ -446,7 +446,7 @@ static int tag_chunk(struct inode *inode, struct audit_tree *tree)
         spin_unlock(&hash_lock);
         spin_unlock(&chunk_entry->lock);
         spin_unlock(&old_entry->lock);
-        fsnotify_destroy_mark_by_entry(old_entry);
+        fsnotify_destroy_mark(old_entry);
         fsnotify_put_mark(old_entry); /* pair to fsnotify_find mark_entry */
         fsnotify_put_mark(old_entry); /* and kill it */
         return 0;
diff --git a/kernel/audit_watch.c b/kernel/audit_watch.c
index d8cb55a5c059..24ecbebf4354 100644
--- a/kernel/audit_watch.c
+++ b/kernel/audit_watch.c
@@ -102,7 +102,7 @@ static inline struct audit_parent *audit_find_parent(struct inode *inode)
         struct fsnotify_mark *entry;
 
         spin_lock(&inode->i_lock);
-        entry = fsnotify_find_mark_entry(audit_watch_group, inode);
+        entry = fsnotify_find_mark(audit_watch_group, inode);
         spin_unlock(&inode->i_lock);
 
         if (entry)
@@ -354,7 +354,7 @@ static void audit_remove_parent_watches(struct audit_parent *parent)
         }
         mutex_unlock(&audit_filter_mutex);
 
-        fsnotify_destroy_mark_by_entry(&parent->mark);
+        fsnotify_destroy_mark(&parent->mark);
 
         fsnotify_recalc_group_mask(audit_watch_group);
 
@@ -504,7 +504,7 @@ void audit_remove_watch_rule(struct audit_krule *krule)
 
                 if (list_empty(&parent->watches)) {
                         audit_get_parent(parent);
-                        fsnotify_destroy_mark_by_entry(&parent->mark);
+                        fsnotify_destroy_mark(&parent->mark);
                         audit_put_parent(parent);
                 }
         }
@@ -521,7 +521,7 @@ static bool audit_watch_should_send_event(struct fsnotify_group *group, struct i
         bool send;
 
         spin_lock(&inode->i_lock);
-        entry = fsnotify_find_mark_entry(group, inode);
+        entry = fsnotify_find_mark(group, inode);
         spin_unlock(&inode->i_lock);
         if (!entry)
                 return false;