openkylin
/
linux
mirror of https://gitee.com/openkylin/linux.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity

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>
This commit is contained in:
Eric Paris 2009-12-17 21:24:24 -05:00
parent e61ce86737
commit d07754412f
7 changed files with 31 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
fs/notify/dnotify/dnotify.c
View File

@ -96,7 +96,7 @@ static int dnotify_handle_event(struct fsnotify_group *group,
to_tell = event->to_tell; to_tell = event->to_tell;
spin_lock(&to_tell->i_lock); 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); spin_unlock(&to_tell->i_lock);
/* unlikely since we alreay passed dnotify_should_send_event() */ /* 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; return false;
spin_lock(&inode->i_lock); spin_lock(&inode->i_lock);
entry = fsnotify_find_mark_entry(group, inode); entry = fsnotify_find_mark(group, inode);
spin_unlock(&inode->i_lock); spin_unlock(&inode->i_lock);
/* no mark means no dnotify watch */ /* 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); mask = (mask & ~FS_EVENT_ON_CHILD);
send = (mask & entry->mask); send = (mask & entry->mask);
fsnotify_put_mark(entry); /* matches fsnotify_find_mark_entry */ fsnotify_put_mark(entry); /* matches fsnotify_find_mark */
return send; return send;
} }
@ -202,7 +202,7 @@ void dnotify_flush(struct file *filp, fl_owner_t id)
return; return;
spin_lock(&inode->i_lock); 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); spin_unlock(&inode->i_lock);
if (!entry) if (!entry)
return; 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 */ /* nothing else could have found us thanks to the dnotify_mark_mutex */
if (dnentry->dn == NULL) if (dnentry->dn == NULL)
fsnotify_destroy_mark_by_entry(entry); fsnotify_destroy_mark(entry);
fsnotify_recalc_group_mask(dnotify_group); 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. */ /* add the new_entry or find an old one. */
spin_lock(&inode->i_lock); 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); spin_unlock(&inode->i_lock);
if (entry) { if (entry) {
dnentry = container_of(entry, struct dnotify_mark_entry, fsn_entry); dnentry = container_of(entry, struct dnotify_mark_entry, fsn_entry);
@ -414,7 +414,7 @@ int fcntl_dirnotify(int fd, struct file *filp, unsigned long arg)
spin_unlock(&entry->lock); spin_unlock(&entry->lock);
if (destroy) if (destroy)
fsnotify_destroy_mark_by_entry(entry); fsnotify_destroy_mark(entry);
fsnotify_recalc_group_mask(dnotify_group); fsnotify_recalc_group_mask(dnotify_group);

12
fs/notify/inode_mark.c
View File

@ -56,7 +56,7 @@
* - The inode is unlinked for the last time. (fsnotify_inode_remove) * - The inode is unlinked for the last time. (fsnotify_inode_remove)
* - The inode is being evicted from cache. (fsnotify_inode_delete) * - The inode is being evicted from cache. (fsnotify_inode_delete)
* - The fs the inode is on is unmounted. (fsnotify_inode_delete/fsnotify_unmount_inodes) * - 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 * - The fsnotify_group associated with the mark is going away and all such marks
* need to be cleaned up. (fsnotify_clear_marks_by_group) * 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 * 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) void fsnotify_destroy_mark(struct fsnotify_mark *entry)
{ {
struct fsnotify_group *group; struct fsnotify_group *group;
struct inode *inode; struct inode *inode;
@ -233,7 +233,7 @@ void fsnotify_clear_marks_by_group(struct fsnotify_group *group)
spin_unlock(&group->mark_lock); spin_unlock(&group->mark_lock);
list_for_each_entry_safe(entry, lentry, &free_list, free_g_list) { 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); fsnotify_put_mark(entry);
} }
} }
@ -256,7 +256,7 @@ void fsnotify_clear_marks_by_inode(struct inode *inode)
spin_unlock(&inode->i_lock); spin_unlock(&inode->i_lock);
list_for_each_entry_safe(entry, lentry, &free_list, i.free_i_list) { 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); fsnotify_put_mark(entry);
} }
} }
@ -265,7 +265,7 @@ 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 *fsnotify_find_mark_entry(struct fsnotify_group *group, struct fsnotify_mark *fsnotify_find_mark(struct fsnotify_group *group,
struct inode *inode) struct inode *inode)
{ {
struct fsnotify_mark *entry; struct fsnotify_mark *entry;
@ -349,7 +349,7 @@ int fsnotify_add_mark(struct fsnotify_mark *entry,
spin_lock(&inode->i_lock); spin_lock(&inode->i_lock);
if (!allow_dups) if (!allow_dups)
lentry = fsnotify_find_mark_entry(group, inode); lentry = fsnotify_find_mark(group, inode);
if (!lentry) { if (!lentry) {
entry->group = group; entry->group = group;
entry->i.inode = inode; entry->i.inode = inode;

4
fs/notify/inotify/inotify_fsnotify.c
View File

@ -98,7 +98,7 @@ static int inotify_handle_event(struct fsnotify_group *group, struct fsnotify_ev
to_tell = event->to_tell; to_tell = event->to_tell;
spin_lock(&to_tell->i_lock); 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); spin_unlock(&to_tell->i_lock);
/* race with watch removal? We already passes should_send */ /* race with watch removal? We already passes should_send */
if (unlikely(!entry)) if (unlikely(!entry))
@ -148,7 +148,7 @@ static bool inotify_should_send_event(struct fsnotify_group *group, struct inode
bool send; bool send;
spin_lock(&inode->i_lock); spin_lock(&inode->i_lock);
entry = fsnotify_find_mark_entry(group, inode); entry = fsnotify_find_mark(group, inode);
spin_unlock(&inode->i_lock); spin_unlock(&inode->i_lock);
if (!entry) if (!entry)
return false; return false;

6
fs/notify/inotify/inotify_user.c
View File

@ -567,7 +567,7 @@ static int inotify_update_existing_watch(struct fsnotify_group *group,
return -EINVAL; return -EINVAL;
spin_lock(&inode->i_lock); spin_lock(&inode->i_lock);
entry = fsnotify_find_mark_entry(group, inode); entry = fsnotify_find_mark(group, inode);
spin_unlock(&inode->i_lock); spin_unlock(&inode->i_lock);
if (!entry) if (!entry)
return -ENOENT; return -ENOENT;
@ -607,7 +607,7 @@ static int inotify_update_existing_watch(struct fsnotify_group *group,
/* return the wd */ /* return the wd */
ret = ientry->wd; ret = ientry->wd;
/* match the get from fsnotify_find_mark_entry() */ /* match the get from fsnotify_find_mark() */
fsnotify_put_mark(entry); fsnotify_put_mark(entry);
return ret; return ret;
@ -823,7 +823,7 @@ SYSCALL_DEFINE2(inotify_rm_watch, int, fd, __s32, wd)
ret = 0; ret = 0;
fsnotify_destroy_mark_by_entry(&ientry->fsn_entry); fsnotify_destroy_mark(&ientry->fsn_entry);
/* match ref taken by inotify_idr_find */ /* match ref taken by inotify_idr_find */
fsnotify_put_mark(&ientry->fsn_entry); fsnotify_put_mark(&ientry->fsn_entry);

4
include/linux/fsnotify_backend.h
View File

@ -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_recalc_inode_mask(struct inode *inode);
extern void fsnotify_init_mark(struct fsnotify_mark *entry, void (*free_mark)(struct fsnotify_mark *entry)); 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 */ /* 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 */ /* copy the values from old into new */
extern void fsnotify_duplicate_mark(struct fsnotify_mark *new, struct fsnotify_mark *old); extern void fsnotify_duplicate_mark(struct fsnotify_mark *new, struct fsnotify_mark *old);
/* attach the mark to both the group and the inode */ /* 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); 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 */ /* 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 */ /* 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_clear_marks_by_group(struct fsnotify_group *group);
extern void fsnotify_get_mark(struct fsnotify_mark *entry); extern void fsnotify_get_mark(struct fsnotify_mark *entry);

12
kernel/audit_tree.c
View File

@ -250,7 +250,7 @@ static void untag_chunk(struct node *p)
list_del_rcu(&chunk->hash); list_del_rcu(&chunk->hash);
spin_unlock(&hash_lock); spin_unlock(&hash_lock);
spin_unlock(&entry->lock); spin_unlock(&entry->lock);
fsnotify_destroy_mark_by_entry(entry); fsnotify_destroy_mark(entry);
fsnotify_put_mark(entry); fsnotify_put_mark(entry);
goto out; goto out;
} }
@ -293,7 +293,7 @@ static void untag_chunk(struct node *p)
owner->root = new; owner->root = new;
spin_unlock(&hash_lock); spin_unlock(&hash_lock);
spin_unlock(&entry->lock); spin_unlock(&entry->lock);
fsnotify_destroy_mark_by_entry(entry); fsnotify_destroy_mark(entry);
fsnotify_put_mark(entry); fsnotify_put_mark(entry);
goto out; goto out;
@ -333,7 +333,7 @@ static int create_chunk(struct inode *inode, struct audit_tree *tree)
spin_unlock(&hash_lock); spin_unlock(&hash_lock);
chunk->dead = 1; chunk->dead = 1;
spin_unlock(&entry->lock); spin_unlock(&entry->lock);
fsnotify_destroy_mark_by_entry(entry); fsnotify_destroy_mark(entry);
fsnotify_put_mark(entry); fsnotify_put_mark(entry);
return 0; return 0;
} }
@ -361,7 +361,7 @@ static int tag_chunk(struct inode *inode, struct audit_tree *tree)
int n; int n;
spin_lock(&inode->i_lock); 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); spin_unlock(&inode->i_lock);
if (!old_entry) if (!old_entry)
return create_chunk(inode, tree); 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(&chunk_entry->lock);
spin_unlock(&old_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(chunk_entry);
fsnotify_put_mark(old_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(&hash_lock);
spin_unlock(&chunk_entry->lock); spin_unlock(&chunk_entry->lock);
spin_unlock(&old_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); /* pair to fsnotify_find mark_entry */
fsnotify_put_mark(old_entry); /* and kill it */ fsnotify_put_mark(old_entry); /* and kill it */
return 0; return 0;

8
kernel/audit_watch.c
View File

@ -102,7 +102,7 @@ static inline struct audit_parent *audit_find_parent(struct inode *inode)
struct fsnotify_mark *entry; struct fsnotify_mark *entry;
spin_lock(&inode->i_lock); 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); spin_unlock(&inode->i_lock);
if (entry) if (entry)
@ -354,7 +354,7 @@ static void audit_remove_parent_watches(struct audit_parent *parent)
} }
mutex_unlock(&audit_filter_mutex); mutex_unlock(&audit_filter_mutex);
fsnotify_destroy_mark_by_entry(&parent->mark); fsnotify_destroy_mark(&parent->mark);
fsnotify_recalc_group_mask(audit_watch_group); 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)) { if (list_empty(&parent->watches)) {
audit_get_parent(parent); audit_get_parent(parent);
fsnotify_destroy_mark_by_entry(&parent->mark); fsnotify_destroy_mark(&parent->mark);
audit_put_parent(parent); audit_put_parent(parent);
} }
} }
@ -521,7 +521,7 @@ static bool audit_watch_should_send_event(struct fsnotify_group *group, struct i
bool send; bool send;
spin_lock(&inode->i_lock); spin_lock(&inode->i_lock);
entry = fsnotify_find_mark_entry(group, inode); entry = fsnotify_find_mark(group, inode);
spin_unlock(&inode->i_lock); spin_unlock(&inode->i_lock);
if (!entry) if (!entry)
return false; return false;