inotify_user.c 20.6 KB
Newer Older
1 2 3 4 5 6 7 8 9 10
/*
 * fs/inotify_user.c - inotify support for userspace
 *
 * Authors:
 *	John McCutchan	<ttb@tentacle.dhs.org>
 *	Robert Love	<rml@novell.com>
 *
 * Copyright (C) 2005 John McCutchan
 * Copyright 2006 Hewlett-Packard Development Company, L.P.
 *
11 12 13
 * Copyright (C) 2009 Eric Paris <Red Hat Inc>
 * inotify was largely rewriten to make use of the fsnotify infrastructure
 *
14 15 16 17 18 19 20 21 22 23 24 25
 * 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.
 */

#include <linux/file.h>
26 27 28 29
#include <linux/fs.h> /* struct inode */
#include <linux/fsnotify_backend.h>
#include <linux/idr.h>
#include <linux/init.h> /* module_init */
30
#include <linux/inotify.h>
31 32 33 34 35 36 37
#include <linux/kernel.h> /* roundup() */
#include <linux/magic.h> /* superblock magic number */
#include <linux/mount.h> /* mntget */
#include <linux/namei.h> /* LOOKUP_FOLLOW */
#include <linux/path.h> /* struct path */
#include <linux/sched.h> /* struct user */
#include <linux/slab.h> /* struct kmem_cache */
38
#include <linux/syscalls.h>
39 40 41 42
#include <linux/types.h>
#include <linux/uaccess.h>
#include <linux/poll.h>
#include <linux/wait.h>
43

44
#include "inotify.h"
45

46
#include <asm/ioctls.h>
47 48 49 50

static struct vfsmount *inotify_mnt __read_mostly;

/* these are configurable via /proc/sys/fs/inotify/ */
51 52
static int inotify_max_user_instances __read_mostly;
static int inotify_max_queued_events __read_mostly;
53
int inotify_max_user_watches __read_mostly;
54

55 56
static struct kmem_cache *inotify_inode_mark_cachep __read_mostly;
struct kmem_cache *event_priv_cachep __read_mostly;
57 58

/*
59 60
 * When inotify registers a new group it increments this and uses that
 * value as an offset to set the fsnotify group "name" and priority.
61
 */
62
static atomic_t inotify_grp_num;
63 64 65 66 67 68 69 70 71 72 73 74 75

#ifdef CONFIG_SYSCTL

#include <linux/sysctl.h>

static int zero;

ctl_table inotify_table[] = {
	{
		.procname	= "max_user_instances",
		.data		= &inotify_max_user_instances,
		.maxlen		= sizeof(int),
		.mode		= 0644,
76
		.proc_handler	= proc_dointvec_minmax,
77 78 79 80 81 82 83
		.extra1		= &zero,
	},
	{
		.procname	= "max_user_watches",
		.data		= &inotify_max_user_watches,
		.maxlen		= sizeof(int),
		.mode		= 0644,
84
		.proc_handler	= proc_dointvec_minmax,
85 86 87 88 89 90 91
		.extra1		= &zero,
	},
	{
		.procname	= "max_queued_events",
		.data		= &inotify_max_queued_events,
		.maxlen		= sizeof(int),
		.mode		= 0644,
92
		.proc_handler	= proc_dointvec_minmax,
93 94
		.extra1		= &zero
	},
95
	{ }
96 97 98
};
#endif /* CONFIG_SYSCTL */

99
static inline __u32 inotify_arg_to_mask(u32 arg)
Y
Yan Zheng 已提交
100
{
101
	__u32 mask;
Y
Yan Zheng 已提交
102

103 104
	/* everything should accept their own ignored and cares about children */
	mask = (FS_IN_IGNORED | FS_EVENT_ON_CHILD);
105

106 107
	/* mask off the flags used to open the fd */
	mask |= (arg & (IN_ALL_EVENTS | IN_ONESHOT));
108

109
	return mask;
110 111
}

112
static inline u32 inotify_mask_to_arg(__u32 mask)
113
{
114 115
	return mask & (IN_ALL_EVENTS | IN_ISDIR | IN_UNMOUNT | IN_IGNORED |
		       IN_Q_OVERFLOW);
116 117
}

