1 #include <linux/fanotify.h>
2 #include <linux/fcntl.h>
3 #include <linux/file.h>
5 #include <linux/anon_inodes.h>
6 #include <linux/fsnotify_backend.h>
7 #include <linux/init.h>
8 #include <linux/mount.h>
9 #include <linux/namei.h>
10 #include <linux/poll.h>
11 #include <linux/security.h>
12 #include <linux/syscalls.h>
13 #include <linux/types.h>
14 #include <linux/uaccess.h>
16 #include <asm/ioctls.h>
18 extern const struct fsnotify_ops fanotify_fsnotify_ops
;
20 static struct kmem_cache
*fanotify_mark_cache __read_mostly
;
23 * Get an fsnotify notification event if one exists and is small
24 * enough to fit in "count". Return an error pointer if the count
25 * is not large enough.
27 * Called with the group->notification_mutex held.
29 static struct fsnotify_event
*get_one_event(struct fsnotify_group
*group
,
32 BUG_ON(!mutex_is_locked(&group
->notification_mutex
));
34 pr_debug("%s: group=%p count=%zd\n", __func__
, group
, count
);
36 if (fsnotify_notify_queue_is_empty(group
))
39 if (FAN_EVENT_METADATA_LEN
> count
)
40 return ERR_PTR(-EINVAL
);
42 /* held the notification_mutex the whole time, so this is the
43 * same event we peeked above */
44 return fsnotify_remove_notify_event(group
);
47 static int create_fd(struct fsnotify_group
*group
, struct fsnotify_event
*event
)
50 struct dentry
*dentry
;
52 struct file
*new_file
;
54 pr_debug("%s: group=%p event=%p\n", __func__
, group
, event
);
56 client_fd
= get_unused_fd();
60 if (event
->data_type
!= FSNOTIFY_EVENT_PATH
) {
62 put_unused_fd(client_fd
);
67 * we need a new file handle for the userspace program so it can read even if it was
68 * originally opened O_WRONLY.
70 dentry
= dget(event
->path
.dentry
);
71 mnt
= mntget(event
->path
.mnt
);
72 /* it's possible this event was an overflow event. in that case dentry and mnt
73 * are NULL; That's fine, just don't call dentry open */
75 new_file
= dentry_open(dentry
, mnt
,
76 O_RDONLY
| O_LARGEFILE
| FMODE_NONOTIFY
,
79 new_file
= ERR_PTR(-EOVERFLOW
);
80 if (IS_ERR(new_file
)) {
82 * we still send an event even if we can't open the file. this
83 * can happen when say tasks are gone and we try to open their
84 * /proc files or we try to open a WRONLY file like in sysfs
85 * we just send the errno to userspace since there isn't much
88 put_unused_fd(client_fd
);
89 client_fd
= PTR_ERR(new_file
);
91 fd_install(client_fd
, new_file
);
97 static ssize_t
fill_event_metadata(struct fsnotify_group
*group
,
98 struct fanotify_event_metadata
*metadata
,
99 struct fsnotify_event
*event
)
101 pr_debug("%s: group=%p metadata=%p event=%p\n", __func__
,
102 group
, metadata
, event
);
104 metadata
->event_len
= FAN_EVENT_METADATA_LEN
;
105 metadata
->vers
= FANOTIFY_METADATA_VERSION
;
106 metadata
->mask
= event
->mask
& FAN_ALL_OUTGOING_EVENTS
;
107 metadata
->pid
= pid_vnr(event
->tgid
);
108 metadata
->fd
= create_fd(group
, event
);
113 static ssize_t
copy_event_to_user(struct fsnotify_group
*group
,
114 struct fsnotify_event
*event
,
117 struct fanotify_event_metadata fanotify_event_metadata
;
120 pr_debug("%s: group=%p event=%p\n", __func__
, group
, event
);
122 ret
= fill_event_metadata(group
, &fanotify_event_metadata
, event
);
126 if (copy_to_user(buf
, &fanotify_event_metadata
, FAN_EVENT_METADATA_LEN
))
129 return FAN_EVENT_METADATA_LEN
;
132 /* intofiy userspace file descriptor functions */
133 static unsigned int fanotify_poll(struct file
*file
, poll_table
*wait
)
135 struct fsnotify_group
*group
= file
->private_data
;
138 poll_wait(file
, &group
->notification_waitq
, wait
);
139 mutex_lock(&group
->notification_mutex
);
140 if (!fsnotify_notify_queue_is_empty(group
))
141 ret
= POLLIN
| POLLRDNORM
;
142 mutex_unlock(&group
->notification_mutex
);
147 static ssize_t
fanotify_read(struct file
*file
, char __user
*buf
,
148 size_t count
, loff_t
*pos
)
150 struct fsnotify_group
*group
;
151 struct fsnotify_event
*kevent
;
157 group
= file
->private_data
;
159 pr_debug("%s: group=%p\n", __func__
, group
);
162 prepare_to_wait(&group
->notification_waitq
, &wait
, TASK_INTERRUPTIBLE
);
164 mutex_lock(&group
->notification_mutex
);
165 kevent
= get_one_event(group
, count
);
166 mutex_unlock(&group
->notification_mutex
);
169 ret
= PTR_ERR(kevent
);
172 ret
= copy_event_to_user(group
, kevent
, buf
);
173 fsnotify_put_event(kevent
);
182 if (file
->f_flags
& O_NONBLOCK
)
185 if (signal_pending(current
))
194 finish_wait(&group
->notification_waitq
, &wait
);
195 if (start
!= buf
&& ret
!= -EFAULT
)
200 static int fanotify_release(struct inode
*ignored
, struct file
*file
)
202 struct fsnotify_group
*group
= file
->private_data
;
204 pr_debug("%s: file=%p group=%p\n", __func__
, file
, group
);
206 /* matches the fanotify_init->fsnotify_alloc_group */
207 fsnotify_put_group(group
);
212 static long fanotify_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
214 struct fsnotify_group
*group
;
215 struct fsnotify_event_holder
*holder
;
220 group
= file
->private_data
;
222 p
= (void __user
*) arg
;
226 mutex_lock(&group
->notification_mutex
);
227 list_for_each_entry(holder
, &group
->notification_list
, event_list
)
228 send_len
+= FAN_EVENT_METADATA_LEN
;
229 mutex_unlock(&group
->notification_mutex
);
230 ret
= put_user(send_len
, (int __user
*) p
);
237 static const struct file_operations fanotify_fops
= {
238 .poll
= fanotify_poll
,
239 .read
= fanotify_read
,
241 .release
= fanotify_release
,
242 .unlocked_ioctl
= fanotify_ioctl
,
243 .compat_ioctl
= fanotify_ioctl
,
246 static void fanotify_free_mark(struct fsnotify_mark
*fsn_mark
)
248 kmem_cache_free(fanotify_mark_cache
, fsn_mark
);
251 static int fanotify_find_path(int dfd
, const char __user
*filename
,
252 struct path
*path
, unsigned int flags
)
256 pr_debug("%s: dfd=%d filename=%p flags=%x\n", __func__
,
257 dfd
, filename
, flags
);
259 if (filename
== NULL
) {
264 file
= fget_light(dfd
, &fput_needed
);
269 if ((flags
& FAN_MARK_ONLYDIR
) &&
270 !(S_ISDIR(file
->f_path
.dentry
->d_inode
->i_mode
))) {
271 fput_light(file
, fput_needed
);
275 *path
= file
->f_path
;
277 fput_light(file
, fput_needed
);
279 unsigned int lookup_flags
= 0;
281 if (!(flags
& FAN_MARK_DONT_FOLLOW
))
282 lookup_flags
|= LOOKUP_FOLLOW
;
283 if (flags
& FAN_MARK_ONLYDIR
)
284 lookup_flags
|= LOOKUP_DIRECTORY
;
286 ret
= user_path_at(dfd
, filename
, lookup_flags
, path
);
291 /* you can only watch an inode if you have read permissions on it */
292 ret
= inode_permission(path
->dentry
->d_inode
, MAY_READ
);
299 static __u32
fanotify_mark_remove_from_mask(struct fsnotify_mark
*fsn_mark
,
305 spin_lock(&fsn_mark
->lock
);
306 if (!(flags
& FAN_MARK_IGNORED_MASK
)) {
307 oldmask
= fsn_mark
->mask
;
308 fsnotify_set_mark_mask_locked(fsn_mark
, (oldmask
& ~mask
));
310 oldmask
= fsn_mark
->ignored_mask
;
311 fsnotify_set_mark_ignored_mask_locked(fsn_mark
, (oldmask
& ~mask
));
313 spin_unlock(&fsn_mark
->lock
);
315 if (!(oldmask
& ~mask
))
316 fsnotify_destroy_mark(fsn_mark
);
318 return mask
& oldmask
;
321 static int fanotify_remove_vfsmount_mark(struct fsnotify_group
*group
,
322 struct vfsmount
*mnt
, __u32 mask
,
325 struct fsnotify_mark
*fsn_mark
= NULL
;
328 fsn_mark
= fsnotify_find_vfsmount_mark(group
, mnt
);
332 removed
= fanotify_mark_remove_from_mask(fsn_mark
, mask
, flags
);
333 fsnotify_put_mark(fsn_mark
);
334 if (removed
& group
->mask
)
335 fsnotify_recalc_group_mask(group
);
336 if (removed
& mnt
->mnt_fsnotify_mask
)
337 fsnotify_recalc_vfsmount_mask(mnt
);
342 static int fanotify_remove_inode_mark(struct fsnotify_group
*group
,
343 struct inode
*inode
, __u32 mask
,
346 struct fsnotify_mark
*fsn_mark
= NULL
;
349 fsn_mark
= fsnotify_find_inode_mark(group
, inode
);
353 removed
= fanotify_mark_remove_from_mask(fsn_mark
, mask
, flags
);
354 /* matches the fsnotify_find_inode_mark() */
355 fsnotify_put_mark(fsn_mark
);
357 if (removed
& group
->mask
)
358 fsnotify_recalc_group_mask(group
);
359 if (removed
& inode
->i_fsnotify_mask
)
360 fsnotify_recalc_inode_mask(inode
);
365 static __u32
fanotify_mark_add_to_mask(struct fsnotify_mark
*fsn_mark
,
371 spin_lock(&fsn_mark
->lock
);
372 if (!(flags
& FAN_MARK_IGNORED_MASK
)) {
373 oldmask
= fsn_mark
->mask
;
374 fsnotify_set_mark_mask_locked(fsn_mark
, (oldmask
| mask
));
376 oldmask
= fsn_mark
->ignored_mask
;
377 fsnotify_set_mark_ignored_mask_locked(fsn_mark
, (oldmask
| mask
));
378 if (flags
& FAN_MARK_IGNORED_SURV_MODIFY
)
379 fsn_mark
->flags
|= FSNOTIFY_MARK_FLAG_IGNORED_SURV_MODIFY
;
381 spin_unlock(&fsn_mark
->lock
);
383 return mask
& ~oldmask
;
386 static int fanotify_add_vfsmount_mark(struct fsnotify_group
*group
,
387 struct vfsmount
*mnt
, __u32 mask
,
390 struct fsnotify_mark
*fsn_mark
;
393 fsn_mark
= fsnotify_find_vfsmount_mark(group
, mnt
);
397 fsn_mark
= kmem_cache_alloc(fanotify_mark_cache
, GFP_KERNEL
);
401 fsnotify_init_mark(fsn_mark
, fanotify_free_mark
);
402 ret
= fsnotify_add_mark(fsn_mark
, group
, NULL
, mnt
, 0);
404 fanotify_free_mark(fsn_mark
);
408 added
= fanotify_mark_add_to_mask(fsn_mark
, mask
, flags
);
409 fsnotify_put_mark(fsn_mark
);
411 if (added
& ~group
->mask
)
412 fsnotify_recalc_group_mask(group
);
413 if (added
& ~mnt
->mnt_fsnotify_mask
)
414 fsnotify_recalc_vfsmount_mask(mnt
);
419 static int fanotify_add_inode_mark(struct fsnotify_group
*group
,
420 struct inode
*inode
, __u32 mask
,
423 struct fsnotify_mark
*fsn_mark
;
426 pr_debug("%s: group=%p inode=%p\n", __func__
, group
, inode
);
428 fsn_mark
= fsnotify_find_inode_mark(group
, inode
);
432 fsn_mark
= kmem_cache_alloc(fanotify_mark_cache
, GFP_KERNEL
);
436 fsnotify_init_mark(fsn_mark
, fanotify_free_mark
);
437 ret
= fsnotify_add_mark(fsn_mark
, group
, inode
, NULL
, 0);
439 fanotify_free_mark(fsn_mark
);
443 added
= fanotify_mark_add_to_mask(fsn_mark
, mask
, flags
);
444 fsnotify_put_mark(fsn_mark
);
446 if (added
& ~group
->mask
)
447 fsnotify_recalc_group_mask(group
);
448 if (added
& ~inode
->i_fsnotify_mask
)
449 fsnotify_recalc_inode_mask(inode
);
454 /* fanotify syscalls */
455 SYSCALL_DEFINE3(fanotify_init
, unsigned int, flags
, unsigned int, event_f_flags
,
456 unsigned int, priority
)
458 struct fsnotify_group
*group
;
461 pr_debug("%s: flags=%d event_f_flags=%d priority=%d\n",
462 __func__
, flags
, event_f_flags
, priority
);
469 if (!capable(CAP_SYS_ADMIN
))
472 if (flags
& ~FAN_ALL_INIT_FLAGS
)
475 f_flags
= (O_RDONLY
| FMODE_NONOTIFY
);
476 if (flags
& FAN_CLOEXEC
)
477 f_flags
|= O_CLOEXEC
;
478 if (flags
& FAN_NONBLOCK
)
479 f_flags
|= O_NONBLOCK
;
481 /* fsnotify_alloc_group takes a ref. Dropped in fanotify_release */
482 group
= fsnotify_alloc_group(&fanotify_fsnotify_ops
);
484 return PTR_ERR(group
);
486 fd
= anon_inode_getfd("[fanotify]", &fanotify_fops
, group
, f_flags
);
493 fsnotify_put_group(group
);
497 SYSCALL_DEFINE(fanotify_mark
)(int fanotify_fd
, unsigned int flags
,
499 const char __user
* pathname
)
501 struct inode
*inode
= NULL
;
502 struct vfsmount
*mnt
= NULL
;
503 struct fsnotify_group
*group
;
506 int ret
, fput_needed
;
508 pr_debug("%s: fanotify_fd=%d flags=%x dfd=%d pathname=%p mask=%llx\n",
509 __func__
, fanotify_fd
, flags
, dfd
, pathname
, mask
);
511 /* we only use the lower 32 bits as of right now. */
512 if (mask
& ((__u64
)0xffffffff << 32))
515 if (flags
& ~FAN_ALL_MARK_FLAGS
)
517 switch (flags
& (FAN_MARK_ADD
| FAN_MARK_REMOVE
| FAN_MARK_FLUSH
)) {
519 case FAN_MARK_REMOVE
:
525 if (mask
& ~(FAN_ALL_EVENTS
| FAN_EVENT_ON_CHILD
))
528 filp
= fget_light(fanotify_fd
, &fput_needed
);
532 /* verify that this is indeed an fanotify instance */
534 if (unlikely(filp
->f_op
!= &fanotify_fops
))
537 ret
= fanotify_find_path(dfd
, pathname
, &path
, flags
);
541 /* inode held in place by reference to path; group by fget on fd */
542 if (!(flags
& FAN_MARK_MOUNT
))
543 inode
= path
.dentry
->d_inode
;
546 group
= filp
->private_data
;
548 /* create/update an inode mark */
549 switch (flags
& (FAN_MARK_ADD
| FAN_MARK_REMOVE
| FAN_MARK_FLUSH
)) {
551 if (flags
& FAN_MARK_MOUNT
)
552 ret
= fanotify_add_vfsmount_mark(group
, mnt
, mask
, flags
);
554 ret
= fanotify_add_inode_mark(group
, inode
, mask
, flags
);
556 case FAN_MARK_REMOVE
:
557 if (flags
& FAN_MARK_MOUNT
)
558 ret
= fanotify_remove_vfsmount_mark(group
, mnt
, mask
, flags
);
560 ret
= fanotify_remove_inode_mark(group
, inode
, mask
, flags
);
563 if (flags
& FAN_MARK_MOUNT
)
564 fsnotify_clear_vfsmount_marks_by_group(group
);
566 fsnotify_clear_inode_marks_by_group(group
);
567 fsnotify_recalc_group_mask(group
);
575 fput_light(filp
, fput_needed
);
579 #ifdef CONFIG_HAVE_SYSCALL_WRAPPERS
580 asmlinkage
long SyS_fanotify_mark(long fanotify_fd
, long flags
, __u64 mask
,
581 long dfd
, long pathname
)
583 return SYSC_fanotify_mark((int) fanotify_fd
, (unsigned int) flags
,
585 (const char __user
*) pathname
);
587 SYSCALL_ALIAS(sys_fanotify_mark
, SyS_fanotify_mark
);
591 * fanotify_user_setup - Our initialization function. Note that we cannnot return
592 * error because we have compiled-in VFS hooks. So an (unlikely) failure here
593 * must result in panic().
595 static int __init
fanotify_user_setup(void)
597 fanotify_mark_cache
= KMEM_CACHE(fsnotify_mark
, SLAB_PANIC
);
601 device_initcall(fanotify_user_setup
);