blob: dd3fb0b17be7cc5d914275c6e83da49e7b8e3f48 [file] [log] [blame]
Eric Paris90586522009-05-21 17:01:20 -04001/*
2 * Copyright (C) 2008 Red Hat, Inc., Eric Paris <eparis@redhat.com>
3 *
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)
7 * any later version.
8 *
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.
13 *
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.
17 */
18
19#include <linux/dcache.h>
20#include <linux/fs.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090021#include <linux/gfp.h>
Eric Paris90586522009-05-21 17:01:20 -040022#include <linux/init.h>
23#include <linux/module.h>
Eric Paris71314852009-12-17 21:24:23 -050024#include <linux/mount.h>
Eric Paris90586522009-05-21 17:01:20 -040025#include <linux/srcu.h>
26
27#include <linux/fsnotify_backend.h>
28#include "fsnotify.h"
Al Viroc63181e2011-11-25 02:35:16 -050029#include "../mount.h"
Eric Paris90586522009-05-21 17:01:20 -040030
31/*
Eric Paris3be25f42009-05-21 17:01:26 -040032 * Clear all of the marks on an inode when it is being evicted from core
33 */
34void __fsnotify_inode_delete(struct inode *inode)
35{
36 fsnotify_clear_marks_by_inode(inode);
37}
38EXPORT_SYMBOL_GPL(__fsnotify_inode_delete);
39
Andreas Gruenbacherca9c7262009-12-17 21:24:27 -050040void __fsnotify_vfsmount_delete(struct vfsmount *mnt)
41{
42 fsnotify_clear_marks_by_mount(mnt);
43}
44
Eric Paris3be25f42009-05-21 17:01:26 -040045/*
Eric Parisc28f7e52009-05-21 17:01:29 -040046 * Given an inode, first check if we care what happens to our children. Inotify
47 * and dnotify both tell their parents about events. If we care about any event
48 * on a child we run all of our children and set a dentry flag saying that the
49 * parent cares. Thus when an event happens on a child it can quickly tell if
50 * if there is a need to find a parent and send the event to the parent.
51 */
52void __fsnotify_update_child_dentry_flags(struct inode *inode)
53{
54 struct dentry *alias;
55 int watched;
56
57 if (!S_ISDIR(inode->i_mode))
58 return;
59
60 /* determine if the children should tell inode about their events */
61 watched = fsnotify_inode_watches_children(inode);
62
Nick Piggin873feea2011-01-07 17:50:06 +110063 spin_lock(&inode->i_lock);
Eric Parisc28f7e52009-05-21 17:01:29 -040064 /* run all of the dentries associated with this inode. Since this is a
65 * directory, there damn well better only be one item on this list */
Al Viro946e51f2014-10-26 19:19:16 -040066 hlist_for_each_entry(alias, &inode->i_dentry, d_u.d_alias) {
Eric Parisc28f7e52009-05-21 17:01:29 -040067 struct dentry *child;
68
69 /* run all of the children of the original inode and fix their
70 * d_flags to indicate parental interest (their parent is the
71 * original inode) */
Nick Piggin2fd6b7f2011-01-07 17:49:34 +110072 spin_lock(&alias->d_lock);
Al Viro946e51f2014-10-26 19:19:16 -040073 list_for_each_entry(child, &alias->d_subdirs, d_child) {
Eric Parisc28f7e52009-05-21 17:01:29 -040074 if (!child->d_inode)
75 continue;
76
Nick Piggin2fd6b7f2011-01-07 17:49:34 +110077 spin_lock_nested(&child->d_lock, DENTRY_D_LOCK_NESTED);
Eric Parisc28f7e52009-05-21 17:01:29 -040078 if (watched)
79 child->d_flags |= DCACHE_FSNOTIFY_PARENT_WATCHED;
80 else
81 child->d_flags &= ~DCACHE_FSNOTIFY_PARENT_WATCHED;
82 spin_unlock(&child->d_lock);
83 }
Nick Piggin2fd6b7f2011-01-07 17:49:34 +110084 spin_unlock(&alias->d_lock);
Eric Parisc28f7e52009-05-21 17:01:29 -040085 }
Nick Piggin873feea2011-01-07 17:50:06 +110086 spin_unlock(&inode->i_lock);
Eric Parisc28f7e52009-05-21 17:01:29 -040087}
88
89/* Notify this dentry's parent about a child's events. */
Eric Paris52420392010-10-28 17:21:56 -040090int __fsnotify_parent(struct path *path, struct dentry *dentry, __u32 mask)
Eric Parisc28f7e52009-05-21 17:01:29 -040091{
92 struct dentry *parent;
93 struct inode *p_inode;
Eric Paris52420392010-10-28 17:21:56 -040094 int ret = 0;
Eric Parisc28f7e52009-05-21 17:01:29 -040095
Andreas Gruenbacher72acc852009-12-17 21:24:24 -050096 if (!dentry)
Linus Torvalds20696012010-08-12 14:23:04 -070097 dentry = path->dentry;
Eric Paris28c60e32009-12-17 21:24:21 -050098
Eric Parisc28f7e52009-05-21 17:01:29 -040099 if (!(dentry->d_flags & DCACHE_FSNOTIFY_PARENT_WATCHED))
Eric Paris52420392010-10-28 17:21:56 -0400100 return 0;
Eric Parisc28f7e52009-05-21 17:01:29 -0400101
Christoph Hellwig4d4eb362010-10-10 05:36:30 -0400102 parent = dget_parent(dentry);
Eric Parisc28f7e52009-05-21 17:01:29 -0400103 p_inode = parent->d_inode;
104
Christoph Hellwig4d4eb362010-10-10 05:36:30 -0400105 if (unlikely(!fsnotify_inode_watches_children(p_inode)))
106 __fsnotify_update_child_dentry_flags(p_inode);
107 else if (p_inode->i_fsnotify_mask & mask) {
Eric Parisc28f7e52009-05-21 17:01:29 -0400108 /* we are notifying a parent so come up with the new mask which
109 * specifies these are events which came from a child. */
110 mask |= FS_EVENT_ON_CHILD;
111
Linus Torvalds20696012010-08-12 14:23:04 -0700112 if (path)
Eric Paris52420392010-10-28 17:21:56 -0400113 ret = fsnotify(p_inode, mask, path, FSNOTIFY_EVENT_PATH,
114 dentry->d_name.name, 0);
Eric Paris28c60e32009-12-17 21:24:21 -0500115 else
Eric Paris52420392010-10-28 17:21:56 -0400116 ret = fsnotify(p_inode, mask, dentry->d_inode, FSNOTIFY_EVENT_INODE,
117 dentry->d_name.name, 0);
Eric Parisc28f7e52009-05-21 17:01:29 -0400118 }
119
Christoph Hellwig4d4eb362010-10-10 05:36:30 -0400120 dput(parent);
Eric Paris52420392010-10-28 17:21:56 -0400121
122 return ret;
Eric Parisc28f7e52009-05-21 17:01:29 -0400123}
124EXPORT_SYMBOL_GPL(__fsnotify_parent);
125
Dan Carpenterfd657172012-05-29 11:02:24 -0700126static int send_to_group(struct inode *to_tell,
Eric Parisce8f76f2010-07-28 10:18:39 -0400127 struct fsnotify_mark *inode_mark,
128 struct fsnotify_mark *vfsmount_mark,
129 __u32 mask, void *data,
Eric Paris613a8072010-07-28 10:18:39 -0400130 int data_is, u32 cookie,
Jan Kara7053aee2014-01-21 15:48:14 -0800131 const unsigned char *file_name)
Eric Paris71314852009-12-17 21:24:23 -0500132{
Eric Parisfaa95602010-08-18 12:25:49 -0400133 struct fsnotify_group *group = NULL;
Eric Paris84e1ab42010-08-18 12:25:50 -0400134 __u32 inode_test_mask = 0;
135 __u32 vfsmount_test_mask = 0;
Eric Paris613a8072010-07-28 10:18:39 -0400136
Eric Parisfaa95602010-08-18 12:25:49 -0400137 if (unlikely(!inode_mark && !vfsmount_mark)) {
138 BUG();
139 return 0;
140 }
Eric Paris5ba08e22010-07-28 10:18:37 -0400141
Eric Parisce8f76f2010-07-28 10:18:39 -0400142 /* clear ignored on inode modification */
143 if (mask & FS_MODIFY) {
144 if (inode_mark &&
145 !(inode_mark->flags & FSNOTIFY_MARK_FLAG_IGNORED_SURV_MODIFY))
146 inode_mark->ignored_mask = 0;
147 if (vfsmount_mark &&
148 !(vfsmount_mark->flags & FSNOTIFY_MARK_FLAG_IGNORED_SURV_MODIFY))
149 vfsmount_mark->ignored_mask = 0;
150 }
Eric Paris613a8072010-07-28 10:18:39 -0400151
Eric Parisce8f76f2010-07-28 10:18:39 -0400152 /* does the inode mark tell us to do something? */
153 if (inode_mark) {
Eric Parisfaa95602010-08-18 12:25:49 -0400154 group = inode_mark->group;
Eric Paris84e1ab42010-08-18 12:25:50 -0400155 inode_test_mask = (mask & ~FS_EVENT_ON_CHILD);
Eric Parisce8f76f2010-07-28 10:18:39 -0400156 inode_test_mask &= inode_mark->mask;
157 inode_test_mask &= ~inode_mark->ignored_mask;
158 }
159
160 /* does the vfsmount_mark tell us to do something? */
161 if (vfsmount_mark) {
Eric Paris84e1ab42010-08-18 12:25:50 -0400162 vfsmount_test_mask = (mask & ~FS_EVENT_ON_CHILD);
Eric Parisfaa95602010-08-18 12:25:49 -0400163 group = vfsmount_mark->group;
Eric Parisce8f76f2010-07-28 10:18:39 -0400164 vfsmount_test_mask &= vfsmount_mark->mask;
165 vfsmount_test_mask &= ~vfsmount_mark->ignored_mask;
166 if (inode_mark)
167 vfsmount_test_mask &= ~inode_mark->ignored_mask;
168 }
169
Dan Carpenterfd657172012-05-29 11:02:24 -0700170 pr_debug("%s: group=%p to_tell=%p mask=%x inode_mark=%p"
Eric Paris84e1ab42010-08-18 12:25:50 -0400171 " inode_test_mask=%x vfsmount_mark=%p vfsmount_test_mask=%x"
Jan Kara7053aee2014-01-21 15:48:14 -0800172 " data=%p data_is=%d cookie=%d\n",
Dan Carpenterfd657172012-05-29 11:02:24 -0700173 __func__, group, to_tell, mask, inode_mark,
Eric Paris84e1ab42010-08-18 12:25:50 -0400174 inode_test_mask, vfsmount_mark, vfsmount_test_mask, data,
Jan Kara7053aee2014-01-21 15:48:14 -0800175 data_is, cookie);
Eric Parisfaa95602010-08-18 12:25:49 -0400176
Eric Parisce8f76f2010-07-28 10:18:39 -0400177 if (!inode_test_mask && !vfsmount_test_mask)
Eric Paris613a8072010-07-28 10:18:39 -0400178 return 0;
179
Jan Kara7053aee2014-01-21 15:48:14 -0800180 return group->ops->handle_event(group, to_tell, inode_mark,
181 vfsmount_mark, mask, data, data_is,
Jan Kara45a22f42014-02-17 13:09:50 +0100182 file_name, cookie);
Eric Paris71314852009-12-17 21:24:23 -0500183}
184
Eric Parisc28f7e52009-05-21 17:01:29 -0400185/*
Eric Paris90586522009-05-21 17:01:20 -0400186 * This is the main call to fsnotify. The VFS calls into hook specific functions
187 * in linux/fsnotify.h. Those functions then in turn call here. Here will call
188 * out to all of the registered fsnotify_group. Those groups can then use the
189 * notification event in whatever means they feel necessary.
190 */
Eric Parisc4ec54b2009-12-17 21:24:34 -0500191int fsnotify(struct inode *to_tell, __u32 mask, void *data, int data_is,
192 const unsigned char *file_name, u32 cookie)
Eric Paris90586522009-05-21 17:01:20 -0400193{
Eric Paris84e1ab42010-08-18 12:25:50 -0400194 struct hlist_node *inode_node = NULL, *vfsmount_node = NULL;
Eric Paris613a8072010-07-28 10:18:39 -0400195 struct fsnotify_mark *inode_mark = NULL, *vfsmount_mark = NULL;
196 struct fsnotify_group *inode_group, *vfsmount_group;
Al Viroc63181e2011-11-25 02:35:16 -0500197 struct mount *mnt;
Eric Parisc4ec54b2009-12-17 21:24:34 -0500198 int idx, ret = 0;
Eric Parise42e2772009-06-11 11:09:47 -0400199 /* global tests shouldn't care about events on child only the specific event */
200 __u32 test_mask = (mask & ~FS_EVENT_ON_CHILD);
Eric Paris90586522009-05-21 17:01:20 -0400201
Linus Torvalds20696012010-08-12 14:23:04 -0700202 if (data_is == FSNOTIFY_EVENT_PATH)
Al Viroc63181e2011-11-25 02:35:16 -0500203 mnt = real_mount(((struct path *)data)->mnt);
Eric Paris613a8072010-07-28 10:18:39 -0400204 else
205 mnt = NULL;
206
207 /*
208 * if this is a modify event we may need to clear the ignored masks
209 * otherwise return if neither the inode nor the vfsmount care about
210 * this type of event.
211 */
212 if (!(mask & FS_MODIFY) &&
213 !(test_mask & to_tell->i_fsnotify_mask) &&
214 !(mnt && test_mask & mnt->mnt_fsnotify_mask))
215 return 0;
Eric Paris3a9fb892009-12-17 21:24:23 -0500216
Eric Paris75c1be42010-07-28 10:18:38 -0400217 idx = srcu_read_lock(&fsnotify_mark_srcu);
Eric Paris71314852009-12-17 21:24:23 -0500218
Eric Paris613a8072010-07-28 10:18:39 -0400219 if ((mask & FS_MODIFY) ||
220 (test_mask & to_tell->i_fsnotify_mask))
Eric Parisce8f76f2010-07-28 10:18:39 -0400221 inode_node = srcu_dereference(to_tell->i_fsnotify_marks.first,
222 &fsnotify_mark_srcu);
Eric Paris75c1be42010-07-28 10:18:38 -0400223
Eric Paris84e1ab42010-08-18 12:25:50 -0400224 if (mnt && ((mask & FS_MODIFY) ||
225 (test_mask & mnt->mnt_fsnotify_mask))) {
226 vfsmount_node = srcu_dereference(mnt->mnt_fsnotify_marks.first,
227 &fsnotify_mark_srcu);
228 inode_node = srcu_dereference(to_tell->i_fsnotify_marks.first,
229 &fsnotify_mark_srcu);
Eric Paris90586522009-05-21 17:01:20 -0400230 }
Eric Paris75c1be42010-07-28 10:18:38 -0400231
Jan Kara8edc6e12014-11-13 15:19:33 -0800232 /*
233 * We need to merge inode & vfsmount mark lists so that inode mark
234 * ignore masks are properly reflected for mount mark notifications.
235 * That's why this traversal is so complicated...
236 */
Eric Paris613a8072010-07-28 10:18:39 -0400237 while (inode_node || vfsmount_node) {
Jan Kara8edc6e12014-11-13 15:19:33 -0800238 inode_group = NULL;
239 inode_mark = NULL;
240 vfsmount_group = NULL;
241 vfsmount_mark = NULL;
Eric Paris5f3f2592010-08-18 12:25:49 -0400242
Eric Paris613a8072010-07-28 10:18:39 -0400243 if (inode_node) {
244 inode_mark = hlist_entry(srcu_dereference(inode_node, &fsnotify_mark_srcu),
Jan Kara0809ab62014-12-12 16:58:36 -0800245 struct fsnotify_mark, obj_list);
Eric Paris613a8072010-07-28 10:18:39 -0400246 inode_group = inode_mark->group;
Eric Parisf72adfd2010-08-27 21:24:24 -0400247 }
Eric Paris75c1be42010-07-28 10:18:38 -0400248
Eric Paris613a8072010-07-28 10:18:39 -0400249 if (vfsmount_node) {
250 vfsmount_mark = hlist_entry(srcu_dereference(vfsmount_node, &fsnotify_mark_srcu),
Jan Kara0809ab62014-12-12 16:58:36 -0800251 struct fsnotify_mark, obj_list);
Eric Paris613a8072010-07-28 10:18:39 -0400252 vfsmount_group = vfsmount_mark->group;
Eric Parisf72adfd2010-08-27 21:24:24 -0400253 }
Eric Paris75c1be42010-07-28 10:18:38 -0400254
Jan Kara8edc6e12014-11-13 15:19:33 -0800255 if (inode_group && vfsmount_group) {
256 int cmp = fsnotify_compare_groups(inode_group,
257 vfsmount_group);
258 if (cmp > 0) {
259 inode_group = NULL;
260 inode_mark = NULL;
261 } else if (cmp < 0) {
262 vfsmount_group = NULL;
263 vfsmount_mark = NULL;
264 }
Eric Paris71314852009-12-17 21:24:23 -0500265 }
Jan Kara8edc6e12014-11-13 15:19:33 -0800266 ret = send_to_group(to_tell, inode_mark, vfsmount_mark, mask,
267 data, data_is, cookie, file_name);
Eric Paris613a8072010-07-28 10:18:39 -0400268
Eric Parisff8bcbd2010-10-28 17:21:56 -0400269 if (ret && (mask & ALL_FSNOTIFY_PERM_EVENTS))
270 goto out;
271
Eric Paris92b46782010-08-27 21:42:11 -0400272 if (inode_group)
Eric Parisce8f76f2010-07-28 10:18:39 -0400273 inode_node = srcu_dereference(inode_node->next,
274 &fsnotify_mark_srcu);
Eric Paris92b46782010-08-27 21:42:11 -0400275 if (vfsmount_group)
Eric Parisce8f76f2010-07-28 10:18:39 -0400276 vfsmount_node = srcu_dereference(vfsmount_node->next,
277 &fsnotify_mark_srcu);
Eric Paris71314852009-12-17 21:24:23 -0500278 }
Eric Parisff8bcbd2010-10-28 17:21:56 -0400279 ret = 0;
280out:
Eric Paris75c1be42010-07-28 10:18:38 -0400281 srcu_read_unlock(&fsnotify_mark_srcu, idx);
Eric Parisc4ec54b2009-12-17 21:24:34 -0500282
Jean-Christophe Dubois98b5c102010-03-23 08:08:09 +0100283 return ret;
Eric Paris90586522009-05-21 17:01:20 -0400284}
285EXPORT_SYMBOL_GPL(fsnotify);
286
287static __init int fsnotify_init(void)
288{
Eric Paris75c1be42010-07-28 10:18:38 -0400289 int ret;
290
Eric Paris20dee622010-07-28 10:18:37 -0400291 BUG_ON(hweight32(ALL_FSNOTIFY_EVENTS) != 23);
292
Eric Paris75c1be42010-07-28 10:18:38 -0400293 ret = init_srcu_struct(&fsnotify_mark_srcu);
294 if (ret)
295 panic("initializing fsnotify_mark_srcu");
296
297 return 0;
Eric Paris90586522009-05-21 17:01:20 -0400298}
Eric Paris75c1be42010-07-28 10:18:38 -0400299core_initcall(fsnotify_init);