118
/* intofiy userspace file descriptor functions */
119 120
static unsigned int inotify_poll(struct file *file, poll_table *wait)
{
121
	struct fsnotify_group *group = file->private_data;
122 123
	int ret = 0;

124 125 126
	poll_wait(file, &group->notification_waitq, wait);
	mutex_lock(&group->notification_mutex);
	if (!fsnotify_notify_queue_is_empty(group))
127
		ret = POLLIN | POLLRDNORM;
128
	mutex_unlock(&group->notification_mutex);
129 130 131 132

	return ret;
}

133 134 135 136 137
/*
 * Get an inotify_kernel_event if one exists and is small
 * enough to fit in "count". Return an error pointer if
 * not large enough.
 *
138
 * Called with the group->notification_mutex held.
139
 */
140 141
static struct fsnotify_event *get_one_event(struct fsnotify_group *group,
					    size_t count)
142 143
{
	size_t event_size = sizeof(struct inotify_event);
144
	struct fsnotify_event *event;
145

146
	if (fsnotify_notify_queue_is_empty(group))
147 148
		return NULL;

149 150
	event = fsnotify_peek_notify_event(group);

151 152
	if (event->name_len)
		event_size += roundup(event->name_len + 1, event_size);
153 154 155 156

	if (event_size > count)
		return ERR_PTR(-EINVAL);

157 158 159 160 161
	/* held the notification_mutex the whole time, so this is the
	 * same event we peeked above */
	fsnotify_remove_notify_event(group);

	return event;
162 163 164 165 166 167 168 169
}

/*
 * Copy an event to user space, returning how much we copied.
 *
 * We already checked that the event size is smaller than the
 * buffer we had in "get_one_event()" above.
 */
170 171
static ssize_t copy_event_to_user(struct fsnotify_group *group,
				  struct fsnotify_event *event,
172 173
				  char __user *buf)
{
174 175 176
	struct inotify_event inotify_event;
	struct fsnotify_event_private_data *fsn_priv;
	struct inotify_event_private_data *priv;
177
	size_t event_size = sizeof(struct inotify_event);
178
	size_t name_len = 0;
179 180 181 182 183 184 185 186 187 188 189 190 191 192 193

	/* we get the inotify watch descriptor from the event private data */
	spin_lock(&event->lock);
	fsn_priv = fsnotify_remove_priv_from_event(group, event);
	spin_unlock(&event->lock);

	if (!fsn_priv)
		inotify_event.wd = -1;
	else {
		priv = container_of(fsn_priv, struct inotify_event_private_data,
				    fsnotify_event_priv_data);
		inotify_event.wd = priv->wd;
		inotify_free_event_priv(fsn_priv);
	}

194 195
	/*
	 * round up event->name_len so it is a multiple of event_size
196 197
	 * plus an extra byte for the terminating '\0'.
	 */
198 199
	if (event->name_len)
		name_len = roundup(event->name_len + 1, event_size);
200 201 202 203
	inotify_event.len = name_len;

	inotify_event.mask = inotify_mask_to_arg(event->mask);
	inotify_event.cookie = event->sync_cookie;
204

205 206
	/* send the main event */
	if (copy_to_user(buf, &inotify_event, event_size))
207 208
		return -EFAULT;

209
	buf += event_size;
210

211 212 213 214 215 216 217 218 219
	/*
	 * fsnotify only stores the pathname, so here we have to send the pathname
	 * and then pad that pathname out to a multiple of sizeof(inotify_event)
	 * with zeros.  I get my zeros from the nul_inotify_event.
	 */
	if (name_len) {
		unsigned int len_to_zero = name_len - event->name_len;
		/* copy the path name */
		if (copy_to_user(buf, event->file_name, event->name_len))
220
			return -EFAULT;
221
		buf += event->name_len;
222

223 224
		/* fill userspace with 0's */
		if (clear_user(buf, len_to_zero))
225 226 227
			return -EFAULT;
		buf += len_to_zero;
		event_size += name_len;
228
	}
229

230 231 232
	return event_size;
}

