fsnotify.c 11.1 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
/*
 *  Copyright (C) 2008 Red Hat, Inc., Eric Paris <eparis@redhat.com>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2, or (at your option)
 *  any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; see the file COPYING.  If not, write to
 *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <linux/dcache.h>
#include <linux/fs.h>
21
#include <linux/gfp.h>
22 23
#include <linux/init.h>
#include <linux/module.h>
24
#include <linux/mount.h>
25 26 27 28 29
#include <linux/srcu.h>

#include <linux/fsnotify_backend.h>
#include "fsnotify.h"

30 31 32 33 34 35 36 37 38
/*
 * Clear all of the marks on an inode when it is being evicted from core
 */
void __fsnotify_inode_delete(struct inode *inode)
{
	fsnotify_clear_marks_by_inode(inode);
}
EXPORT_SYMBOL_GPL(__fsnotify_inode_delete);

39 40 41 42 43
void __fsnotify_vfsmount_delete(struct vfsmount *mnt)
{
	fsnotify_clear_marks_by_mount(mnt);
}

Jan Kara's avatar
Jan Kara committed
44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69
/**
 * fsnotify_unmount_inodes - an sb is unmounting.  handle any watched inodes.
 * @sb: superblock being unmounted.
 *
 * Called during unmount with no locks held, so needs to be safe against
 * concurrent modifiers. We temporarily drop sb->s_inode_list_lock and CAN block.
 */
void fsnotify_unmount_inodes(struct super_block *sb)
{
	struct inode *inode, *iput_inode = NULL;

	spin_lock(&sb->s_inode_list_lock);
	list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
		/*
		 * We cannot __iget() an inode in state I_FREEING,
		 * I_WILL_FREE, or I_NEW which is fine because by that point
		 * the inode cannot have any associated watches.
		 */
		spin_lock(&inode->i_lock);
		if (inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) {
			spin_unlock(&inode->i_lock);
			continue;
		}

		/*
		 * If i_count is zero, the inode cannot have any watches and
70
		 * doing an __iget/iput with SB_ACTIVE clear would actually
Jan Kara's avatar
Jan Kara committed
71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100
		 * evict all inodes with zero i_count from icache which is
		 * unnecessarily violent and may in fact be illegal to do.
		 */
		if (!atomic_read(&inode->i_count)) {
			spin_unlock(&inode->i_lock);
			continue;
		}

		__iget(inode);
		spin_unlock(&inode->i_lock);
		spin_unlock(&sb->s_inode_list_lock);

		if (iput_inode)
			iput(iput_inode);

		/* for each watch, send FS_UNMOUNT and then remove it */
		fsnotify(inode, FS_UNMOUNT, inode, FSNOTIFY_EVENT_INODE, NULL, 0);

		fsnotify_inode_delete(inode);

		iput_inode = inode;

		spin_lock(&sb->s_inode_list_lock);
	}
	spin_unlock(&sb->s_inode_list_lock);

	if (iput_inode)
		iput(iput_inode);
}

101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118
/*
 * Given an inode, first check if we care what happens to our children.  Inotify
 * and dnotify both tell their parents about events.  If we care about any event
 * on a child we run all of our children and set a dentry flag saying that the
 * parent cares.  Thus when an event happens on a child it can quickly tell if
 * if there is a need to find a parent and send the event to the parent.
 */
void __fsnotify_update_child_dentry_flags(struct inode *inode)
{
	struct dentry *alias;
	int watched;

	if (!S_ISDIR(inode->i_mode))
		return;

	/* determine if the children should tell inode about their events */
	watched = fsnotify_inode_watches_children(inode);

119
	spin_lock(&inode->i_lock);
120 121
	/* run all of the dentries associated with this inode.  Since this is a
	 * 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 124 125 126 127
		struct dentry *child;

		/* run all of the children of the original inode and fix their
		 * d_flags to indicate parental interest (their parent is the
		 * original inode) */
Nick Piggin's avatar
Nick Piggin committed
128
		spin_lock(&alias->d_lock);
129
		list_for_each_entry(child, &alias->d_subdirs, d_child) {
130 131 132
			if (!child->d_inode)
				continue;

Nick Piggin's avatar
Nick Piggin committed
133
			spin_lock_nested(&child->d_lock, DENTRY_D_LOCK_NESTED);
134 135 136 137 138 139
			if (watched)
				child->d_flags |= DCACHE_FSNOTIFY_PARENT_WATCHED;
			else
				child->d_flags &= ~DCACHE_FSNOTIFY_PARENT_WATCHED;
			spin_unlock(&child->d_lock);
		}
Nick Piggin's avatar
Nick Piggin committed
140
		spin_unlock(&alias->d_lock);
141
	}
142
	spin_unlock(&inode->i_lock);
143 144 145
}

