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/gfp.h>
22 #include <linux/init.h>
23 #include <linux/module.h>
24 #include <linux/mount.h>
25 #include <linux/srcu.h>
27 #include <linux/fsnotify_backend.h>
31 * Clear all of the marks on an inode when it is being evicted from core
33 void __fsnotify_inode_delete(struct inode
*inode
)
35 fsnotify_clear_marks_by_inode(inode
);
37 EXPORT_SYMBOL_GPL(__fsnotify_inode_delete
);
39 void __fsnotify_vfsmount_delete(struct vfsmount
*mnt
)
41 fsnotify_clear_marks_by_mount(mnt
);
45 * Given an inode, first check if we care what happens to our children. Inotify
46 * and dnotify both tell their parents about events. If we care about any event
47 * on a child we run all of our children and set a dentry flag saying that the
48 * parent cares. Thus when an event happens on a child it can quickly tell if
49 * if there is a need to find a parent and send the event to the parent.
51 void __fsnotify_update_child_dentry_flags(struct inode
*inode
)
56 if (!S_ISDIR(inode
->i_mode
))
59 /* determine if the children should tell inode about their events */
60 watched
= fsnotify_inode_watches_children(inode
);
62 spin_lock(&dcache_lock
);
63 /* run all of the dentries associated with this inode. Since this is a
64 * directory, there damn well better only be one item on this list */
65 list_for_each_entry(alias
, &inode
->i_dentry
, d_alias
) {
68 /* run all of the children of the original inode and fix their
69 * d_flags to indicate parental interest (their parent is the
71 list_for_each_entry(child
, &alias
->d_subdirs
, d_u
.d_child
) {
75 spin_lock(&child
->d_lock
);
77 child
->d_flags
|= DCACHE_FSNOTIFY_PARENT_WATCHED
;
79 child
->d_flags
&= ~DCACHE_FSNOTIFY_PARENT_WATCHED
;
80 spin_unlock(&child
->d_lock
);
83 spin_unlock(&dcache_lock
);
86 /* Notify this dentry's parent about a child's events. */
87 void __fsnotify_parent(struct path
*path
, struct dentry
*dentry
, __u32 mask
)
89 struct dentry
*parent
;
90 struct inode
*p_inode
;
93 dentry
= path
->dentry
;
95 if (!(dentry
->d_flags
& DCACHE_FSNOTIFY_PARENT_WATCHED
))
98 parent
= dget_parent(dentry
);
99 p_inode
= parent
->d_inode
;
101 if (unlikely(!fsnotify_inode_watches_children(p_inode
)))
102 __fsnotify_update_child_dentry_flags(p_inode
);
103 else if (p_inode
->i_fsnotify_mask
& mask
) {
104 /* we are notifying a parent so come up with the new mask which
105 * specifies these are events which came from a child. */
106 mask
|= FS_EVENT_ON_CHILD
;
109 fsnotify(p_inode
, mask
, path
, FSNOTIFY_EVENT_PATH
,
110 dentry
->d_name
.name
, 0);
112 fsnotify(p_inode
, mask
, dentry
->d_inode
, FSNOTIFY_EVENT_INODE
,
113 dentry
->d_name
.name
, 0);
118 EXPORT_SYMBOL_GPL(__fsnotify_parent
);
120 static int send_to_group(struct inode
*to_tell
, struct vfsmount
*mnt
,
121 struct fsnotify_mark
*inode_mark
,
122 struct fsnotify_mark
*vfsmount_mark
,
123 __u32 mask
, void *data
,
124 int data_is
, u32 cookie
,
125 const unsigned char *file_name
,
126 struct fsnotify_event
**event
)
128 struct fsnotify_group
*group
= NULL
;
129 __u32 inode_test_mask
= 0;
130 __u32 vfsmount_test_mask
= 0;
132 if (unlikely(!inode_mark
&& !vfsmount_mark
)) {
137 /* clear ignored on inode modification */
138 if (mask
& FS_MODIFY
) {
140 !(inode_mark
->flags
& FSNOTIFY_MARK_FLAG_IGNORED_SURV_MODIFY
))
141 inode_mark
->ignored_mask
= 0;
143 !(vfsmount_mark
->flags
& FSNOTIFY_MARK_FLAG_IGNORED_SURV_MODIFY
))
144 vfsmount_mark
->ignored_mask
= 0;
147 /* does the inode mark tell us to do something? */
149 group
= inode_mark
->group
;
150 inode_test_mask
= (mask
& ~FS_EVENT_ON_CHILD
);
151 inode_test_mask
&= inode_mark
->mask
;
152 inode_test_mask
&= ~inode_mark
->ignored_mask
;
155 /* does the vfsmount_mark tell us to do something? */
157 vfsmount_test_mask
= (mask
& ~FS_EVENT_ON_CHILD
);
158 group
= vfsmount_mark
->group
;
159 vfsmount_test_mask
&= vfsmount_mark
->mask
;
160 vfsmount_test_mask
&= ~vfsmount_mark
->ignored_mask
;
162 vfsmount_test_mask
&= ~inode_mark
->ignored_mask
;
165 pr_debug("%s: group=%p to_tell=%p mnt=%p mask=%x inode_mark=%p"
166 " inode_test_mask=%x vfsmount_mark=%p vfsmount_test_mask=%x"
167 " data=%p data_is=%d cookie=%d event=%p\n",
168 __func__
, group
, to_tell
, mnt
, mask
, inode_mark
,
169 inode_test_mask
, vfsmount_mark
, vfsmount_test_mask
, data
,
170 data_is
, cookie
, *event
);
172 if (!inode_test_mask
&& !vfsmount_test_mask
)
175 if (group
->ops
->should_send_event(group
, to_tell
, inode_mark
,
176 vfsmount_mark
, mask
, data
,
181 *event
= fsnotify_create_event(to_tell
, mask
, data
,
187 return group
->ops
->handle_event(group
, inode_mark
, vfsmount_mark
, *event
);
191 * This is the main call to fsnotify. The VFS calls into hook specific functions
192 * in linux/fsnotify.h. Those functions then in turn call here. Here will call
193 * out to all of the registered fsnotify_group. Those groups can then use the
194 * notification event in whatever means they feel necessary.
196 int fsnotify(struct inode
*to_tell
, __u32 mask
, void *data
, int data_is
,
197 const unsigned char *file_name
, u32 cookie
)
199 struct hlist_node
*inode_node
= NULL
, *vfsmount_node
= NULL
;
200 struct fsnotify_mark
*inode_mark
= NULL
, *vfsmount_mark
= NULL
;
201 struct fsnotify_group
*inode_group
, *vfsmount_group
;
202 struct fsnotify_event
*event
= NULL
;
203 struct vfsmount
*mnt
;
205 /* global tests shouldn't care about events on child only the specific event */
206 __u32 test_mask
= (mask
& ~FS_EVENT_ON_CHILD
);
208 if (data_is
== FSNOTIFY_EVENT_PATH
)
209 mnt
= ((struct path
*)data
)->mnt
;
214 * if this is a modify event we may need to clear the ignored masks
215 * otherwise return if neither the inode nor the vfsmount care about
216 * this type of event.
218 if (!(mask
& FS_MODIFY
) &&
219 !(test_mask
& to_tell
->i_fsnotify_mask
) &&
220 !(mnt
&& test_mask
& mnt
->mnt_fsnotify_mask
))
223 idx
= srcu_read_lock(&fsnotify_mark_srcu
);
225 if ((mask
& FS_MODIFY
) ||
226 (test_mask
& to_tell
->i_fsnotify_mask
))
227 inode_node
= srcu_dereference(to_tell
->i_fsnotify_marks
.first
,
228 &fsnotify_mark_srcu
);
230 if (mnt
&& ((mask
& FS_MODIFY
) ||
231 (test_mask
& mnt
->mnt_fsnotify_mask
))) {
232 vfsmount_node
= srcu_dereference(mnt
->mnt_fsnotify_marks
.first
,
233 &fsnotify_mark_srcu
);
234 inode_node
= srcu_dereference(to_tell
->i_fsnotify_marks
.first
,
235 &fsnotify_mark_srcu
);
238 while (inode_node
|| vfsmount_node
) {
239 inode_group
= vfsmount_group
= NULL
;
242 inode_mark
= hlist_entry(srcu_dereference(inode_node
, &fsnotify_mark_srcu
),
243 struct fsnotify_mark
, i
.i_list
);
244 inode_group
= inode_mark
->group
;
248 vfsmount_mark
= hlist_entry(srcu_dereference(vfsmount_node
, &fsnotify_mark_srcu
),
249 struct fsnotify_mark
, m
.m_list
);
250 vfsmount_group
= vfsmount_mark
->group
;
253 if (inode_group
> vfsmount_group
) {
255 send_to_group(to_tell
, NULL
, inode_mark
, NULL
, mask
, data
,
256 data_is
, cookie
, file_name
, &event
);
257 /* we didn't use the vfsmount_mark */
258 vfsmount_group
= NULL
;
259 } else if (vfsmount_group
> inode_group
) {
260 send_to_group(to_tell
, mnt
, NULL
, vfsmount_mark
, mask
, data
,
261 data_is
, cookie
, file_name
, &event
);
264 send_to_group(to_tell
, mnt
, inode_mark
, vfsmount_mark
,
265 mask
, data
, data_is
, cookie
, file_name
,
270 inode_node
= srcu_dereference(inode_node
->next
,
271 &fsnotify_mark_srcu
);
273 vfsmount_node
= srcu_dereference(vfsmount_node
->next
,
274 &fsnotify_mark_srcu
);
277 srcu_read_unlock(&fsnotify_mark_srcu
, idx
);
279 * fsnotify_create_event() took a reference so the event can't be cleaned
280 * up while we are still trying to add it to lists, drop that one.
283 fsnotify_put_event(event
);
287 EXPORT_SYMBOL_GPL(fsnotify
);
289 static __init
int fsnotify_init(void)
293 BUG_ON(hweight32(ALL_FSNOTIFY_EVENTS
) != 23);
295 ret
= init_srcu_struct(&fsnotify_mark_srcu
);
297 panic("initializing fsnotify_mark_srcu");
301 core_initcall(fsnotify_init
);