233 234 235
static ssize_t inotify_read(struct file *file, char __user *buf,
			    size_t count, loff_t *pos)
{
236 237
	struct fsnotify_group *group;
	struct fsnotify_event *kevent;
238 239 240 241 242
	char __user *start;
	int ret;
	DEFINE_WAIT(wait);

	start = buf;
243
	group = file->private_data;
244 245

	while (1) {
246
		prepare_to_wait(&group->notification_waitq, &wait, TASK_INTERRUPTIBLE);
247

248 249 250
		mutex_lock(&group->notification_mutex);
		kevent = get_one_event(group, count);
		mutex_unlock(&group->notification_mutex);
251

252 253 254 255
		if (kevent) {
			ret = PTR_ERR(kevent);
			if (IS_ERR(kevent))
				break;
256 257
			ret = copy_event_to_user(group, kevent, buf);
			fsnotify_put_event(kevent);
258 259 260 261 262
			if (ret < 0)
				break;
			buf += ret;
			count -= ret;
			continue;
263 264
		}

265 266
		ret = -EAGAIN;
		if (file->f_flags & O_NONBLOCK)
267
			break;
268 269
		ret = -EINTR;
		if (signal_pending(current))
270
			break;
271

272
		if (start != buf)
273
			break;
274

275
		schedule();
276 277
	}

278
	finish_wait(&group->notification_waitq, &wait);
279 280
	if (start != buf && ret != -EFAULT)
		ret = buf - start;
281 282 283
	return ret;
}

284 285
static int inotify_fasync(int fd, struct file *file, int on)
{
286
	struct fsnotify_group *group = file->private_data;
287

288
	return fasync_helper(fd, file, on, &group->inotify_data.fa) >= 0 ? 0 : -EIO;
289 290
}

291 292
static int inotify_release(struct inode *ignored, struct file *file)
{
293
	struct fsnotify_group *group = file->private_data;
294
	struct user_struct *user = group->inotify_data.user;
295

296
	fsnotify_clear_marks_by_group(group);
297

298 299
	/* free this group, matching get was inotify_init->fsnotify_obtain_group */
	fsnotify_put_group(group);
300

301 302
	atomic_dec(&user->inotify_devs);

303 304 305 306 307 308
	return 0;
}

static long inotify_ioctl(struct file *file, unsigned int cmd,
			  unsigned long arg)
{
309 310 311
	struct fsnotify_group *group;
	struct fsnotify_event_holder *holder;
	struct fsnotify_event *event;
312 313
	void __user *p;
	int ret = -ENOTTY;
314
	size_t send_len = 0;
315

316
	group = file->private_data;
317 318 319 320
	p = (void __user *) arg;

	switch (cmd) {
	case FIONREAD:
321 322 323 324
		mutex_lock(&group->notification_mutex);
		list_for_each_entry(holder, &group->notification_list, event_list) {
			event = holder->event;
			send_len += sizeof(struct inotify_event);
325 326 327
			if (event->name_len)
				send_len += roundup(event->name_len + 1,
						sizeof(struct inotify_event));
328 329 330
		}
		mutex_unlock(&group->notification_mutex);
		ret = put_user(send_len, (int __user *) p);
331 332 333 334 335 336 337
		break;
	}

	return ret;
}

static const struct file_operations inotify_fops = {
338 339 340 341 342
	.poll		= inotify_poll,
	.read		= inotify_read,
	.fasync		= inotify_fasync,
	.release	= inotify_release,
	.unlocked_ioctl	= inotify_ioctl,
343 344 345 346
	.compat_ioctl	= inotify_ioctl,
};


347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363
/*
 * find_inode - resolve a user-given path to a specific inode
 */
static int inotify_find_inode(const char __user *dirname, struct path *path, unsigned flags)
{
	int error;

	error = user_path_at(AT_FDCWD, dirname, flags, path);
	if (error)
		return error;
	/* you can only watch an inode if you have read permissions on it */
	error = inode_permission(path->dentry->d_inode, MAY_READ);
	if (error)
		path_put(path);
	return error;
}