/* Notify this dentry's parent about a child's events. */
Al Viro's avatar
Al Viro committed
146
int __fsnotify_parent(const struct path *path, struct dentry *dentry, __u32 mask)
147 148 149
{
	struct dentry *parent;
	struct inode *p_inode;
150
	int ret = 0;
151

152
	if (!dentry)
153
		dentry = path->dentry;
154

155
	if (!(dentry->d_flags & DCACHE_FSNOTIFY_PARENT_WATCHED))
156
		return 0;
157

158
	parent = dget_parent(dentry);
159 160
	p_inode = parent->d_inode;

161 162 163
	if (unlikely(!fsnotify_inode_watches_children(p_inode)))
		__fsnotify_update_child_dentry_flags(p_inode);
	else if (p_inode->i_fsnotify_mask & mask) {
Al Viro's avatar
Al Viro committed
164 165
		struct name_snapshot name;

166 167 168 169
		/* we are notifying a parent so come up with the new mask which
		 * specifies these are events which came from a child. */
		mask |= FS_EVENT_ON_CHILD;

Al Viro's avatar
Al Viro committed
170
		take_dentry_name_snapshot(&name, dentry);
171
		if (path)
172
			ret = fsnotify(p_inode, mask, path, FSNOTIFY_EVENT_PATH,
Al Viro's avatar
Al Viro committed
173
				       name.name, 0);
174
		else
175
			ret = fsnotify(p_inode, mask, dentry->d_inode, FSNOTIFY_EVENT_INODE,
Al Viro's avatar
Al Viro committed
176 177
				       name.name, 0);
		release_dentry_name_snapshot(&name);
178 179
	}

180
	dput(parent);
181 182

	return ret;
183 184 185
}
EXPORT_SYMBOL_GPL(__fsnotify_parent);

186
static int send_to_group(struct inode *to_tell,
187 188
			 struct fsnotify_mark *inode_mark,
			 struct fsnotify_mark *vfsmount_mark,
Al Viro's avatar
Al Viro committed
189
			 __u32 mask, const void *data,
190
			 int data_is, u32 cookie,
191 192
			 const unsigned char *file_name,
			 struct fsnotify_iter_info *iter_info)
193
{
194
	struct fsnotify_group *group = NULL;
195 196
	__u32 inode_test_mask = 0;
	__u32 vfsmount_test_mask = 0;
197

198 199 200 201
	if (unlikely(!inode_mark && !vfsmount_mark)) {
		BUG();
		return 0;
	}
202 203 204 205 206 207 208 209 210 211

	/* 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;
	}
212

213 214
	/* does the inode mark tell us to do something? */
	if (inode_mark) {
215
		group = inode_mark->group;
216
		inode_test_mask = (mask & ~FS_EVENT_ON_CHILD);
217 218 219
		inode_test_mask &= inode_mark->mask;
		inode_test_mask &= ~inode_mark->ignored_mask;
	}
220

221 222
	/* does the vfsmount_mark tell us to do something? */
	if (vfsmount_mark) {
223
		vfsmount_test_mask = (mask & ~FS_EVENT_ON_CHILD);
224
		group = vfsmount_mark->group;
225 226 227 228 229 230
		vfsmount_test_mask &= vfsmount_mark->mask;
		vfsmount_test_mask &= ~vfsmount_mark->ignored_mask;
		if (inode_mark)
			vfsmount_test_mask &= ~inode_mark->ignored_mask;
	}

231
	pr_debug("%s: group=%p to_tell=%p mask=%x inode_mark=%p"
232
		 " inode_test_mask=%x vfsmount_mark=%p vfsmount_test_mask=%x"
233
		 " data=%p data_is=%d cookie=%d\n",
234
		 __func__, group, to_tell, mask, inode_mark,
235
		 inode_test_mask, vfsmount_mark, vfsmount_test_mask, data,
236
		 data_is, cookie);
237

238
	if (!inode_test_mask && !vfsmount_test_mask)
239 240
		return 0;

241 242
	return group->ops->handle_event(group, to_tell, inode_mark,
					vfsmount_mark, mask, data, data_is,
243
					file_name, cookie, iter_info);
244 245
}

246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268
static struct fsnotify_mark *fsnotify_first_mark(struct fsnotify_mark_connector **connp)
{
	struct fsnotify_mark_connector *conn;
	struct hlist_node *node = NULL;

	conn = srcu_dereference(*connp, &fsnotify_mark_srcu);
	if (conn)
		node = srcu_dereference(conn->list.first, &fsnotify_mark_srcu);

	return hlist_entry_safe(node, struct fsnotify_mark, obj_list);
}

static struct fsnotify_mark *fsnotify_next_mark(struct fsnotify_mark *mark)
{
	struct hlist_node *node = NULL;

	if (mark)
		node = srcu_dereference(mark->obj_list.next,
					&fsnotify_mark_srcu);

	return hlist_entry_safe(node, struct fsnotify_mark, obj_list);
}

