Branch data Line data Source code
1 : : /*
2 : : * fs/inotify_user.c - inotify support for userspace
3 : : *
4 : : * Authors:
5 : : * John McCutchan <ttb@tentacle.dhs.org>
6 : : * Robert Love <rml@novell.com>
7 : : *
8 : : * Copyright (C) 2005 John McCutchan
9 : : * Copyright 2006 Hewlett-Packard Development Company, L.P.
10 : : *
11 : : * Copyright (C) 2009 Eric Paris <Red Hat Inc>
12 : : * inotify was largely rewriten to make use of the fsnotify infrastructure
13 : : *
14 : : * This program is free software; you can redistribute it and/or modify it
15 : : * under the terms of the GNU General Public License as published by the
16 : : * Free Software Foundation; either version 2, or (at your option) any
17 : : * later version.
18 : : *
19 : : * This program is distributed in the hope that it will be useful, but
20 : : * WITHOUT ANY WARRANTY; without even the implied warranty of
21 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22 : : * General Public License for more details.
23 : : */
24 : :
25 : : #include <linux/file.h>
26 : : #include <linux/fs.h> /* struct inode */
27 : : #include <linux/fsnotify_backend.h>
28 : : #include <linux/idr.h>
29 : : #include <linux/init.h> /* module_init */
30 : : #include <linux/inotify.h>
31 : : #include <linux/kernel.h> /* roundup() */
32 : : #include <linux/namei.h> /* LOOKUP_FOLLOW */
33 : : #include <linux/sched.h> /* struct user */
34 : : #include <linux/slab.h> /* struct kmem_cache */
35 : : #include <linux/syscalls.h>
36 : : #include <linux/types.h>
37 : : #include <linux/anon_inodes.h>
38 : : #include <linux/uaccess.h>
39 : : #include <linux/poll.h>
40 : : #include <linux/wait.h>
41 : :
42 : : #include "inotify.h"
43 : : #include "../fdinfo.h"
44 : :
45 : : #include <asm/ioctls.h>
46 : :
47 : : /* these are configurable via /proc/sys/fs/inotify/ */
48 : : static int inotify_max_user_instances __read_mostly;
49 : : static int inotify_max_queued_events __read_mostly;
50 : : static int inotify_max_user_watches __read_mostly;
51 : :
52 : : static struct kmem_cache *inotify_inode_mark_cachep __read_mostly;
53 : :
54 : : #ifdef CONFIG_SYSCTL
55 : :
56 : : #include <linux/sysctl.h>
57 : :
58 : : static int zero;
59 : :
60 : : ctl_table inotify_table[] = {
61 : : {
62 : : .procname = "max_user_instances",
63 : : .data = &inotify_max_user_instances,
64 : : .maxlen = sizeof(int),
65 : : .mode = 0644,
66 : : .proc_handler = proc_dointvec_minmax,
67 : : .extra1 = &zero,
68 : : },
69 : : {
70 : : .procname = "max_user_watches",
71 : : .data = &inotify_max_user_watches,
72 : : .maxlen = sizeof(int),
73 : : .mode = 0644,
74 : : .proc_handler = proc_dointvec_minmax,
75 : : .extra1 = &zero,
76 : : },
77 : : {
78 : : .procname = "max_queued_events",
79 : : .data = &inotify_max_queued_events,
80 : : .maxlen = sizeof(int),
81 : : .mode = 0644,
82 : : .proc_handler = proc_dointvec_minmax,
83 : : .extra1 = &zero
84 : : },
85 : : { }
86 : : };
87 : : #endif /* CONFIG_SYSCTL */
88 : :
89 : : static inline __u32 inotify_arg_to_mask(u32 arg)
90 : : {
91 : : __u32 mask;
92 : :
93 : : /*
94 : : * everything should accept their own ignored, cares about children,
95 : : * and should receive events when the inode is unmounted
96 : : */
97 : : mask = (FS_IN_IGNORED | FS_EVENT_ON_CHILD | FS_UNMOUNT);
98 : :
99 : : /* mask off the flags used to open the fd */
100 : 60 : mask |= (arg & (IN_ALL_EVENTS | IN_ONESHOT | IN_EXCL_UNLINK));
101 : :
102 : : return mask;
103 : : }
104 : :
105 : : static inline u32 inotify_mask_to_arg(__u32 mask)
106 : : {
107 : 26017 : return mask & (IN_ALL_EVENTS | IN_ISDIR | IN_UNMOUNT | IN_IGNORED |
108 : : IN_Q_OVERFLOW);
109 : : }
110 : :
111 : : /* intofiy userspace file descriptor functions */
112 : 0 : static unsigned int inotify_poll(struct file *file, poll_table *wait)
113 : : {
114 : 76161 : struct fsnotify_group *group = file->private_data;
115 : : int ret = 0;
116 : :
117 : 76161 : poll_wait(file, &group->notification_waitq, wait);
118 : 76161 : mutex_lock(&group->notification_mutex);
119 [ + + ]: 76161 : if (!fsnotify_notify_queue_is_empty(group))
120 : : ret = POLLIN | POLLRDNORM;
121 : 76161 : mutex_unlock(&group->notification_mutex);
122 : :
123 : 76161 : return ret;
124 : : }
125 : :
126 : : static int round_event_name_len(struct fsnotify_event *fsn_event)
127 : : {
128 : : struct inotify_event_info *event;
129 : :
130 : : event = INOTIFY_E(fsn_event);
131 [ + + ]: 52078 : if (!event->name_len)
[ - + + + ]
132 : : return 0;
133 : 51912 : return roundup(event->name_len + 1, sizeof(struct inotify_event));
134 : : }
135 : :
136 : : /*
137 : : * Get an inotify_kernel_event if one exists and is small
138 : : * enough to fit in "count". Return an error pointer if
139 : : * not large enough.
140 : : *
141 : : * Called with the group->notification_mutex held.
142 : : */
143 : 0 : static struct fsnotify_event *get_one_event(struct fsnotify_group *group,
144 : : size_t count)
145 : : {
146 : : size_t event_size = sizeof(struct inotify_event);
147 : : struct fsnotify_event *event;
148 : :
149 [ + + ]: 64735 : if (fsnotify_notify_queue_is_empty(group))
150 : : return NULL;
151 : :
152 : 26017 : event = fsnotify_peek_notify_event(group);
153 : :
154 : : pr_debug("%s: group=%p event=%p\n", __func__, group, event);
155 : :
156 : 26017 : event_size += round_event_name_len(event);
157 [ + - ]: 26017 : if (event_size > count)
158 : : return ERR_PTR(-EINVAL);
159 : :
160 : : /* held the notification_mutex the whole time, so this is the
161 : : * same event we peeked above */
162 : 26017 : fsnotify_remove_notify_event(group);
163 : :
164 : 26017 : return event;
165 : : }
166 : :
167 : : /*
168 : : * Copy an event to user space, returning how much we copied.
169 : : *
170 : : * We already checked that the event size is smaller than the
171 : : * buffer we had in "get_one_event()" above.
172 : : */
173 : 26017 : static ssize_t copy_event_to_user(struct fsnotify_group *group,
174 : : struct fsnotify_event *fsn_event,
175 : : char __user *buf)
176 : : {
177 : : struct inotify_event inotify_event;
178 : : struct inotify_event_info *event;
179 : : size_t event_size = sizeof(struct inotify_event);
180 : : size_t name_len;
181 : : size_t pad_name_len;
182 : :
183 : : pr_debug("%s: group=%p event=%p\n", __func__, group, fsn_event);
184 : :
185 : : event = INOTIFY_E(fsn_event);
186 : 26017 : name_len = event->name_len;
187 : : /*
188 : : * round up name length so it is a multiple of event_size
189 : : * plus an extra byte for the terminating '\0'.
190 : : */
191 : 26017 : pad_name_len = round_event_name_len(fsn_event);
192 : 26017 : inotify_event.len = pad_name_len;
193 : 52034 : inotify_event.mask = inotify_mask_to_arg(fsn_event->mask);
194 : 26017 : inotify_event.wd = event->wd;
195 : 26017 : inotify_event.cookie = event->sync_cookie;
196 : :
197 : : /* send the main event */
198 [ + - ]: 52034 : if (copy_to_user(buf, &inotify_event, event_size))
199 : : return -EFAULT;
200 : :
201 : 26017 : buf += event_size;
202 : :
203 : : /*
204 : : * fsnotify only stores the pathname, so here we have to send the pathname
205 : : * and then pad that pathname out to a multiple of sizeof(inotify_event)
206 : : * with zeros.
207 : : */
208 [ + + ]: 26017 : if (pad_name_len) {
209 : : /* copy the path name */
210 [ + - ]: 25956 : if (copy_to_user(buf, event->name, name_len))
211 : : return -EFAULT;
212 : 25956 : buf += name_len;
213 : :
214 : : /* fill userspace with 0's */
215 [ + - ]: 25956 : if (clear_user(buf, pad_name_len - name_len))
216 : : return -EFAULT;
217 : 25956 : event_size += pad_name_len;
218 : : }
219 : :
220 : 26017 : return event_size;
221 : : }
222 : :
223 : 0 : static ssize_t inotify_read(struct file *file, char __user *buf,
224 : : size_t count, loff_t *pos)
225 : : {
226 : : struct fsnotify_group *group;
227 : : struct fsnotify_event *kevent;
228 : : char __user *start;
229 : : int ret;
230 : 77436 : DEFINE_WAIT(wait);
231 : :
232 : : start = buf;
233 : 64735 : group = file->private_data;
234 : :
235 : : while (1) {
236 : 64735 : prepare_to_wait(&group->notification_waitq, &wait, TASK_INTERRUPTIBLE);
237 : :
238 : 64735 : mutex_lock(&group->notification_mutex);
239 : 64735 : kevent = get_one_event(group, count);
240 : 64735 : mutex_unlock(&group->notification_mutex);
241 : :
242 : : pr_debug("%s: group=%p kevent=%p\n", __func__, group, kevent);
243 : :
244 [ + + ]: 64735 : if (kevent) {
245 : : ret = PTR_ERR(kevent);
246 [ + - ]: 26017 : if (IS_ERR(kevent))
247 : : break;
248 : 26017 : ret = copy_event_to_user(group, kevent, buf);
249 : 26017 : fsnotify_destroy_event(group, kevent);
250 [ + - ]: 26017 : if (ret < 0)
251 : : break;
252 : 26017 : buf += ret;
253 : 26017 : count -= ret;
254 : 26017 : continue;
255 : : }
256 : :
257 : : ret = -EAGAIN;
258 [ + + ]: 38718 : if (file->f_flags & O_NONBLOCK)
259 : : break;
260 : : ret = -ERESTARTSYS;
261 [ + - ]: 48 : if (signal_pending(current))
262 : : break;
263 : :
264 [ - + ]: 48 : if (start != buf)
265 : : break;
266 : :
267 : 0 : schedule();
268 : : }
269 : :
270 : 38718 : finish_wait(&group->notification_waitq, &wait);
271 [ + + ]: 38718 : if (start != buf && ret != -EFAULT)
272 : 19493 : ret = buf - start;
273 : 38718 : return ret;
274 : : }
275 : :
276 : 0 : static int inotify_release(struct inode *ignored, struct file *file)
277 : : {
278 : 8 : struct fsnotify_group *group = file->private_data;
279 : :
280 : : pr_debug("%s: group=%p\n", __func__, group);
281 : :
282 : : /* free this group, matching get was inotify_init->fsnotify_obtain_group */
283 : 8 : fsnotify_destroy_group(group);
284 : :
285 : 8 : return 0;
286 : : }
287 : :
288 : 0 : static long inotify_ioctl(struct file *file, unsigned int cmd,
289 : : unsigned long arg)
290 : : {
291 : : struct fsnotify_group *group;
292 : : struct fsnotify_event *fsn_event;
293 : : void __user *p;
294 : : int ret = -ENOTTY;
295 : : size_t send_len = 0;
296 : :
297 : 44 : group = file->private_data;
298 : 44 : p = (void __user *) arg;
299 : :
300 : : pr_debug("%s: group=%p cmd=%u\n", __func__, group, cmd);
301 : :
302 [ + - ]: 44 : switch (cmd) {
303 : : case FIONREAD:
304 : 44 : mutex_lock(&group->notification_mutex);
305 [ + + ]: 132 : list_for_each_entry(fsn_event, &group->notification_list,
306 : : list) {
307 : 44 : send_len += sizeof(struct inotify_event);
308 : 44 : send_len += round_event_name_len(fsn_event);
309 : : }
310 : 44 : mutex_unlock(&group->notification_mutex);
311 : 44 : ret = put_user(send_len, (int __user *) p);
312 : 44 : break;
313 : : }
314 : :
315 : 44 : return ret;
316 : : }
317 : :
318 : : static const struct file_operations inotify_fops = {
319 : : .show_fdinfo = inotify_show_fdinfo,
320 : : .poll = inotify_poll,
321 : : .read = inotify_read,
322 : : .fasync = fsnotify_fasync,
323 : : .release = inotify_release,
324 : : .unlocked_ioctl = inotify_ioctl,
325 : : .compat_ioctl = inotify_ioctl,
326 : : .llseek = noop_llseek,
327 : : };
328 : :
329 : :
330 : : /*
331 : : * find_inode - resolve a user-given path to a specific inode
332 : : */
333 : 0 : static int inotify_find_inode(const char __user *dirname, struct path *path, unsigned flags)
334 : : {
335 : : int error;
336 : :
337 : 30 : error = user_path_at(AT_FDCWD, dirname, flags, path);
338 [ + - ]: 30 : if (error)
339 : : return error;
340 : : /* you can only watch an inode if you have read permissions on it */
341 : 30 : error = inode_permission(path->dentry->d_inode, MAY_READ);
342 [ - + ]: 30 : if (error)
343 : 0 : path_put(path);
344 : 30 : return error;
345 : : }
346 : :
347 : 0 : static int inotify_add_to_idr(struct idr *idr, spinlock_t *idr_lock,
348 : : struct inotify_inode_mark *i_mark)
349 : : {
350 : : int ret;
351 : :
352 : 30 : idr_preload(GFP_KERNEL);
353 : : spin_lock(idr_lock);
354 : :
355 : 30 : ret = idr_alloc_cyclic(idr, i_mark, 1, 0, GFP_NOWAIT);
356 [ + - ]: 30 : if (ret >= 0) {
357 : : /* we added the mark to the idr, take a reference */
358 : 30 : i_mark->wd = ret;
359 : 30 : fsnotify_get_mark(&i_mark->fsn_mark);
360 : : }
361 : :
362 : : spin_unlock(idr_lock);
363 : : idr_preload_end();
364 : 30 : return ret < 0 ? ret : 0;
365 : : }
366 : :
367 : 0 : static struct inotify_inode_mark *inotify_idr_find_locked(struct fsnotify_group *group,
368 : : int wd)
369 : : {
370 : 58 : struct idr *idr = &group->inotify_data.idr;
371 : : spinlock_t *idr_lock = &group->inotify_data.idr_lock;
372 : : struct inotify_inode_mark *i_mark;
373 : :
374 [ - + ]: 58 : assert_spin_locked(idr_lock);
375 : :
376 : : i_mark = idr_find(idr, wd);
377 [ + + ]: 58 : if (i_mark) {
378 : 57 : struct fsnotify_mark *fsn_mark = &i_mark->fsn_mark;
379 : :
380 : 57 : fsnotify_get_mark(fsn_mark);
381 : : /* One ref for being in the idr, one ref we just took */
382 [ - + ]: 57 : BUG_ON(atomic_read(&fsn_mark->refcnt) < 2);
383 : : }
384 : :
385 : 58 : return i_mark;
386 : : }
387 : :
388 : 0 : static struct inotify_inode_mark *inotify_idr_find(struct fsnotify_group *group,
389 : : int wd)
390 : : {
391 : : struct inotify_inode_mark *i_mark;
392 : : spinlock_t *idr_lock = &group->inotify_data.idr_lock;
393 : :
394 : : spin_lock(idr_lock);
395 : 28 : i_mark = inotify_idr_find_locked(group, wd);
396 : : spin_unlock(idr_lock);
397 : :
398 : 28 : return i_mark;
399 : : }
400 : :
401 : 0 : static void do_inotify_remove_from_idr(struct fsnotify_group *group,
402 : : struct inotify_inode_mark *i_mark)
403 : : {
404 : 30 : struct idr *idr = &group->inotify_data.idr;
405 : : spinlock_t *idr_lock = &group->inotify_data.idr_lock;
406 : 30 : int wd = i_mark->wd;
407 : :
408 [ - + ]: 30 : assert_spin_locked(idr_lock);
409 : :
410 : 30 : idr_remove(idr, wd);
411 : :
412 : : /* removed from the idr, drop that ref */
413 : 30 : fsnotify_put_mark(&i_mark->fsn_mark);
414 : 30 : }
415 : :
416 : : /*
417 : : * Remove the mark from the idr (if present) and drop the reference
418 : : * on the mark because it was in the idr.
419 : : */
420 : 0 : static void inotify_remove_from_idr(struct fsnotify_group *group,
421 : : struct inotify_inode_mark *i_mark)
422 : : {
423 : : spinlock_t *idr_lock = &group->inotify_data.idr_lock;
424 : : struct inotify_inode_mark *found_i_mark = NULL;
425 : : int wd;
426 : :
427 : : spin_lock(idr_lock);
428 : 30 : wd = i_mark->wd;
429 : :
430 : : /*
431 : : * does this i_mark think it is in the idr? we shouldn't get called
432 : : * if it wasn't....
433 : : */
434 [ - + ]: 30 : if (wd == -1) {
435 [ # # ][ # # ]: 0 : WARN_ONCE(1, "%s: i_mark=%p i_mark->wd=%d i_mark->group=%p"
436 : : " i_mark->inode=%p\n", __func__, i_mark, i_mark->wd,
437 : : i_mark->fsn_mark.group, i_mark->fsn_mark.i.inode);
438 : : goto out;
439 : : }
440 : :
441 : : /* Lets look in the idr to see if we find it */
442 : 30 : found_i_mark = inotify_idr_find_locked(group, wd);
443 [ - + ]: 60 : if (unlikely(!found_i_mark)) {
444 [ # # ][ # # ]: 0 : WARN_ONCE(1, "%s: i_mark=%p i_mark->wd=%d i_mark->group=%p"
445 : : " i_mark->inode=%p\n", __func__, i_mark, i_mark->wd,
446 : : i_mark->fsn_mark.group, i_mark->fsn_mark.i.inode);
447 : : goto out;
448 : : }
449 : :
450 : : /*
451 : : * We found an mark in the idr at the right wd, but it's
452 : : * not the mark we were told to remove. eparis seriously
453 : : * fucked up somewhere.
454 : : */
455 [ - + ]: 30 : if (unlikely(found_i_mark != i_mark)) {
456 [ # # ][ # # ]: 0 : WARN_ONCE(1, "%s: i_mark=%p i_mark->wd=%d i_mark->group=%p "
457 : : "mark->inode=%p found_i_mark=%p found_i_mark->wd=%d "
458 : : "found_i_mark->group=%p found_i_mark->inode=%p\n",
459 : : __func__, i_mark, i_mark->wd, i_mark->fsn_mark.group,
460 : : i_mark->fsn_mark.i.inode, found_i_mark, found_i_mark->wd,
461 : : found_i_mark->fsn_mark.group,
462 : : found_i_mark->fsn_mark.i.inode);
463 : : goto out;
464 : : }
465 : :
466 : : /*
467 : : * One ref for being in the idr
468 : : * one ref held by the caller trying to kill us
469 : : * one ref grabbed by inotify_idr_find
470 : : */
471 [ - + ]: 30 : if (unlikely(atomic_read(&i_mark->fsn_mark.refcnt) < 3)) {
472 : 0 : printk(KERN_ERR "%s: i_mark=%p i_mark->wd=%d i_mark->group=%p"
473 : : " i_mark->inode=%p\n", __func__, i_mark, i_mark->wd,
474 : : i_mark->fsn_mark.group, i_mark->fsn_mark.i.inode);
475 : : /* we can't really recover with bad ref cnting.. */
476 : 0 : BUG();
477 : : }
478 : :
479 : 30 : do_inotify_remove_from_idr(group, i_mark);
480 : : out:
481 : : /* match the ref taken by inotify_idr_find_locked() */
482 [ + - ]: 30 : if (found_i_mark)
483 : 30 : fsnotify_put_mark(&found_i_mark->fsn_mark);
484 : 30 : i_mark->wd = -1;
485 : : spin_unlock(idr_lock);
486 : 30 : }
487 : :
488 : : /*
489 : : * Send IN_IGNORED for this wd, remove this wd from the idr.
490 : : */
491 : 0 : void inotify_ignored_and_remove_idr(struct fsnotify_mark *fsn_mark,
492 : : struct fsnotify_group *group)
493 : : {
494 : : struct inotify_inode_mark *i_mark;
495 : :
496 : : /* Queue ignore event for the watch */
497 : 30 : inotify_handle_event(group, NULL, fsn_mark, NULL, FS_IN_IGNORED,
498 : : NULL, FSNOTIFY_EVENT_NONE, NULL, 0);
499 : :
500 : : i_mark = container_of(fsn_mark, struct inotify_inode_mark, fsn_mark);
501 : : /* remove this mark from the idr */
502 : 30 : inotify_remove_from_idr(group, i_mark);
503 : :
504 : 30 : atomic_dec(&group->inotify_data.user->inotify_watches);
505 : 30 : }
506 : :
507 : : /* ding dong the mark is dead */
508 : 0 : static void inotify_free_mark(struct fsnotify_mark *fsn_mark)
509 : : {
510 : : struct inotify_inode_mark *i_mark;
511 : :
512 : : i_mark = container_of(fsn_mark, struct inotify_inode_mark, fsn_mark);
513 : :
514 : 30 : kmem_cache_free(inotify_inode_mark_cachep, i_mark);
515 : 30 : }
516 : :
517 : 0 : static int inotify_update_existing_watch(struct fsnotify_group *group,
518 : : struct inode *inode,
519 : : u32 arg)
520 : : {
521 : : struct fsnotify_mark *fsn_mark;
522 : : struct inotify_inode_mark *i_mark;
523 : : __u32 old_mask, new_mask;
524 : : __u32 mask;
525 : 30 : int add = (arg & IN_MASK_ADD);
526 : : int ret;
527 : :
528 : : mask = inotify_arg_to_mask(arg);
529 : :
530 : 30 : fsn_mark = fsnotify_find_inode_mark(group, inode);
531 [ - + ]: 30 : if (!fsn_mark)
532 : : return -ENOENT;
533 : :
534 : : i_mark = container_of(fsn_mark, struct inotify_inode_mark, fsn_mark);
535 : :
536 : : spin_lock(&fsn_mark->lock);
537 : :
538 : 0 : old_mask = fsn_mark->mask;
539 [ # # ]: 0 : if (add)
540 : 0 : fsnotify_set_mark_mask_locked(fsn_mark, (fsn_mark->mask | mask));
541 : : else
542 : 0 : fsnotify_set_mark_mask_locked(fsn_mark, mask);
543 : 0 : new_mask = fsn_mark->mask;
544 : :
545 : : spin_unlock(&fsn_mark->lock);
546 : :
547 [ # # ]: 0 : if (old_mask != new_mask) {
548 : : /* more bits in old than in new? */
549 : 0 : int dropped = (old_mask & ~new_mask);
550 : : /* more bits in this fsn_mark than the inode's mask? */
551 : 0 : int do_inode = (new_mask & ~inode->i_fsnotify_mask);
552 : :
553 : : /* update the inode with this new fsn_mark */
554 [ # # ]: 0 : if (dropped || do_inode)
555 : 0 : fsnotify_recalc_inode_mask(inode);
556 : :
557 : : }
558 : :
559 : : /* return the wd */
560 : 0 : ret = i_mark->wd;
561 : :
562 : : /* match the get from fsnotify_find_mark() */
563 : 0 : fsnotify_put_mark(fsn_mark);
564 : :
565 : 0 : return ret;
566 : : }
567 : :
568 : 0 : static int inotify_new_watch(struct fsnotify_group *group,
569 : : struct inode *inode,
570 : : u32 arg)
571 : : {
572 : : struct inotify_inode_mark *tmp_i_mark;
573 : : __u32 mask;
574 : : int ret;
575 : 30 : struct idr *idr = &group->inotify_data.idr;
576 : 30 : spinlock_t *idr_lock = &group->inotify_data.idr_lock;
577 : :
578 : : mask = inotify_arg_to_mask(arg);
579 : :
580 : 30 : tmp_i_mark = kmem_cache_alloc(inotify_inode_mark_cachep, GFP_KERNEL);
581 [ + - ]: 30 : if (unlikely(!tmp_i_mark))
582 : : return -ENOMEM;
583 : :
584 : 30 : fsnotify_init_mark(&tmp_i_mark->fsn_mark, inotify_free_mark);
585 : 30 : tmp_i_mark->fsn_mark.mask = mask;
586 : 30 : tmp_i_mark->wd = -1;
587 : :
588 : : ret = -ENOSPC;
589 [ + - ]: 30 : if (atomic_read(&group->inotify_data.user->inotify_watches) >= inotify_max_user_watches)
590 : : goto out_err;
591 : :
592 : 30 : ret = inotify_add_to_idr(idr, idr_lock, tmp_i_mark);
593 [ + - ]: 30 : if (ret)
594 : : goto out_err;
595 : :
596 : : /* we are on the idr, now get on the inode */
597 : 30 : ret = fsnotify_add_mark_locked(&tmp_i_mark->fsn_mark, group, inode,
598 : : NULL, 0);
599 [ - + ]: 30 : if (ret) {
600 : : /* we failed to get on the inode, get off the idr */
601 : 0 : inotify_remove_from_idr(group, tmp_i_mark);
602 : 0 : goto out_err;
603 : : }
604 : :
605 : : /* increment the number of watches the user has */
606 : 30 : atomic_inc(&group->inotify_data.user->inotify_watches);
607 : :
608 : : /* return the watch descriptor for this new mark */
609 : 30 : ret = tmp_i_mark->wd;
610 : :
611 : : out_err:
612 : : /* match the ref from fsnotify_init_mark() */
613 : 30 : fsnotify_put_mark(&tmp_i_mark->fsn_mark);
614 : :
615 : 30 : return ret;
616 : : }
617 : :
618 : 0 : static int inotify_update_watch(struct fsnotify_group *group, struct inode *inode, u32 arg)
619 : : {
620 : : int ret = 0;
621 : :
622 : 30 : mutex_lock(&group->mark_mutex);
623 : : /* try to update and existing watch with the new arg */
624 : 30 : ret = inotify_update_existing_watch(group, inode, arg);
625 : : /* no mark present, try to add a new one */
626 [ + - ]: 30 : if (ret == -ENOENT)
627 : 30 : ret = inotify_new_watch(group, inode, arg);
628 : 30 : mutex_unlock(&group->mark_mutex);
629 : :
630 : 30 : return ret;
631 : : }
632 : :
633 : 0 : static struct fsnotify_group *inotify_new_group(unsigned int max_events)
634 : : {
635 : : struct fsnotify_group *group;
636 : : struct inotify_event_info *oevent;
637 : :
638 : 8 : group = fsnotify_alloc_group(&inotify_fsnotify_ops);
639 [ + - ]: 8 : if (IS_ERR(group))
640 : : return group;
641 : :
642 : : oevent = kmalloc(sizeof(struct inotify_event_info), GFP_KERNEL);
643 [ - + ]: 8 : if (unlikely(!oevent)) {
644 : 0 : fsnotify_destroy_group(group);
645 : 0 : return ERR_PTR(-ENOMEM);
646 : : }
647 : 8 : group->overflow_event = &oevent->fse;
648 : 8 : fsnotify_init_event(group->overflow_event, NULL, FS_Q_OVERFLOW);
649 : 8 : oevent->wd = -1;
650 : 8 : oevent->sync_cookie = 0;
651 : 8 : oevent->name_len = 0;
652 : :
653 : 8 : group->max_events = max_events;
654 : :
655 : 8 : spin_lock_init(&group->inotify_data.idr_lock);
656 : 8 : idr_init(&group->inotify_data.idr);
657 : 16 : group->inotify_data.user = get_current_user();
658 : :
659 [ - + ]: 8 : if (atomic_inc_return(&group->inotify_data.user->inotify_devs) >
660 : : inotify_max_user_instances) {
661 : 0 : fsnotify_destroy_group(group);
662 : 0 : return ERR_PTR(-EMFILE);
663 : : }
664 : :
665 : : return group;
666 : : }
667 : :
668 : :
669 : : /* inotify syscalls */
670 : 0 : SYSCALL_DEFINE1(inotify_init1, int, flags)
671 : : {
672 : : struct fsnotify_group *group;
673 : : int ret;
674 : :
675 : : /* Check the IN_* constants for consistency. */
676 : : BUILD_BUG_ON(IN_CLOEXEC != O_CLOEXEC);
677 : : BUILD_BUG_ON(IN_NONBLOCK != O_NONBLOCK);
678 : :
679 [ + - ]: 8 : if (flags & ~(IN_CLOEXEC | IN_NONBLOCK))
680 : : return -EINVAL;
681 : :
682 : : /* fsnotify_obtain_group took a reference to group, we put this when we kill the file in the end */
683 : 8 : group = inotify_new_group(inotify_max_queued_events);
684 [ - + ]: 8 : if (IS_ERR(group))
685 : : return PTR_ERR(group);
686 : :
687 : 8 : ret = anon_inode_getfd("inotify", &inotify_fops, group,
688 : : O_RDONLY | flags);
689 [ - + ]: 8 : if (ret < 0)
690 : 0 : fsnotify_destroy_group(group);
691 : :
692 : : return ret;
693 : : }
694 : :
695 : 0 : SYSCALL_DEFINE0(inotify_init)
696 : : {
697 : 4 : return sys_inotify_init1(0);
698 : : }
699 : :
700 : 0 : SYSCALL_DEFINE3(inotify_add_watch, int, fd, const char __user *, pathname,
701 : : u32, mask)
702 : : {
703 : : struct fsnotify_group *group;
704 : : struct inode *inode;
705 : : struct path path;
706 : : struct fd f;
707 : : int ret;
708 : : unsigned flags = 0;
709 : :
710 : : /* don't allow invalid bits: we don't want flags set */
711 [ + - ]: 30 : if (unlikely(!(mask & ALL_INOTIFY_BITS)))
712 : : return -EINVAL;
713 : :
714 : 30 : f = fdget(fd);
715 [ + - ]: 30 : if (unlikely(!f.file))
716 : : return -EBADF;
717 : :
718 : : /* verify that this is indeed an inotify instance */
719 [ + - ]: 30 : if (unlikely(f.file->f_op != &inotify_fops)) {
720 : : ret = -EINVAL;
721 : : goto fput_and_out;
722 : : }
723 : :
724 [ + - ]: 30 : if (!(mask & IN_DONT_FOLLOW))
725 : : flags |= LOOKUP_FOLLOW;
726 [ - + ]: 30 : if (mask & IN_ONLYDIR)
727 : 0 : flags |= LOOKUP_DIRECTORY;
728 : :
729 : 30 : ret = inotify_find_inode(pathname, &path, flags);
730 [ + - ]: 30 : if (ret)
731 : : goto fput_and_out;
732 : :
733 : : /* inode held in place by reference to path; group by fget on fd */
734 : 30 : inode = path.dentry->d_inode;
735 : 30 : group = f.file->private_data;
736 : :
737 : : /* create/update an inode mark */
738 : 30 : ret = inotify_update_watch(group, inode, mask);
739 : 30 : path_put(&path);
740 : : fput_and_out:
741 : : fdput(f);
742 : : return ret;
743 : : }
744 : :
745 : 0 : SYSCALL_DEFINE2(inotify_rm_watch, int, fd, __s32, wd)
746 : : {
747 : : struct fsnotify_group *group;
748 : : struct inotify_inode_mark *i_mark;
749 : : struct fd f;
750 : : int ret = 0;
751 : :
752 : 28 : f = fdget(fd);
753 [ + - ]: 28 : if (unlikely(!f.file))
754 : : return -EBADF;
755 : :
756 : : /* verify that this is indeed an inotify instance */
757 : : ret = -EINVAL;
758 [ + - ]: 28 : if (unlikely(f.file->f_op != &inotify_fops))
759 : : goto out;
760 : :
761 : 28 : group = f.file->private_data;
762 : :
763 : : ret = -EINVAL;
764 : 28 : i_mark = inotify_idr_find(group, wd);
765 [ + + ]: 28 : if (unlikely(!i_mark))
766 : : goto out;
767 : :
768 : : ret = 0;
769 : :
770 : 27 : fsnotify_destroy_mark(&i_mark->fsn_mark, group);
771 : :
772 : : /* match ref taken by inotify_idr_find */
773 : 27 : fsnotify_put_mark(&i_mark->fsn_mark);
774 : :
775 : : out:
776 : : fdput(f);
777 : : return ret;
778 : : }
779 : :
780 : : /*
781 : : * inotify_user_setup - Our initialization function. Note that we cannot return
782 : : * error because we have compiled-in VFS hooks. So an (unlikely) failure here
783 : : * must result in panic().
784 : : */
785 : 0 : static int __init inotify_user_setup(void)
786 : : {
787 : : BUILD_BUG_ON(IN_ACCESS != FS_ACCESS);
788 : : BUILD_BUG_ON(IN_MODIFY != FS_MODIFY);
789 : : BUILD_BUG_ON(IN_ATTRIB != FS_ATTRIB);
790 : : BUILD_BUG_ON(IN_CLOSE_WRITE != FS_CLOSE_WRITE);
791 : : BUILD_BUG_ON(IN_CLOSE_NOWRITE != FS_CLOSE_NOWRITE);
792 : : BUILD_BUG_ON(IN_OPEN != FS_OPEN);
793 : : BUILD_BUG_ON(IN_MOVED_FROM != FS_MOVED_FROM);
794 : : BUILD_BUG_ON(IN_MOVED_TO != FS_MOVED_TO);
795 : : BUILD_BUG_ON(IN_CREATE != FS_CREATE);
796 : : BUILD_BUG_ON(IN_DELETE != FS_DELETE);
797 : : BUILD_BUG_ON(IN_DELETE_SELF != FS_DELETE_SELF);
798 : : BUILD_BUG_ON(IN_MOVE_SELF != FS_MOVE_SELF);
799 : : BUILD_BUG_ON(IN_UNMOUNT != FS_UNMOUNT);
800 : : BUILD_BUG_ON(IN_Q_OVERFLOW != FS_Q_OVERFLOW);
801 : : BUILD_BUG_ON(IN_IGNORED != FS_IN_IGNORED);
802 : : BUILD_BUG_ON(IN_EXCL_UNLINK != FS_EXCL_UNLINK);
803 : : BUILD_BUG_ON(IN_ISDIR != FS_ISDIR);
804 : : BUILD_BUG_ON(IN_ONESHOT != FS_IN_ONESHOT);
805 : :
806 : : BUG_ON(hweight32(ALL_INOTIFY_BITS) != 21);
807 : :
808 : 0 : inotify_inode_mark_cachep = KMEM_CACHE(inotify_inode_mark, SLAB_PANIC);
809 : :
810 : 0 : inotify_max_queued_events = 16384;
811 : 0 : inotify_max_user_instances = 128;
812 : 0 : inotify_max_user_watches = 8192;
813 : :
814 : 0 : return 0;
815 : : }
816 : : module_init(inotify_user_setup);
|