364 365 366 367
/*
 * Remove the mark from the idr (if present) and drop the reference
 * on the mark because it was in the idr.
 */
368 369 370 371
static void inotify_remove_from_idr(struct fsnotify_group *group,
				    struct inotify_inode_mark_entry *ientry)
{
	struct idr *idr;
372 373 374
	struct fsnotify_mark_entry *entry;
	struct inotify_inode_mark_entry *found_ientry;
	int wd;
375 376 377

	spin_lock(&group->inotify_data.idr_lock);
	idr = &group->inotify_data.idr;
378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400
	wd = ientry->wd;

	if (wd == -1)
		goto out;

	entry = idr_find(&group->inotify_data.idr, wd);
	if (unlikely(!entry))
		goto out;

	found_ientry = container_of(entry, struct inotify_inode_mark_entry, fsn_entry);
	if (unlikely(found_ientry != ientry)) {
		/* We found an entry in the idr with the right wd, but it's
		 * not the entry we were told to remove.  eparis seriously
		 * fucked up somewhere. */
		WARN_ON(1);
		ientry->wd = -1;
		goto out;
	}

	/* One ref for being in the idr, one ref held by the caller */
	BUG_ON(atomic_read(&entry->refcnt) < 2);

	idr_remove(idr, wd);
401
	ientry->wd = -1;
402 403 404 405 406

	/* removed from the idr, drop that ref */
	fsnotify_put_mark(entry);
out:
	spin_unlock(&group->inotify_data.idr_lock);
407
}
408

409
/*
410
 * Send IN_IGNORED for this wd, remove this wd from the idr.
411
 */
412 413
void inotify_ignored_and_remove_idr(struct fsnotify_mark_entry *entry,
				    struct fsnotify_group *group)
414 415
{
	struct inotify_inode_mark_entry *ientry;
416
	struct fsnotify_event *ignored_event;
417 418
	struct inotify_event_private_data *event_priv;
	struct fsnotify_event_private_data *fsn_event_priv;
E
Eric Paris 已提交
419
	int ret;
420

421 422 423 424 425 426
	ignored_event = fsnotify_create_event(NULL, FS_IN_IGNORED, NULL,
					      FSNOTIFY_EVENT_NONE, NULL, 0,
					      GFP_NOFS);
	if (!ignored_event)
		return;

427 428
	ientry = container_of(entry, struct inotify_inode_mark_entry, fsn_entry);

429
	event_priv = kmem_cache_alloc(event_priv_cachep, GFP_NOFS);
430 431 432 433 434 435 436 437
	if (unlikely(!event_priv))
		goto skip_send_ignore;

	fsn_event_priv = &event_priv->fsnotify_event_priv_data;

	fsn_event_priv->group = group;
	event_priv->wd = ientry->wd;

E
Eric Paris 已提交
438 439
	ret = fsnotify_add_notify_event(group, ignored_event, fsn_event_priv);
	if (ret)
440 441 442 443
		inotify_free_event_priv(fsn_event_priv);

skip_send_ignore:

444 445 446
	/* matches the reference taken when the event was created */
	fsnotify_put_event(ignored_event);

447
	/* remove this entry from the idr */
448
	inotify_remove_from_idr(group, ientry);
449

450
	atomic_dec(&group->inotify_data.user->inotify_watches);
451 452 453 454 455 456 457 458 459 460
}

/* ding dong the mark is dead */
static void inotify_free_mark(struct fsnotify_mark_entry *entry)
{
	struct inotify_inode_mark_entry *ientry = (struct inotify_inode_mark_entry *)entry;

	kmem_cache_free(inotify_inode_mark_cachep, ientry);
}

461 462 463
static int inotify_update_existing_watch(struct fsnotify_group *group,
					 struct inode *inode,
					 u32 arg)