269 270 271 272 273 274
/*
 * This is the main call to fsnotify.  The VFS calls into hook specific functions
 * in linux/fsnotify.h.  Those functions then in turn call here.  Here will call
 * out to all of the registered fsnotify_group.  Those groups can then use the
 * notification event in whatever means they feel necessary.
 */
Al Viro's avatar
Al Viro committed
275
int fsnotify(struct inode *to_tell, __u32 mask, const void *data, int data_is,
276
	     const unsigned char *file_name, u32 cookie)
277
{
278
	struct fsnotify_iter_info iter_info = {};
279
	struct mount *mnt;
280
	int ret = 0;
281 282
	/* global tests shouldn't care about events on child only the specific event */
	__u32 test_mask = (mask & ~FS_EVENT_ON_CHILD);
283

284
	if (data_is == FSNOTIFY_EVENT_PATH)
Al Viro's avatar
Al Viro committed
285
		mnt = real_mount(((const struct path *)data)->mnt);
286 287 288
	else
		mnt = NULL;

289 290 291 292 293 294 295
	/*
	 * Optimization: srcu_read_lock() has a memory barrier which can
	 * be expensive.  It protects walking the *_fsnotify_marks lists.
	 * However, if we do not walk the lists, we do not have to do
	 * SRCU because we have no references to any objects and do not
	 * need SRCU to keep them "alive".
	 */
296 297
	if (!to_tell->i_fsnotify_marks &&
	    (!mnt || !mnt->mnt_fsnotify_marks))
298
		return 0;
299 300 301 302 303 304 305 306 307
	/*
	 * 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.
	 */
	if (!(mask & FS_MODIFY) &&
	    !(test_mask & to_tell->i_fsnotify_mask) &&
	    !(mnt && test_mask & mnt->mnt_fsnotify_mask))
		return 0;
308

309
	iter_info.srcu_idx = srcu_read_lock(&fsnotify_mark_srcu);
310

311
	if ((mask & FS_MODIFY) ||
312
	    (test_mask & to_tell->i_fsnotify_mask)) {
313 314
		iter_info.inode_mark =
			fsnotify_first_mark(&to_tell->i_fsnotify_marks);
315
	}
316

317 318
	if (mnt && ((mask & FS_MODIFY) ||
		    (test_mask & mnt->mnt_fsnotify_mask))) {
319 320 321 322
		iter_info.inode_mark =
			fsnotify_first_mark(&to_tell->i_fsnotify_marks);
		iter_info.vfsmount_mark =
			fsnotify_first_mark(&mnt->mnt_fsnotify_marks);
323
	}
324

325 326 327 328 329
	/*
	 * We need to merge inode & vfsmount mark lists so that inode mark
	 * ignore masks are properly reflected for mount mark notifications.
	 * That's why this traversal is so complicated...
	 */
330 331 332 333 334 335 336 337
	while (iter_info.inode_mark || iter_info.vfsmount_mark) {
		struct fsnotify_mark *inode_mark = iter_info.inode_mark;
		struct fsnotify_mark *vfsmount_mark = iter_info.vfsmount_mark;

		if (inode_mark && vfsmount_mark) {
			int cmp = fsnotify_compare_groups(inode_mark->group,
							  vfsmount_mark->group);
			if (cmp > 0)
338
				inode_mark = NULL;
339
			else if (cmp < 0)
340
				vfsmount_mark = NULL;
341
		}
342

343
		ret = send_to_group(to_tell, inode_mark, vfsmount_mark, mask,
344 345
				    data, data_is, cookie, file_name,
				    &iter_info);
346

347 348 349
		if (ret && (mask & ALL_FSNOTIFY_PERM_EVENTS))
			goto out;

350 351 352 353 354 355
		if (inode_mark)
			iter_info.inode_mark =
				fsnotify_next_mark(iter_info.inode_mark);
		if (vfsmount_mark)
			iter_info.vfsmount_mark =
				fsnotify_next_mark(iter_info.vfsmount_mark);
356
	}
357 358
	ret = 0;
out:
359
	srcu_read_unlock(&fsnotify_mark_srcu, iter_info.srcu_idx);
360

361
	return ret;
362 363 364
}
EXPORT_SYMBOL_GPL(fsnotify);

365 366
extern struct kmem_cache *fsnotify_mark_connector_cachep;

367 368
static __init int fsnotify_init(void)
{
369 370
	int ret;

371 372
	BUG_ON(hweight32(ALL_FSNOTIFY_EVENTS) != 23);

373 374 375 376
	ret = init_srcu_struct(&fsnotify_mark_srcu);
	if (ret)
		panic("initializing fsnotify_mark_srcu");

377 378 379
	fsnotify_mark_connector_cachep = KMEM_CACHE(fsnotify_mark_connector,
						    SLAB_PANIC);

380
	return 0;
381
}
382
core_initcall(fsnotify_init);