}
/* Notify this dentry's parent about a child's events. */
-void __fsnotify_parent(struct path *path, struct dentry *dentry, __u32 mask)
+void __fsnotify_parent(struct file *file, struct dentry *dentry, __u32 mask)
{
struct dentry *parent;
struct inode *p_inode;
bool should_update_children = false;
if (!dentry)
- dentry = path->dentry;
+ dentry = file->f_path.dentry;
if (!(dentry->d_flags & DCACHE_FSNOTIFY_PARENT_WATCHED))
return;
* specifies these are events which came from a child. */
mask |= FS_EVENT_ON_CHILD;
- if (path)
- fsnotify(p_inode, mask, path, FSNOTIFY_EVENT_PATH,
+ if (file)
+ fsnotify(p_inode, mask, file, FSNOTIFY_EVENT_FILE,
dentry->d_name.name, 0);
else
fsnotify(p_inode, mask, dentry->d_inode, FSNOTIFY_EVENT_INODE,
}
EXPORT_SYMBOL_GPL(__fsnotify_parent);
-void __fsnotify_flush_ignored_mask(struct inode *inode, void *data, int data_is)
+static int send_to_group(struct inode *to_tell, struct vfsmount *mnt,
+ struct fsnotify_mark *inode_mark,
+ struct fsnotify_mark *vfsmount_mark,
+ __u32 mask, void *data,
+ int data_is, u32 cookie,
+ const unsigned char *file_name,
+ struct fsnotify_event **event)
{
- struct fsnotify_mark *mark;
- struct hlist_node *node;
-
- if (!hlist_empty(&inode->i_fsnotify_marks)) {
- spin_lock(&inode->i_lock);
- hlist_for_each_entry(mark, node, &inode->i_fsnotify_marks, i.i_list) {
- if (!(mark->flags & FSNOTIFY_MARK_FLAG_IGNORED_SURV_MODIFY))
- mark->ignored_mask = 0;
- }
- spin_unlock(&inode->i_lock);
+ struct fsnotify_group *group = inode_mark->group;
+ __u32 inode_test_mask = (mask & ~FS_EVENT_ON_CHILD);
+ __u32 vfsmount_test_mask = (mask & ~FS_EVENT_ON_CHILD);
+
+ pr_debug("%s: group=%p to_tell=%p mnt=%p mark=%p mask=%x data=%p"
+ " data_is=%d cookie=%d event=%p\n", __func__, group, to_tell,
+ mnt, inode_mark, mask, data, data_is, cookie, *event);
+
+ /* clear ignored on inode modification */
+ if (mask & FS_MODIFY) {
+ if (inode_mark &&
+ !(inode_mark->flags & FSNOTIFY_MARK_FLAG_IGNORED_SURV_MODIFY))
+ inode_mark->ignored_mask = 0;
+ if (vfsmount_mark &&
+ !(vfsmount_mark->flags & FSNOTIFY_MARK_FLAG_IGNORED_SURV_MODIFY))
+ vfsmount_mark->ignored_mask = 0;
}
- if (data_is == FSNOTIFY_EVENT_PATH) {
- struct vfsmount *mnt;
-
- mnt = ((struct path *)data)->mnt;
- if (mnt && !hlist_empty(&mnt->mnt_fsnotify_marks)) {
- spin_lock(&mnt->mnt_root->d_lock);
- hlist_for_each_entry(mark, node, &mnt->mnt_fsnotify_marks, m.m_list) {
- if (!(mark->flags & FSNOTIFY_MARK_FLAG_IGNORED_SURV_MODIFY))
- mark->ignored_mask = 0;
- }
- spin_unlock(&mnt->mnt_root->d_lock);
- }
+ /* does the inode mark tell us to do something? */
+ if (inode_mark) {
+ inode_test_mask &= inode_mark->mask;
+ inode_test_mask &= ~inode_mark->ignored_mask;
}
-}
-static int send_to_group(struct fsnotify_group *group, struct inode *to_tell,
- struct vfsmount *mnt, __u32 mask, void *data,
- int data_is, u32 cookie, const unsigned char *file_name,
- struct fsnotify_event **event)
-{
- if (!group->ops->should_send_event(group, to_tell, mnt, mask,
- data, data_is))
+ /* does the vfsmount_mark tell us to do something? */
+ if (vfsmount_mark) {
+ vfsmount_test_mask &= vfsmount_mark->mask;
+ vfsmount_test_mask &= ~vfsmount_mark->ignored_mask;
+ if (inode_mark)
+ vfsmount_test_mask &= ~inode_mark->ignored_mask;
+ }
+
+ if (!inode_test_mask && !vfsmount_test_mask)
return 0;
+
+ if (group->ops->should_send_event(group, to_tell, inode_mark,
+ vfsmount_mark, mask, data,
+ data_is) == false)
+ return 0;
+
if (!*event) {
*event = fsnotify_create_event(to_tell, mask, data,
data_is, file_name,
if (!*event)
return -ENOMEM;
}
- return group->ops->handle_event(group, *event);
-}
-
-static bool needed_by_vfsmount(__u32 test_mask, struct vfsmount *mnt)
-{
- if (!mnt)
- return false;
-
- return (test_mask & mnt->mnt_fsnotify_mask);
+ return group->ops->handle_event(group, inode_mark, vfsmount_mark, *event);
}
/*
int fsnotify(struct inode *to_tell, __u32 mask, void *data, int data_is,
const unsigned char *file_name, u32 cookie)
{
- struct fsnotify_group *group;
+ struct hlist_node *inode_node, *vfsmount_node;
+ struct fsnotify_mark *inode_mark = NULL, *vfsmount_mark = NULL;
+ struct fsnotify_group *inode_group, *vfsmount_group;
struct fsnotify_event *event = NULL;
- struct vfsmount *mnt = NULL;
+ struct vfsmount *mnt;
int idx, ret = 0;
+ bool used_inode = false, used_vfsmount = false;
/* global tests shouldn't care about events on child only the specific event */
__u32 test_mask = (mask & ~FS_EVENT_ON_CHILD);
- /* if no fsnotify listeners, nothing to do */
- if (list_empty(&fsnotify_inode_groups) &&
- list_empty(&fsnotify_vfsmount_groups))
- return 0;
-
- if (mask & FS_MODIFY)
- __fsnotify_flush_ignored_mask(to_tell, data, data_is);
-
- /* if none of the directed listeners or vfsmount listeners care */
- if (!(test_mask & fsnotify_inode_mask) &&
- !(test_mask & fsnotify_vfsmount_mask))
- return 0;
-
- if (data_is == FSNOTIFY_EVENT_PATH)
- mnt = ((struct path *)data)->mnt;
-
- /* if this inode's directed listeners don't care and nothing on the vfsmount
- * listeners list cares, nothing to do */
- if (!(test_mask & to_tell->i_fsnotify_mask) &&
- !needed_by_vfsmount(test_mask, mnt))
- return 0;
+ if (data_is == FSNOTIFY_EVENT_FILE)
+ mnt = ((struct file *)data)->f_path.mnt;
+ else
+ mnt = NULL;
/*
- * SRCU!! the groups list is very very much read only and the path is
- * very hot. The VAST majority of events are not going to need to do
- * anything other than walk the list so it's crazy to pre-allocate.
+ * if this is a modify event we may need to clear the ignored masks
+ * otherwise return if neither the inode nor the vfsmount care about
+ * this type of event.
*/
- idx = srcu_read_lock(&fsnotify_grp_srcu);
-
- if (test_mask & to_tell->i_fsnotify_mask) {
- list_for_each_entry_rcu(group, &fsnotify_inode_groups, inode_group_list) {
- if (test_mask & group->mask) {
- ret = send_to_group(group, to_tell, NULL, mask, data, data_is,
- cookie, file_name, &event);
- if (ret)
- goto out;
- }
- }
+ if (!(mask & FS_MODIFY) &&
+ !(test_mask & to_tell->i_fsnotify_mask) &&
+ !(mnt && test_mask & mnt->mnt_fsnotify_mask))
+ return 0;
+
+ idx = srcu_read_lock(&fsnotify_mark_srcu);
+
+ if ((mask & FS_MODIFY) ||
+ (test_mask & to_tell->i_fsnotify_mask))
+ inode_node = srcu_dereference(to_tell->i_fsnotify_marks.first,
+ &fsnotify_mark_srcu);
+ else
+ inode_node = NULL;
+
+ if (mnt) {
+ if ((mask & FS_MODIFY) ||
+ (test_mask & mnt->mnt_fsnotify_mask))
+ vfsmount_node = srcu_dereference(mnt->mnt_fsnotify_marks.first,
+ &fsnotify_mark_srcu);
+ else
+ vfsmount_node = NULL;
+ } else {
+ mnt = NULL;
+ vfsmount_node = NULL;
}
- if (needed_by_vfsmount(test_mask, mnt)) {
- list_for_each_entry_rcu(group, &fsnotify_vfsmount_groups, vfsmount_group_list) {
- if (test_mask & group->mask) {
- ret = send_to_group(group, to_tell, mnt, mask, data, data_is,
- cookie, file_name, &event);
- if (ret)
- goto out;
- }
+
+ while (inode_node || vfsmount_node) {
+ if (inode_node) {
+ inode_mark = hlist_entry(srcu_dereference(inode_node, &fsnotify_mark_srcu),
+ struct fsnotify_mark, i.i_list);
+ inode_group = inode_mark->group;
+ } else
+ inode_group = (void *)-1;
+
+ if (vfsmount_node) {
+ vfsmount_mark = hlist_entry(srcu_dereference(vfsmount_node, &fsnotify_mark_srcu),
+ struct fsnotify_mark, m.m_list);
+ vfsmount_group = vfsmount_mark->group;
+ } else
+ vfsmount_group = (void *)-1;
+
+ if (inode_group < vfsmount_group) {
+ /* handle inode */
+ send_to_group(to_tell, NULL, inode_mark, NULL, mask, data,
+ data_is, cookie, file_name, &event);
+ used_inode = true;
+ } else if (vfsmount_group < inode_group) {
+ send_to_group(to_tell, mnt, NULL, vfsmount_mark, mask, data,
+ data_is, cookie, file_name, &event);
+ used_vfsmount = true;
+ } else {
+ send_to_group(to_tell, mnt, inode_mark, vfsmount_mark,
+ mask, data, data_is, cookie, file_name,
+ &event);
+ used_vfsmount = true;
+ used_inode = true;
}
+
+ if (used_inode)
+ inode_node = srcu_dereference(inode_node->next,
+ &fsnotify_mark_srcu);
+ if (used_vfsmount)
+ vfsmount_node = srcu_dereference(vfsmount_node->next,
+ &fsnotify_mark_srcu);
}
-out:
- srcu_read_unlock(&fsnotify_grp_srcu, idx);
+
+ srcu_read_unlock(&fsnotify_mark_srcu, idx);
/*
* fsnotify_create_event() took a reference so the event can't be cleaned
* up while we are still trying to add it to lists, drop that one.
static __init int fsnotify_init(void)
{
+ int ret;
+
BUG_ON(hweight32(ALL_FSNOTIFY_EVENTS) != 23);
- return init_srcu_struct(&fsnotify_grp_srcu);
+ ret = init_srcu_struct(&fsnotify_mark_srcu);
+ if (ret)
+ panic("initializing fsnotify_mark_srcu");
+
+ return 0;
}
-subsys_initcall(fsnotify_init);
+core_initcall(fsnotify_init);
git://bbs.cooldavid.org / net-next-2.6.git / blobdiff