464
{
465
	struct fsnotify_mark_entry *entry;
466 467
	struct inotify_inode_mark_entry *ientry;
	__u32 old_mask, new_mask;
468 469 470
	__u32 mask;
	int add = (arg & IN_MASK_ADD);
	int ret;
471 472 473 474 475 476 477 478 479

	/* don't allow invalid bits: we don't want flags set */
	mask = inotify_arg_to_mask(arg);
	if (unlikely(!mask))
		return -EINVAL;

	spin_lock(&inode->i_lock);
	entry = fsnotify_find_mark_entry(group, inode);
	spin_unlock(&inode->i_lock);
480 481
	if (!entry)
		return -ENOENT;
482

483
	ientry = container_of(entry, struct inotify_inode_mark_entry, fsn_entry);
484

485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514
	spin_lock(&entry->lock);

	old_mask = entry->mask;
	if (add) {
		entry->mask |= mask;
		new_mask = entry->mask;
	} else {
		entry->mask = mask;
		new_mask = entry->mask;
	}

	spin_unlock(&entry->lock);

	if (old_mask != new_mask) {
		/* more bits in old than in new? */
		int dropped = (old_mask & ~new_mask);
		/* more bits in this entry than the inode's mask? */
		int do_inode = (new_mask & ~inode->i_fsnotify_mask);
		/* more bits in this entry than the group? */
		int do_group = (new_mask & ~group->mask);

		/* update the inode with this new entry */
		if (dropped || do_inode)
			fsnotify_recalc_inode_mask(inode);

		/* update the group mask with the new mask */
		if (dropped || do_group)
			fsnotify_recalc_group_mask(group);
	}

515 516 517 518
	/* return the wd */
	ret = ientry->wd;

	/* match the get from fsnotify_find_mark_entry() */
519 520
	fsnotify_put_mark(entry);

521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554
	return ret;
}

static int inotify_new_watch(struct fsnotify_group *group,
			     struct inode *inode,
			     u32 arg)
{
	struct inotify_inode_mark_entry *tmp_ientry;
	__u32 mask;
	int ret;

	/* don't allow invalid bits: we don't want flags set */
	mask = inotify_arg_to_mask(arg);
	if (unlikely(!mask))
		return -EINVAL;

	tmp_ientry = kmem_cache_alloc(inotify_inode_mark_cachep, GFP_KERNEL);
	if (unlikely(!tmp_ientry))
		return -ENOMEM;

	fsnotify_init_mark(&tmp_ientry->fsn_entry, inotify_free_mark);
	tmp_ientry->fsn_entry.mask = mask;
	tmp_ientry->wd = -1;

	ret = -ENOSPC;
	if (atomic_read(&group->inotify_data.user->inotify_watches) >= inotify_max_user_watches)
		goto out_err;
retry:
	ret = -ENOMEM;
	if (unlikely(!idr_pre_get(&group->inotify_data.idr, GFP_KERNEL)))
		goto out_err;

	spin_lock(&group->inotify_data.idr_lock);
	ret = idr_get_new_above(&group->inotify_data.idr, &tmp_ientry->fsn_entry,
555
				group->inotify_data.last_wd+1,
556 557 558 559 560 561 562 563 564
				&tmp_ientry->wd);
	spin_unlock(&group->inotify_data.idr_lock);
	if (ret) {
		/* idr was out of memory allocate and try again */
		if (ret == -EAGAIN)
			goto retry;
		goto out_err;
	}

565 566 567
	/* we put the mark on the idr, take a reference */
	fsnotify_get_mark(&tmp_ientry->fsn_entry);

568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587
	/* we are on the idr, now get on the inode */
	ret = fsnotify_add_mark(&tmp_ientry->fsn_entry, group, inode);
	if (ret) {
		/* we failed to get on the inode, get off the idr */
		inotify_remove_from_idr(group, tmp_ientry);
		goto out_err;
	}

	/* update the idr hint, who cares about races, it's just a hint */
	group->inotify_data.last_wd = tmp_ientry->wd;

	/* increment the number of watches the user has */
	atomic_inc(&group->inotify_data.user->inotify_watches);

	/* return the watch descriptor for this new entry */
	ret = tmp_ientry->wd;

	/* match the ref from fsnotify_init_markentry() */
	fsnotify_put_mark(&tmp_ientry->fsn_entry);

588 589 590 591
	/* if this mark added a new event update the group mask */
	if (mask & ~group->mask)
		fsnotify_recalc_group_mask(group);

592
out_err:
593
	if (ret < 0)
594
		kmem_cache_free(inotify_inode_mark_cachep, tmp_ientry);
595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615

	return ret;
}

