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 * fsnotify_unmount_inodes - an sb is unmounting. handle any watched inodes.
46 * @sb: superblock being unmounted.
48 * Called during unmount with no locks held, so needs to be safe against
49 * concurrent modifiers. We temporarily drop sb->s_inode_list_lock and CAN block.
51 void fsnotify_unmount_inodes(struct super_block
*sb
)
53 struct inode
*inode
, *iput_inode
= NULL
;
55 spin_lock(&sb
->s_inode_list_lock
);
56 list_for_each_entry(inode
, &sb
->s_inodes
, i_sb_list
) {
58 * We cannot __iget() an inode in state I_FREEING,
59 * I_WILL_FREE, or I_NEW which is fine because by that point
60 * the inode cannot have any associated watches.
62 spin_lock(&inode
->i_lock
);
63 if (inode
->i_state
& (I_FREEING
|I_WILL_FREE
|I_NEW
)) {
64 spin_unlock(&inode
->i_lock
);
69 * If i_count is zero, the inode cannot have any watches and
70 * doing an __iget/iput with MS_ACTIVE clear would actually
71 * evict all inodes with zero i_count from icache which is
72 * unnecessarily violent and may in fact be illegal to do.
74 if (!atomic_read(&inode
->i_count
)) {
75 spin_unlock(&inode
->i_lock
);
80 spin_unlock(&inode
->i_lock
);
81 spin_unlock(&sb
->s_inode_list_lock
);
86 /* for each watch, send FS_UNMOUNT and then remove it */
87 fsnotify(inode
, FS_UNMOUNT
, inode
, FSNOTIFY_EVENT_INODE
, NULL
, 0);
89 fsnotify_inode_delete(inode
);
93 spin_lock(&sb
->s_inode_list_lock
);
95 spin_unlock(&sb
->s_inode_list_lock
);
102 * Given an inode, first check if we care what happens to our children. Inotify
103 * and dnotify both tell their parents about events. If we care about any event
104 * on a child we run all of our children and set a dentry flag saying that the
105 * parent cares. Thus when an event happens on a child it can quickly tell if
106 * if there is a need to find a parent and send the event to the parent.
108 void __fsnotify_update_child_dentry_flags(struct inode
*inode
)
110 struct dentry
*alias
;
113 if (!S_ISDIR(inode
->i_mode
))
116 /* determine if the children should tell inode about their events */
117 watched
= fsnotify_inode_watches_children(inode
);
119 spin_lock(&inode
->i_lock
);
120 /* run all of the dentries associated with this inode. Since this is a
121 * directory, there damn well better only be one item on this list */
122 hlist_for_each_entry(alias
, &inode
->i_dentry
, d_u
.d_alias
) {
123 struct dentry
*child
;
125 /* run all of the children of the original inode and fix their
126 * d_flags to indicate parental interest (their parent is the
128 spin_lock(&alias
->d_lock
);
129 list_for_each_entry(child
, &alias
->d_subdirs
, d_child
) {
133 spin_lock_nested(&child
->d_lock
, DENTRY_D_LOCK_NESTED
);
135 child
->d_flags
|= DCACHE_FSNOTIFY_PARENT_WATCHED
;
137 child
->d_flags
&= ~DCACHE_FSNOTIFY_PARENT_WATCHED
;
138 spin_unlock(&child
->d_lock
);
140 spin_unlock(&alias
->d_lock
);
142 spin_unlock(&inode
->i_lock
);
145 /* Notify this dentry's parent about a child's events. */
146 int __fsnotify_parent(const struct path
*path
, struct dentry
*dentry
, __u32 mask
)
148 struct dentry
*parent
;
149 struct inode
*p_inode
;
153 dentry
= path
->dentry
;
155 if (!(dentry
->d_flags
& DCACHE_FSNOTIFY_PARENT_WATCHED
))
158 parent
= dget_parent(dentry
);
159 p_inode
= parent
->d_inode
;
161 if (unlikely(!fsnotify_inode_watches_children(p_inode
))) {
162 __fsnotify_update_child_dentry_flags(p_inode
);
163 } else if (p_inode
->i_fsnotify_mask
& mask
& ~FS_EVENT_ON_CHILD
) {
164 struct name_snapshot name
;
166 /* we are notifying a parent so come up with the new mask which
167 * specifies these are events which came from a child. */
168 mask
|= FS_EVENT_ON_CHILD
;
170 take_dentry_name_snapshot(&name
, dentry
);
172 ret
= fsnotify(p_inode
, mask
, path
, FSNOTIFY_EVENT_PATH
,
175 ret
= fsnotify(p_inode
, mask
, dentry
->d_inode
, FSNOTIFY_EVENT_INODE
,
177 release_dentry_name_snapshot(&name
);
184 EXPORT_SYMBOL_GPL(__fsnotify_parent
);
186 static int send_to_group(struct inode
*to_tell
,
187 struct fsnotify_mark
*inode_mark
,
188 struct fsnotify_mark
*vfsmount_mark
,
189 __u32 mask
, const void *data
,
190 int data_is
, u32 cookie
,
191 const unsigned char *file_name
,
192 struct fsnotify_iter_info
*iter_info
)
194 struct fsnotify_group
*group
= NULL
;
195 __u32 test_mask
= (mask
& ~FS_EVENT_ON_CHILD
);
196 __u32 marks_mask
= 0;
197 __u32 marks_ignored_mask
= 0;
199 if (unlikely(!inode_mark
&& !vfsmount_mark
)) {
204 /* clear ignored on inode modification */
205 if (mask
& FS_MODIFY
) {
207 !(inode_mark
->flags
& FSNOTIFY_MARK_FLAG_IGNORED_SURV_MODIFY
))
208 inode_mark
->ignored_mask
= 0;
210 !(vfsmount_mark
->flags
& FSNOTIFY_MARK_FLAG_IGNORED_SURV_MODIFY
))
211 vfsmount_mark
->ignored_mask
= 0;
214 /* does the inode mark tell us to do something? */
216 group
= inode_mark
->group
;
217 marks_mask
|= inode_mark
->mask
;
218 marks_ignored_mask
|= inode_mark
->ignored_mask
;
221 /* does the vfsmount_mark tell us to do something? */
223 group
= vfsmount_mark
->group
;
224 marks_mask
|= vfsmount_mark
->mask
;
225 marks_ignored_mask
|= vfsmount_mark
->ignored_mask
;
228 pr_debug("%s: group=%p to_tell=%p mask=%x inode_mark=%p"
229 " vfsmount_mark=%p marks_mask=%x marks_ignored_mask=%x"
230 " data=%p data_is=%d cookie=%d\n",
231 __func__
, group
, to_tell
, mask
, inode_mark
, vfsmount_mark
,
232 marks_mask
, marks_ignored_mask
, data
,
235 if (!(test_mask
& marks_mask
& ~marks_ignored_mask
))
238 return group
->ops
->handle_event(group
, to_tell
, inode_mark
,
239 vfsmount_mark
, mask
, data
, data_is
,
240 file_name
, cookie
, iter_info
);
244 * This is the main call to fsnotify. The VFS calls into hook specific functions
245 * in linux/fsnotify.h. Those functions then in turn call here. Here will call
246 * out to all of the registered fsnotify_group. Those groups can then use the
247 * notification event in whatever means they feel necessary.
249 int fsnotify(struct inode
*to_tell
, __u32 mask
, const void *data
, int data_is
,
250 const unsigned char *file_name
, u32 cookie
)
252 struct hlist_node
*inode_node
= NULL
, *vfsmount_node
= NULL
;
253 struct fsnotify_mark
*inode_mark
= NULL
, *vfsmount_mark
= NULL
;
254 struct fsnotify_group
*inode_group
, *vfsmount_group
;
255 struct fsnotify_mark_connector
*inode_conn
, *vfsmount_conn
;
256 struct fsnotify_iter_info iter_info
;
259 /* global tests shouldn't care about events on child only the specific event */
260 __u32 test_mask
= (mask
& ~FS_EVENT_ON_CHILD
);
262 if (data_is
== FSNOTIFY_EVENT_PATH
)
263 mnt
= real_mount(((const struct path
*)data
)->mnt
);
267 /* An event "on child" is not intended for a mount mark */
268 if (mask
& FS_EVENT_ON_CHILD
)
272 * Optimization: srcu_read_lock() has a memory barrier which can
273 * be expensive. It protects walking the *_fsnotify_marks lists.
274 * However, if we do not walk the lists, we do not have to do
275 * SRCU because we have no references to any objects and do not
276 * need SRCU to keep them "alive".
278 if (!to_tell
->i_fsnotify_marks
&&
279 (!mnt
|| !mnt
->mnt_fsnotify_marks
))
282 * if this is a modify event we may need to clear the ignored masks
283 * otherwise return if neither the inode nor the vfsmount care about
284 * this type of event.
286 if (!(mask
& FS_MODIFY
) &&
287 !(test_mask
& to_tell
->i_fsnotify_mask
) &&
288 !(mnt
&& test_mask
& mnt
->mnt_fsnotify_mask
))
291 iter_info
.srcu_idx
= srcu_read_lock(&fsnotify_mark_srcu
);
293 inode_conn
= srcu_dereference(to_tell
->i_fsnotify_marks
,
294 &fsnotify_mark_srcu
);
296 inode_node
= srcu_dereference(inode_conn
->list
.first
,
297 &fsnotify_mark_srcu
);
300 inode_conn
= srcu_dereference(to_tell
->i_fsnotify_marks
,
301 &fsnotify_mark_srcu
);
303 inode_node
= srcu_dereference(inode_conn
->list
.first
,
304 &fsnotify_mark_srcu
);
305 vfsmount_conn
= srcu_dereference(mnt
->mnt_fsnotify_marks
,
306 &fsnotify_mark_srcu
);
308 vfsmount_node
= srcu_dereference(
309 vfsmount_conn
->list
.first
,
310 &fsnotify_mark_srcu
);
314 * We need to merge inode & vfsmount mark lists so that inode mark
315 * ignore masks are properly reflected for mount mark notifications.
316 * That's why this traversal is so complicated...
318 while (inode_node
|| vfsmount_node
) {
321 vfsmount_group
= NULL
;
322 vfsmount_mark
= NULL
;
325 inode_mark
= hlist_entry(srcu_dereference(inode_node
, &fsnotify_mark_srcu
),
326 struct fsnotify_mark
, obj_list
);
327 inode_group
= inode_mark
->group
;
331 vfsmount_mark
= hlist_entry(srcu_dereference(vfsmount_node
, &fsnotify_mark_srcu
),
332 struct fsnotify_mark
, obj_list
);
333 vfsmount_group
= vfsmount_mark
->group
;
336 * Need to protect both marks against freeing so that we can
337 * continue iteration from this place, regardless of which mark
338 * we actually happen to send an event for.
340 iter_info
.inode_mark
= inode_mark
;
341 iter_info
.vfsmount_mark
= vfsmount_mark
;
343 if (inode_group
&& vfsmount_group
) {
344 int cmp
= fsnotify_compare_groups(inode_group
,
349 } else if (cmp
< 0) {
350 vfsmount_group
= NULL
;
351 vfsmount_mark
= NULL
;
355 ret
= send_to_group(to_tell
, inode_mark
, vfsmount_mark
, mask
,
356 data
, data_is
, cookie
, file_name
,
359 if (ret
&& (mask
& ALL_FSNOTIFY_PERM_EVENTS
))
363 inode_node
= srcu_dereference(inode_node
->next
,
364 &fsnotify_mark_srcu
);
366 vfsmount_node
= srcu_dereference(vfsmount_node
->next
,
367 &fsnotify_mark_srcu
);
371 srcu_read_unlock(&fsnotify_mark_srcu
, iter_info
.srcu_idx
);
375 EXPORT_SYMBOL_GPL(fsnotify
);
377 extern struct kmem_cache
*fsnotify_mark_connector_cachep
;
379 static __init
int fsnotify_init(void)
383 BUG_ON(hweight32(ALL_FSNOTIFY_EVENTS
) != 23);
385 ret
= init_srcu_struct(&fsnotify_mark_srcu
);
387 panic("initializing fsnotify_mark_srcu");
389 fsnotify_mark_connector_cachep
= KMEM_CACHE(fsnotify_mark_connector
,
394 core_initcall(fsnotify_init
);