2 * Copyright (C) 2008 Red Hat, Inc., Eric Paris <eparis@redhat.com>
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2, or (at your option)
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; see the file COPYING. If not, write to
16 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
19 #include <linux/dcache.h>
21 #include <linux/init.h>
22 #include <linux/module.h>
23 #include <linux/srcu.h>
25 #include <linux/fsnotify_backend.h>
29 * Clear all of the marks on an inode when it is being evicted from core
31 void __fsnotify_inode_delete(struct inode
*inode
)
33 fsnotify_clear_marks_by_inode(inode
);
35 EXPORT_SYMBOL_GPL(__fsnotify_inode_delete
);
38 * Given an inode, first check if we care what happens to our children. Inotify
39 * and dnotify both tell their parents about events. If we care about any event
40 * on a child we run all of our children and set a dentry flag saying that the
41 * parent cares. Thus when an event happens on a child it can quickly tell if
42 * if there is a need to find a parent and send the event to the parent.
44 void __fsnotify_update_child_dentry_flags(struct inode
*inode
)
49 if (!S_ISDIR(inode
->i_mode
))
52 /* determine if the children should tell inode about their events */
53 watched
= fsnotify_inode_watches_children(inode
);
55 spin_lock(&dcache_lock
);
56 /* run all of the dentries associated with this inode. Since this is a
57 * directory, there damn well better only be one item on this list */
58 list_for_each_entry(alias
, &inode
->i_dentry
, d_alias
) {
61 /* run all of the children of the original inode and fix their
62 * d_flags to indicate parental interest (their parent is the
64 list_for_each_entry(child
, &alias
->d_subdirs
, d_u
.d_child
) {
68 spin_lock(&child
->d_lock
);
70 child
->d_flags
|= DCACHE_FSNOTIFY_PARENT_WATCHED
;
72 child
->d_flags
&= ~DCACHE_FSNOTIFY_PARENT_WATCHED
;
73 spin_unlock(&child
->d_lock
);
76 spin_unlock(&dcache_lock
);
79 /* Notify this dentry's parent about a child's events. */
80 void __fsnotify_parent(struct file
*file
, struct dentry
*dentry
, __u32 mask
)
82 struct dentry
*parent
;
83 struct inode
*p_inode
;
85 bool should_update_children
= false;
88 dentry
= file
->f_path
.dentry
;
90 if (!(dentry
->d_flags
& DCACHE_FSNOTIFY_PARENT_WATCHED
))
93 spin_lock(&dentry
->d_lock
);
94 parent
= dentry
->d_parent
;
95 p_inode
= parent
->d_inode
;
97 if (fsnotify_inode_watches_children(p_inode
)) {
98 if (p_inode
->i_fsnotify_mask
& mask
) {
104 * The parent doesn't care about events on it's children but
105 * at least one child thought it did. We need to run all the
106 * children and update their d_flags to let them know p_inode
107 * doesn't care about them any more.
110 should_update_children
= true;
113 spin_unlock(&dentry
->d_lock
);
116 /* we are notifying a parent so come up with the new mask which
117 * specifies these are events which came from a child. */
118 mask
|= FS_EVENT_ON_CHILD
;
121 fsnotify(p_inode
, mask
, file
, FSNOTIFY_EVENT_FILE
,
122 dentry
->d_name
.name
, 0);
124 fsnotify(p_inode
, mask
, dentry
->d_inode
, FSNOTIFY_EVENT_INODE
,
125 dentry
->d_name
.name
, 0);
129 if (unlikely(should_update_children
)) {
130 __fsnotify_update_child_dentry_flags(p_inode
);
134 EXPORT_SYMBOL_GPL(__fsnotify_parent
);
137 * This is the main call to fsnotify. The VFS calls into hook specific functions
138 * in linux/fsnotify.h. Those functions then in turn call here. Here will call
139 * out to all of the registered fsnotify_group. Those groups can then use the
140 * notification event in whatever means they feel necessary.
142 void fsnotify(struct inode
*to_tell
, __u32 mask
, void *data
, int data_is
, const char *file_name
, u32 cookie
)
144 struct fsnotify_group
*group
;
145 struct fsnotify_event
*event
= NULL
;
147 /* global tests shouldn't care about events on child only the specific event */
148 __u32 test_mask
= (mask
& ~FS_EVENT_ON_CHILD
);
150 if (list_empty(&fsnotify_groups
))
153 if (!(test_mask
& fsnotify_mask
))
156 if (!(test_mask
& to_tell
->i_fsnotify_mask
))
159 * SRCU!! the groups list is very very much read only and the path is
160 * very hot. The VAST majority of events are not going to need to do
161 * anything other than walk the list so it's crazy to pre-allocate.
163 idx
= srcu_read_lock(&fsnotify_grp_srcu
);
164 list_for_each_entry_rcu(group
, &fsnotify_groups
, group_list
) {
165 if (test_mask
& group
->mask
) {
166 if (!group
->ops
->should_send_event(group
, to_tell
, mask
,
170 event
= fsnotify_create_event(to_tell
, mask
, data
,
171 data_is
, file_name
, cookie
,
173 /* shit, we OOM'd and now we can't tell, maybe
174 * someday someone else will want to do something
179 group
->ops
->handle_event(group
, event
);
182 srcu_read_unlock(&fsnotify_grp_srcu
, idx
);
184 * fsnotify_create_event() took a reference so the event can't be cleaned
185 * up while we are still trying to add it to lists, drop that one.
188 fsnotify_put_event(event
);
190 EXPORT_SYMBOL_GPL(fsnotify
);
192 static __init
int fsnotify_init(void)
194 return init_srcu_struct(&fsnotify_grp_srcu
);
196 subsys_initcall(fsnotify_init
);