static int inotify_update_watch(struct fsnotify_group *group, struct inode *inode, u32 arg)
{
	int ret = 0;

retry:
	/* try to update and existing watch with the new arg */
	ret = inotify_update_existing_watch(group, inode, arg);
	/* no mark present, try to add a new one */
	if (ret == -ENOENT)
		ret = inotify_new_watch(group, inode, arg);
	/*
	 * inotify_new_watch could race with another thread which did an
	 * inotify_new_watch between the update_existing and the add watch
	 * here, go back and try to update an existing mark again.
	 */
	if (ret == -EEXIST)
		goto retry;
616

617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634
	return ret;
}

static struct fsnotify_group *inotify_new_group(struct user_struct *user, unsigned int max_events)
{
	struct fsnotify_group *group;
	unsigned int grp_num;

	/* fsnotify_obtain_group took a reference to group, we put this when we kill the file in the end */
	grp_num = (INOTIFY_GROUP_NUM - atomic_inc_return(&inotify_grp_num));
	group = fsnotify_obtain_group(grp_num, 0, &inotify_fsnotify_ops);
	if (IS_ERR(group))
		return group;

	group->max_events = max_events;

	spin_lock_init(&group->inotify_data.idr_lock);
	idr_init(&group->inotify_data.idr);
635
	group->inotify_data.last_wd = 0;
636 637 638 639 640 641 642 643
	group->inotify_data.user = user;
	group->inotify_data.fa = NULL;

	return group;
}


/* inotify syscalls */
644
SYSCALL_DEFINE1(inotify_init1, int, flags)
645
{
646
	struct fsnotify_group *group;
647 648
	struct user_struct *user;
	struct file *filp;
649
	struct path path;
650 651
	int fd, ret;

652 653 654 655
	/* Check the IN_* constants for consistency.  */
	BUILD_BUG_ON(IN_CLOEXEC != O_CLOEXEC);
	BUILD_BUG_ON(IN_NONBLOCK != O_NONBLOCK);

656
	if (flags & ~(IN_CLOEXEC | IN_NONBLOCK))
U
Ulrich Drepper 已提交
657 658 659
		return -EINVAL;

	fd = get_unused_fd_flags(flags & O_CLOEXEC);
660 661 662
	if (fd < 0)
		return fd;

663
	user = get_current_user();
664 665 666 667 668 669
	if (unlikely(atomic_read(&user->inotify_devs) >=
			inotify_max_user_instances)) {
		ret = -EMFILE;
		goto out_free_uid;
	}

670 671 672 673
	/* fsnotify_obtain_group took a reference to group, we put this when we kill the file in the end */
	group = inotify_new_group(user, inotify_max_queued_events);
	if (IS_ERR(group)) {
		ret = PTR_ERR(group);
674 675 676
		goto out_free_uid;
	}

A
Al Viro 已提交
677 678
	atomic_inc(&user->inotify_devs);

679 680 681 682
	path.mnt = inotify_mnt;
	path.dentry = inotify_mnt->mnt_root;
	path_get(&path);
	filp = alloc_file(&path, FMODE_READ, &inotify_fops);
A
Al Viro 已提交
683 684 685
	if (!filp)
		goto Enfile;

686
	filp->f_flags = O_RDONLY | (flags & O_NONBLOCK);
687 688
	filp->private_data = group;

689 690 691
	fd_install(fd, filp);

	return fd;
692

A
Al Viro 已提交
693 694
Enfile:
	ret = -ENFILE;
695
	path_put(&path);
A
Al Viro 已提交
696
	atomic_dec(&user->inotify_devs);
697 698 699 700 701 702
out_free_uid:
	free_uid(user);
	put_unused_fd(fd);
	return ret;
}

703
SYSCALL_DEFINE0(inotify_init)
U
Ulrich Drepper 已提交
704 705 706 707
{
	return sys_inotify_init1(0);
}

708 709
SYSCALL_DEFINE3(inotify_add_watch, int, fd, const char __user *, pathname,
		u32, mask)
710
{
711
	struct fsnotify_group *group;
712
	struct inode *inode;
713
	struct path path;
714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732
	struct file *filp;
	int ret, fput_needed;
	unsigned flags = 0;

	filp = fget_light(fd, &fput_needed);
	if (unlikely(!filp))
		return -EBADF;

	/* verify that this is indeed an inotify instance */
	if (unlikely(filp->f_op != &inotify_fops)) {
		ret = -EINVAL;
		goto fput_and_out;
	}

	if (!(mask & IN_DONT_FOLLOW))
		flags |= LOOKUP_FOLLOW;
	if (mask & IN_ONLYDIR)
		flags |= LOOKUP_DIRECTORY;

733 734
	ret = inotify_find_inode(pathname, &path, flags);
	if (ret)
735 736
		goto fput_and_out;

737
	/* inode held in place by reference to path; group by fget on fd */
738
	inode = path.dentry->d_inode;
739
	group = filp->private_data;
740

741 742
	/* create/update an inode mark */
	ret = inotify_update_watch(group, inode, mask);
743
	path_put(&path);
744 745 746 747 748
fput_and_out:
	fput_light(filp, fput_needed);
	return ret;
}

749
SYSCALL_DEFINE2(inotify_rm_watch, int, fd, __s32, wd)
750
{
751 752
	struct fsnotify_group *group;
	struct fsnotify_mark_entry *entry;
753
	struct file *filp;
754
	int ret = 0, fput_needed;
755 756 757 758 759 760 761 762 763 764 765

	filp = fget_light(fd, &fput_needed);
	if (unlikely(!filp))
		return -EBADF;

	/* verify that this is indeed an inotify instance */
	if (unlikely(filp->f_op != &inotify_fops)) {
		ret = -EINVAL;
		goto out;
	}

766
	group = filp->private_data;
767

768 769 770 771 772 773 774 775 776 777
	spin_lock(&group->inotify_data.idr_lock);
	entry = idr_find(&group->inotify_data.idr, wd);
	if (unlikely(!entry)) {
		spin_unlock(&group->inotify_data.idr_lock);
		ret = -EINVAL;
		goto out;
	}
	fsnotify_get_mark(entry);
	spin_unlock(&group->inotify_data.idr_lock);

778
	fsnotify_destroy_mark_by_entry(entry);
779
	fsnotify_put_mark(entry);
780 781 782 783 784 785

out:
	fput_light(filp, fput_needed);
	return ret;
}

786
static int
787
inotify_get_sb(struct file_system_type *fs_type, int flags,
788
	       const char *dev_name, void *data, struct vfsmount *mnt)
789
{
790 791
	return get_sb_pseudo(fs_type, "inotify", NULL,
			INOTIFYFS_SUPER_MAGIC, mnt);
792 793 794
}

static struct file_system_type inotify_fs_type = {
795 796 797
    .name	= "inotifyfs",
    .get_sb	= inotify_get_sb,
    .kill_sb	= kill_anon_super,
798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816
};

/*
 * inotify_user_setup - Our initialization function.  Note that we cannnot return
 * error because we have compiled-in VFS hooks.  So an (unlikely) failure here
 * must result in panic().
 */
static int __init inotify_user_setup(void)
{
	int ret;

	ret = register_filesystem(&inotify_fs_type);
	if (unlikely(ret))
		panic("inotify: register_filesystem returned %d!\n", ret);

	inotify_mnt = kern_mount(&inotify_fs_type);
	if (IS_ERR(inotify_mnt))
		panic("inotify: kern_mount ret %ld!\n", PTR_ERR(inotify_mnt));

817 818 819
	inotify_inode_mark_cachep = KMEM_CACHE(inotify_inode_mark_entry, SLAB_PANIC);
	event_priv_cachep = KMEM_CACHE(inotify_event_private_data, SLAB_PANIC);

820 821 822 823 824 825 826
	inotify_max_queued_events = 16384;
	inotify_max_user_instances = 128;
	inotify_max_user_watches = 8192;

	return 0;
}
module_init(inotify_user_setup);