]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - fs/notify/fanotify/fanotify_user.c
fsnotify: Remove fsnotify_recalc_{inode|vfsmount}_mask()
[mirror_ubuntu-artful-kernel.git] / fs / notify / fanotify / fanotify_user.c
CommitLineData
33d3dfff 1#include <linux/fanotify.h>
11637e4b 2#include <linux/fcntl.h>
2a3edf86 3#include <linux/file.h>
11637e4b 4#include <linux/fs.h>
52c923dd 5#include <linux/anon_inodes.h>
11637e4b 6#include <linux/fsnotify_backend.h>
2a3edf86 7#include <linux/init.h>
a1014f10 8#include <linux/mount.h>
2a3edf86 9#include <linux/namei.h>
a1014f10 10#include <linux/poll.h>
11637e4b
EP
11#include <linux/security.h>
12#include <linux/syscalls.h>
e4e047a2 13#include <linux/slab.h>
2a3edf86 14#include <linux/types.h>
a1014f10 15#include <linux/uaccess.h>
91c2e0bc 16#include <linux/compat.h>
174cd4b1 17#include <linux/sched/signal.h>
a1014f10
EP
18
19#include <asm/ioctls.h>
11637e4b 20
c63181e6 21#include "../../mount.h"
be77196b 22#include "../fdinfo.h"
7053aee2 23#include "fanotify.h"
c63181e6 24
2529a0df 25#define FANOTIFY_DEFAULT_MAX_EVENTS 16384
e7099d8a 26#define FANOTIFY_DEFAULT_MAX_MARKS 8192
4afeff85 27#define FANOTIFY_DEFAULT_MAX_LISTENERS 128
2529a0df 28
48149e9d
HS
29/*
30 * All flags that may be specified in parameter event_f_flags of fanotify_init.
31 *
32 * Internal and external open flags are stored together in field f_flags of
33 * struct file. Only external open flags shall be allowed in event_f_flags.
34 * Internal flags like FMODE_NONOTIFY, FMODE_EXEC, FMODE_NOCMTIME shall be
35 * excluded.
36 */
37#define FANOTIFY_INIT_ALL_EVENT_F_BITS ( \
38 O_ACCMODE | O_APPEND | O_NONBLOCK | \
39 __O_SYNC | O_DSYNC | O_CLOEXEC | \
40 O_LARGEFILE | O_NOATIME )
41
33d3dfff 42extern const struct fsnotify_ops fanotify_fsnotify_ops;
11637e4b 43
2a3edf86 44static struct kmem_cache *fanotify_mark_cache __read_mostly;
7053aee2 45struct kmem_cache *fanotify_event_cachep __read_mostly;
f083441b 46struct kmem_cache *fanotify_perm_event_cachep __read_mostly;
2a3edf86 47
a1014f10
EP
48/*
49 * Get an fsnotify notification event if one exists and is small
50 * enough to fit in "count". Return an error pointer if the count
51 * is not large enough.
52 *
c21dbe20 53 * Called with the group->notification_lock held.
a1014f10
EP
54 */
55static struct fsnotify_event *get_one_event(struct fsnotify_group *group,
56 size_t count)
57{
ed272640 58 assert_spin_locked(&group->notification_lock);
a1014f10
EP
59
60 pr_debug("%s: group=%p count=%zd\n", __func__, group, count);
61
62 if (fsnotify_notify_queue_is_empty(group))
63 return NULL;
64
65 if (FAN_EVENT_METADATA_LEN > count)
66 return ERR_PTR(-EINVAL);
67
c21dbe20 68 /* held the notification_lock the whole time, so this is the
a1014f10 69 * same event we peeked above */
8ba8fa91 70 return fsnotify_remove_first_event(group);
a1014f10
EP
71}
72
352e3b24 73static int create_fd(struct fsnotify_group *group,
7053aee2
JK
74 struct fanotify_event_info *event,
75 struct file **file)
a1014f10
EP
76{
77 int client_fd;
a1014f10
EP
78 struct file *new_file;
79
22aa425d 80 pr_debug("%s: group=%p event=%p\n", __func__, group, event);
a1014f10 81
0b37e097 82 client_fd = get_unused_fd_flags(group->fanotify_data.f_flags);
a1014f10
EP
83 if (client_fd < 0)
84 return client_fd;
85
a1014f10
EP
86 /*
87 * we need a new file handle for the userspace program so it can read even if it was
88 * originally opened O_WRONLY.
89 */
a1014f10
EP
90 /* it's possible this event was an overflow event. in that case dentry and mnt
91 * are NULL; That's fine, just don't call dentry open */
765927b2
AV
92 if (event->path.dentry && event->path.mnt)
93 new_file = dentry_open(&event->path,
80af2588 94 group->fanotify_data.f_flags | FMODE_NONOTIFY,
a1014f10
EP
95 current_cred());
96 else
97 new_file = ERR_PTR(-EOVERFLOW);
98 if (IS_ERR(new_file)) {
99 /*
100 * we still send an event even if we can't open the file. this
101 * can happen when say tasks are gone and we try to open their
102 * /proc files or we try to open a WRONLY file like in sysfs
103 * we just send the errno to userspace since there isn't much
104 * else we can do.
105 */
106 put_unused_fd(client_fd);
107 client_fd = PTR_ERR(new_file);
108 } else {
352e3b24 109 *file = new_file;
a1014f10
EP
110 }
111
22aa425d 112 return client_fd;
a1014f10
EP
113}
114
ecf6f5e7 115static int fill_event_metadata(struct fsnotify_group *group,
7053aee2
JK
116 struct fanotify_event_metadata *metadata,
117 struct fsnotify_event *fsn_event,
118 struct file **file)
a1014f10 119{
fdbf3cee 120 int ret = 0;
7053aee2 121 struct fanotify_event_info *event;
fdbf3cee 122
a1014f10 123 pr_debug("%s: group=%p metadata=%p event=%p\n", __func__,
7053aee2 124 group, metadata, fsn_event);
a1014f10 125
352e3b24 126 *file = NULL;
7053aee2 127 event = container_of(fsn_event, struct fanotify_event_info, fse);
a1014f10 128 metadata->event_len = FAN_EVENT_METADATA_LEN;
7d131623 129 metadata->metadata_len = FAN_EVENT_METADATA_LEN;
a1014f10 130 metadata->vers = FANOTIFY_METADATA_VERSION;
de1e0c40 131 metadata->reserved = 0;
7053aee2 132 metadata->mask = fsn_event->mask & FAN_ALL_OUTGOING_EVENTS;
32c32632 133 metadata->pid = pid_vnr(event->tgid);
7053aee2 134 if (unlikely(fsn_event->mask & FAN_Q_OVERFLOW))
fdbf3cee
LS
135 metadata->fd = FAN_NOFD;
136 else {
352e3b24 137 metadata->fd = create_fd(group, event, file);
fdbf3cee
LS
138 if (metadata->fd < 0)
139 ret = metadata->fd;
140 }
a1014f10 141
fdbf3cee 142 return ret;
a1014f10
EP
143}
144
b2d87909 145#ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS
f083441b
JK
146static struct fanotify_perm_event_info *dequeue_event(
147 struct fsnotify_group *group, int fd)
b2d87909 148{
f083441b 149 struct fanotify_perm_event_info *event, *return_e = NULL;
b2d87909 150
073f6552 151 spin_lock(&group->notification_lock);
f083441b
JK
152 list_for_each_entry(event, &group->fanotify_data.access_list,
153 fae.fse.list) {
154 if (event->fd != fd)
b2d87909
EP
155 continue;
156
f083441b
JK
157 list_del_init(&event->fae.fse.list);
158 return_e = event;
b2d87909
EP
159 break;
160 }
073f6552 161 spin_unlock(&group->notification_lock);
b2d87909 162
f083441b 163 pr_debug("%s: found return_re=%p\n", __func__, return_e);
b2d87909 164
f083441b 165 return return_e;
b2d87909
EP
166}
167
168static int process_access_response(struct fsnotify_group *group,
169 struct fanotify_response *response_struct)
170{
f083441b
JK
171 struct fanotify_perm_event_info *event;
172 int fd = response_struct->fd;
173 int response = response_struct->response;
b2d87909
EP
174
175 pr_debug("%s: group=%p fd=%d response=%d\n", __func__, group,
176 fd, response);
177 /*
178 * make sure the response is valid, if invalid we do nothing and either
25985edc 179 * userspace can send a valid response or we will clean it up after the
b2d87909
EP
180 * timeout
181 */
182 switch (response) {
183 case FAN_ALLOW:
184 case FAN_DENY:
185 break;
186 default:
187 return -EINVAL;
188 }
189
190 if (fd < 0)
191 return -EINVAL;
192
f083441b
JK
193 event = dequeue_event(group, fd);
194 if (!event)
b2d87909
EP
195 return -ENOENT;
196
f083441b 197 event->response = response;
b2d87909
EP
198 wake_up(&group->fanotify_data.access_waitq);
199
b2d87909
EP
200 return 0;
201}
b2d87909
EP
202#endif
203
a1014f10
EP
204static ssize_t copy_event_to_user(struct fsnotify_group *group,
205 struct fsnotify_event *event,
206 char __user *buf)
207{
208 struct fanotify_event_metadata fanotify_event_metadata;
352e3b24 209 struct file *f;
b2d87909 210 int fd, ret;
a1014f10
EP
211
212 pr_debug("%s: group=%p event=%p\n", __func__, group, event);
213
352e3b24 214 ret = fill_event_metadata(group, &fanotify_event_metadata, event, &f);
ecf6f5e7 215 if (ret < 0)
d507816b 216 return ret;
b2d87909 217
fdbf3cee 218 fd = fanotify_event_metadata.fd;
b2d87909 219 ret = -EFAULT;
7d131623
EP
220 if (copy_to_user(buf, &fanotify_event_metadata,
221 fanotify_event_metadata.event_len))
352e3b24
AV
222 goto out_close_fd;
223
f083441b 224#ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS
d507816b
JK
225 if (event->mask & FAN_ALL_PERM_EVENTS)
226 FANOTIFY_PE(event)->fd = fd;
f083441b 227#endif
a1014f10 228
3587b1b0
AV
229 if (fd != FAN_NOFD)
230 fd_install(fd, f);
7d131623 231 return fanotify_event_metadata.event_len;
b2d87909 232
b2d87909 233out_close_fd:
352e3b24
AV
234 if (fd != FAN_NOFD) {
235 put_unused_fd(fd);
236 fput(f);
237 }
b2d87909 238 return ret;
a1014f10
EP
239}
240
241/* intofiy userspace file descriptor functions */
242static unsigned int fanotify_poll(struct file *file, poll_table *wait)
243{
244 struct fsnotify_group *group = file->private_data;
245 int ret = 0;
246
247 poll_wait(file, &group->notification_waitq, wait);
c21dbe20 248 spin_lock(&group->notification_lock);
a1014f10
EP
249 if (!fsnotify_notify_queue_is_empty(group))
250 ret = POLLIN | POLLRDNORM;
c21dbe20 251 spin_unlock(&group->notification_lock);
a1014f10
EP
252
253 return ret;
254}
255
256static ssize_t fanotify_read(struct file *file, char __user *buf,
257 size_t count, loff_t *pos)
258{
259 struct fsnotify_group *group;
260 struct fsnotify_event *kevent;
261 char __user *start;
262 int ret;
536ebe9c 263 DEFINE_WAIT_FUNC(wait, woken_wake_function);
a1014f10
EP
264
265 start = buf;
266 group = file->private_data;
267
268 pr_debug("%s: group=%p\n", __func__, group);
269
536ebe9c 270 add_wait_queue(&group->notification_waitq, &wait);
a1014f10 271 while (1) {
c21dbe20 272 spin_lock(&group->notification_lock);
a1014f10 273 kevent = get_one_event(group, count);
c21dbe20 274 spin_unlock(&group->notification_lock);
a1014f10 275
d8aaab4f 276 if (IS_ERR(kevent)) {
a1014f10 277 ret = PTR_ERR(kevent);
d8aaab4f
JK
278 break;
279 }
280
281 if (!kevent) {
282 ret = -EAGAIN;
283 if (file->f_flags & O_NONBLOCK)
a1014f10 284 break;
d8aaab4f
JK
285
286 ret = -ERESTARTSYS;
287 if (signal_pending(current))
288 break;
289
290 if (start != buf)
a1014f10 291 break;
536ebe9c
PZ
292
293 wait_woken(&wait, TASK_INTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
a1014f10
EP
294 continue;
295 }
296
d8aaab4f
JK
297 ret = copy_event_to_user(group, kevent, buf);
298 /*
299 * Permission events get queued to wait for response. Other
300 * events can be destroyed now.
301 */
d507816b 302 if (!(kevent->mask & FAN_ALL_PERM_EVENTS)) {
d8aaab4f 303 fsnotify_destroy_event(group, kevent);
d507816b
JK
304 if (ret < 0)
305 break;
306 } else {
307#ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS
308 if (ret < 0) {
309 FANOTIFY_PE(kevent)->response = FAN_DENY;
310 wake_up(&group->fanotify_data.access_waitq);
311 break;
312 }
073f6552 313 spin_lock(&group->notification_lock);
d507816b
JK
314 list_add_tail(&kevent->list,
315 &group->fanotify_data.access_list);
073f6552 316 spin_unlock(&group->notification_lock);
d507816b
JK
317#endif
318 }
d8aaab4f
JK
319 buf += ret;
320 count -= ret;
a1014f10 321 }
536ebe9c 322 remove_wait_queue(&group->notification_waitq, &wait);
a1014f10 323
a1014f10
EP
324 if (start != buf && ret != -EFAULT)
325 ret = buf - start;
326 return ret;
327}
328
b2d87909
EP
329static ssize_t fanotify_write(struct file *file, const char __user *buf, size_t count, loff_t *pos)
330{
331#ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS
332 struct fanotify_response response = { .fd = -1, .response = -1 };
333 struct fsnotify_group *group;
334 int ret;
335
336 group = file->private_data;
337
338 if (count > sizeof(response))
339 count = sizeof(response);
340
341 pr_debug("%s: group=%p count=%zu\n", __func__, group, count);
342
343 if (copy_from_user(&response, buf, count))
344 return -EFAULT;
345
346 ret = process_access_response(group, &response);
347 if (ret < 0)
348 count = ret;
349
350 return count;
351#else
352 return -EINVAL;
353#endif
354}
355
52c923dd
EP
356static int fanotify_release(struct inode *ignored, struct file *file)
357{
358 struct fsnotify_group *group = file->private_data;
52c923dd 359
2eebf582 360#ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS
f083441b 361 struct fanotify_perm_event_info *event, *next;
96d41019 362 struct fsnotify_event *fsn_event;
19ba54f4 363
5838d444 364 /*
96d41019
JK
365 * Stop new events from arriving in the notification queue. since
366 * userspace cannot use fanotify fd anymore, no event can enter or
367 * leave access_list by now either.
5838d444 368 */
96d41019 369 fsnotify_group_stop_queueing(group);
2eebf582 370
96d41019
JK
371 /*
372 * Process all permission events on access_list and notification queue
373 * and simulate reply from userspace.
374 */
073f6552 375 spin_lock(&group->notification_lock);
f083441b
JK
376 list_for_each_entry_safe(event, next, &group->fanotify_data.access_list,
377 fae.fse.list) {
378 pr_debug("%s: found group=%p event=%p\n", __func__, group,
379 event);
2eebf582 380
f083441b
JK
381 list_del_init(&event->fae.fse.list);
382 event->response = FAN_ALLOW;
2eebf582 383 }
2eebf582 384
5838d444 385 /*
96d41019
JK
386 * Destroy all non-permission events. For permission events just
387 * dequeue them and set the response. They will be freed once the
388 * response is consumed and fanotify_get_response() returns.
5838d444 389 */
96d41019
JK
390 while (!fsnotify_notify_queue_is_empty(group)) {
391 fsn_event = fsnotify_remove_first_event(group);
1404ff3c 392 if (!(fsn_event->mask & FAN_ALL_PERM_EVENTS)) {
c21dbe20 393 spin_unlock(&group->notification_lock);
96d41019 394 fsnotify_destroy_event(group, fsn_event);
c21dbe20 395 spin_lock(&group->notification_lock);
1404ff3c 396 } else
96d41019
JK
397 FANOTIFY_PE(fsn_event)->response = FAN_ALLOW;
398 }
c21dbe20 399 spin_unlock(&group->notification_lock);
96d41019
JK
400
401 /* Response for all permission events it set, wakeup waiters */
2eebf582
EP
402 wake_up(&group->fanotify_data.access_waitq);
403#endif
0a6b6bd5 404
52c923dd 405 /* matches the fanotify_init->fsnotify_alloc_group */
d8153d4d 406 fsnotify_destroy_group(group);
52c923dd
EP
407
408 return 0;
409}
410
a1014f10
EP
411static long fanotify_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
412{
413 struct fsnotify_group *group;
7053aee2 414 struct fsnotify_event *fsn_event;
a1014f10
EP
415 void __user *p;
416 int ret = -ENOTTY;
417 size_t send_len = 0;
418
419 group = file->private_data;
420
421 p = (void __user *) arg;
422
423 switch (cmd) {
424 case FIONREAD:
c21dbe20 425 spin_lock(&group->notification_lock);
7053aee2 426 list_for_each_entry(fsn_event, &group->notification_list, list)
a1014f10 427 send_len += FAN_EVENT_METADATA_LEN;
c21dbe20 428 spin_unlock(&group->notification_lock);
a1014f10
EP
429 ret = put_user(send_len, (int __user *) p);
430 break;
431 }
432
433 return ret;
434}
435
52c923dd 436static const struct file_operations fanotify_fops = {
be77196b 437 .show_fdinfo = fanotify_show_fdinfo,
a1014f10
EP
438 .poll = fanotify_poll,
439 .read = fanotify_read,
b2d87909 440 .write = fanotify_write,
52c923dd
EP
441 .fasync = NULL,
442 .release = fanotify_release,
a1014f10
EP
443 .unlocked_ioctl = fanotify_ioctl,
444 .compat_ioctl = fanotify_ioctl,
6038f373 445 .llseek = noop_llseek,
52c923dd
EP
446};
447
2a3edf86
EP
448static void fanotify_free_mark(struct fsnotify_mark *fsn_mark)
449{
450 kmem_cache_free(fanotify_mark_cache, fsn_mark);
451}
452
453static int fanotify_find_path(int dfd, const char __user *filename,
454 struct path *path, unsigned int flags)
455{
456 int ret;
457
458 pr_debug("%s: dfd=%d filename=%p flags=%x\n", __func__,
459 dfd, filename, flags);
460
461 if (filename == NULL) {
2903ff01 462 struct fd f = fdget(dfd);
2a3edf86
EP
463
464 ret = -EBADF;
2903ff01 465 if (!f.file)
2a3edf86
EP
466 goto out;
467
468 ret = -ENOTDIR;
469 if ((flags & FAN_MARK_ONLYDIR) &&
496ad9aa 470 !(S_ISDIR(file_inode(f.file)->i_mode))) {
2903ff01 471 fdput(f);
2a3edf86
EP
472 goto out;
473 }
474
2903ff01 475 *path = f.file->f_path;
2a3edf86 476 path_get(path);
2903ff01 477 fdput(f);
2a3edf86
EP
478 } else {
479 unsigned int lookup_flags = 0;
480
481 if (!(flags & FAN_MARK_DONT_FOLLOW))
482 lookup_flags |= LOOKUP_FOLLOW;
483 if (flags & FAN_MARK_ONLYDIR)
484 lookup_flags |= LOOKUP_DIRECTORY;
485
486 ret = user_path_at(dfd, filename, lookup_flags, path);
487 if (ret)
488 goto out;
489 }
490
491 /* you can only watch an inode if you have read permissions on it */
492 ret = inode_permission(path->dentry->d_inode, MAY_READ);
493 if (ret)
494 path_put(path);
495out:
496 return ret;
497}
498
b9e4e3bd
EP
499static __u32 fanotify_mark_remove_from_mask(struct fsnotify_mark *fsn_mark,
500 __u32 mask,
6dfbd149
LS
501 unsigned int flags,
502 int *destroy)
088b09b0 503{
d2c1874c 504 __u32 oldmask = 0;
088b09b0
AG
505
506 spin_lock(&fsn_mark->lock);
b9e4e3bd 507 if (!(flags & FAN_MARK_IGNORED_MASK)) {
66ba93c0
LS
508 __u32 tmask = fsn_mark->mask & ~mask;
509
510 if (flags & FAN_MARK_ONDIR)
511 tmask &= ~FAN_ONDIR;
512
b9e4e3bd 513 oldmask = fsn_mark->mask;
66d2b81b 514 fsn_mark->mask = tmask;
b9e4e3bd 515 } else {
d2c1874c 516 __u32 tmask = fsn_mark->ignored_mask & ~mask;
66ba93c0
LS
517 if (flags & FAN_MARK_ONDIR)
518 tmask &= ~FAN_ONDIR;
66d2b81b 519 fsn_mark->ignored_mask = tmask;
b9e4e3bd 520 }
a118449a 521 *destroy = !(fsn_mark->mask | fsn_mark->ignored_mask);
088b09b0
AG
522 spin_unlock(&fsn_mark->lock);
523
088b09b0
AG
524 return mask & oldmask;
525}
526
f3640192 527static int fanotify_remove_vfsmount_mark(struct fsnotify_group *group,
b9e4e3bd
EP
528 struct vfsmount *mnt, __u32 mask,
529 unsigned int flags)
88826276
EP
530{
531 struct fsnotify_mark *fsn_mark = NULL;
088b09b0 532 __u32 removed;
6dfbd149 533 int destroy_mark;
88826276 534
7b18527c 535 mutex_lock(&group->mark_mutex);
f3640192 536 fsn_mark = fsnotify_find_vfsmount_mark(group, mnt);
7b18527c
LS
537 if (!fsn_mark) {
538 mutex_unlock(&group->mark_mutex);
f3640192 539 return -ENOENT;
7b18527c 540 }
88826276 541
6dfbd149
LS
542 removed = fanotify_mark_remove_from_mask(fsn_mark, mask, flags,
543 &destroy_mark);
c9747640 544 if (removed & real_mount(mnt)->mnt_fsnotify_mask)
8920d273 545 fsnotify_recalc_mask(real_mount(mnt)->mnt_fsnotify_marks);
6dfbd149 546 if (destroy_mark)
4712e722 547 fsnotify_detach_mark(fsn_mark);
7b18527c 548 mutex_unlock(&group->mark_mutex);
4712e722
JK
549 if (destroy_mark)
550 fsnotify_free_mark(fsn_mark);
6dfbd149 551
f3640192 552 fsnotify_put_mark(fsn_mark);
f3640192
AG
553 return 0;
554}
2a3edf86 555
f3640192 556static int fanotify_remove_inode_mark(struct fsnotify_group *group,
b9e4e3bd
EP
557 struct inode *inode, __u32 mask,
558 unsigned int flags)
f3640192
AG
559{
560 struct fsnotify_mark *fsn_mark = NULL;
561 __u32 removed;
6dfbd149 562 int destroy_mark;
f3640192 563
7b18527c 564 mutex_lock(&group->mark_mutex);
f3640192 565 fsn_mark = fsnotify_find_inode_mark(group, inode);
7b18527c
LS
566 if (!fsn_mark) {
567 mutex_unlock(&group->mark_mutex);
88826276 568 return -ENOENT;
7b18527c 569 }
88826276 570
6dfbd149
LS
571 removed = fanotify_mark_remove_from_mask(fsn_mark, mask, flags,
572 &destroy_mark);
c9747640 573 if (removed & inode->i_fsnotify_mask)
8920d273 574 fsnotify_recalc_mask(inode->i_fsnotify_marks);
6dfbd149 575 if (destroy_mark)
4712e722 576 fsnotify_detach_mark(fsn_mark);
7b18527c 577 mutex_unlock(&group->mark_mutex);
4712e722
JK
578 if (destroy_mark)
579 fsnotify_free_mark(fsn_mark);
7b18527c 580
5444e298 581 /* matches the fsnotify_find_inode_mark() */
2a3edf86 582 fsnotify_put_mark(fsn_mark);
088b09b0 583
2a3edf86
EP
584 return 0;
585}
586
b9e4e3bd
EP
587static __u32 fanotify_mark_add_to_mask(struct fsnotify_mark *fsn_mark,
588 __u32 mask,
589 unsigned int flags)
912ee394 590{
192ca4d1 591 __u32 oldmask = -1;
912ee394
AG
592
593 spin_lock(&fsn_mark->lock);
b9e4e3bd 594 if (!(flags & FAN_MARK_IGNORED_MASK)) {
66ba93c0
LS
595 __u32 tmask = fsn_mark->mask | mask;
596
597 if (flags & FAN_MARK_ONDIR)
598 tmask |= FAN_ONDIR;
599
b9e4e3bd 600 oldmask = fsn_mark->mask;
66d2b81b 601 fsn_mark->mask = tmask;
b9e4e3bd 602 } else {
192ca4d1 603 __u32 tmask = fsn_mark->ignored_mask | mask;
66ba93c0
LS
604 if (flags & FAN_MARK_ONDIR)
605 tmask |= FAN_ONDIR;
606
66d2b81b 607 fsn_mark->ignored_mask = tmask;
c9778a98
EP
608 if (flags & FAN_MARK_IGNORED_SURV_MODIFY)
609 fsn_mark->flags |= FSNOTIFY_MARK_FLAG_IGNORED_SURV_MODIFY;
b9e4e3bd 610 }
912ee394
AG
611 spin_unlock(&fsn_mark->lock);
612
613 return mask & ~oldmask;
614}
615
5e9c070c
LS
616static struct fsnotify_mark *fanotify_add_new_mark(struct fsnotify_group *group,
617 struct inode *inode,
618 struct vfsmount *mnt)
619{
620 struct fsnotify_mark *mark;
621 int ret;
622
623 if (atomic_read(&group->num_marks) > group->fanotify_data.max_marks)
624 return ERR_PTR(-ENOSPC);
625
626 mark = kmem_cache_alloc(fanotify_mark_cache, GFP_KERNEL);
627 if (!mark)
628 return ERR_PTR(-ENOMEM);
629
630 fsnotify_init_mark(mark, fanotify_free_mark);
631 ret = fsnotify_add_mark_locked(mark, group, inode, mnt, 0);
632 if (ret) {
633 fsnotify_put_mark(mark);
634 return ERR_PTR(ret);
635 }
636
637 return mark;
638}
639
640
52202dfb 641static int fanotify_add_vfsmount_mark(struct fsnotify_group *group,
b9e4e3bd
EP
642 struct vfsmount *mnt, __u32 mask,
643 unsigned int flags)
2a3edf86
EP
644{
645 struct fsnotify_mark *fsn_mark;
912ee394 646 __u32 added;
2a3edf86 647
7b18527c 648 mutex_lock(&group->mark_mutex);
88826276
EP
649 fsn_mark = fsnotify_find_vfsmount_mark(group, mnt);
650 if (!fsn_mark) {
5e9c070c
LS
651 fsn_mark = fanotify_add_new_mark(group, NULL, mnt);
652 if (IS_ERR(fsn_mark)) {
7b18527c 653 mutex_unlock(&group->mark_mutex);
5e9c070c 654 return PTR_ERR(fsn_mark);
7b18527c 655 }
88826276 656 }
b9e4e3bd 657 added = fanotify_mark_add_to_mask(fsn_mark, mask, flags);
c63181e6 658 if (added & ~real_mount(mnt)->mnt_fsnotify_mask)
8920d273 659 fsnotify_recalc_mask(real_mount(mnt)->mnt_fsnotify_marks);
c9747640 660 mutex_unlock(&group->mark_mutex);
5e9c070c 661
fa218ab9 662 fsnotify_put_mark(fsn_mark);
5e9c070c 663 return 0;
88826276
EP
664}
665
52202dfb 666static int fanotify_add_inode_mark(struct fsnotify_group *group,
b9e4e3bd
EP
667 struct inode *inode, __u32 mask,
668 unsigned int flags)
88826276
EP
669{
670 struct fsnotify_mark *fsn_mark;
912ee394 671 __u32 added;
88826276
EP
672
673 pr_debug("%s: group=%p inode=%p\n", __func__, group, inode);
2a3edf86 674
5322a59f
EP
675 /*
676 * If some other task has this inode open for write we should not add
677 * an ignored mark, unless that ignored mark is supposed to survive
678 * modification changes anyway.
679 */
680 if ((flags & FAN_MARK_IGNORED_MASK) &&
681 !(flags & FAN_MARK_IGNORED_SURV_MODIFY) &&
682 (atomic_read(&inode->i_writecount) > 0))
683 return 0;
684
7b18527c 685 mutex_lock(&group->mark_mutex);
5444e298 686 fsn_mark = fsnotify_find_inode_mark(group, inode);
2a3edf86 687 if (!fsn_mark) {
5e9c070c
LS
688 fsn_mark = fanotify_add_new_mark(group, inode, NULL);
689 if (IS_ERR(fsn_mark)) {
7b18527c 690 mutex_unlock(&group->mark_mutex);
5e9c070c 691 return PTR_ERR(fsn_mark);
7b18527c 692 }
2a3edf86 693 }
b9e4e3bd 694 added = fanotify_mark_add_to_mask(fsn_mark, mask, flags);
43709a28 695 if (added & ~inode->i_fsnotify_mask)
8920d273 696 fsnotify_recalc_mask(inode->i_fsnotify_marks);
c9747640 697 mutex_unlock(&group->mark_mutex);
5e9c070c 698
fa218ab9 699 fsnotify_put_mark(fsn_mark);
5e9c070c 700 return 0;
88826276 701}
2a3edf86 702
52c923dd 703/* fanotify syscalls */
08ae8938 704SYSCALL_DEFINE2(fanotify_init, unsigned int, flags, unsigned int, event_f_flags)
11637e4b 705{
52c923dd
EP
706 struct fsnotify_group *group;
707 int f_flags, fd;
4afeff85 708 struct user_struct *user;
ff57cd58 709 struct fanotify_event_info *oevent;
52c923dd 710
08ae8938
EP
711 pr_debug("%s: flags=%d event_f_flags=%d\n",
712 __func__, flags, event_f_flags);
52c923dd 713
52c923dd 714 if (!capable(CAP_SYS_ADMIN))
a2f13ad0 715 return -EPERM;
52c923dd
EP
716
717 if (flags & ~FAN_ALL_INIT_FLAGS)
718 return -EINVAL;
719
48149e9d
HS
720 if (event_f_flags & ~FANOTIFY_INIT_ALL_EVENT_F_BITS)
721 return -EINVAL;
722
723 switch (event_f_flags & O_ACCMODE) {
724 case O_RDONLY:
725 case O_RDWR:
726 case O_WRONLY:
727 break;
728 default:
729 return -EINVAL;
730 }
731
4afeff85
EP
732 user = get_current_user();
733 if (atomic_read(&user->fanotify_listeners) > FANOTIFY_DEFAULT_MAX_LISTENERS) {
734 free_uid(user);
735 return -EMFILE;
736 }
737
b2d87909 738 f_flags = O_RDWR | FMODE_NONOTIFY;
52c923dd
EP
739 if (flags & FAN_CLOEXEC)
740 f_flags |= O_CLOEXEC;
741 if (flags & FAN_NONBLOCK)
742 f_flags |= O_NONBLOCK;
743
744 /* fsnotify_alloc_group takes a ref. Dropped in fanotify_release */
745 group = fsnotify_alloc_group(&fanotify_fsnotify_ops);
26379198
EP
746 if (IS_ERR(group)) {
747 free_uid(user);
52c923dd 748 return PTR_ERR(group);
26379198 749 }
52c923dd 750
4afeff85
EP
751 group->fanotify_data.user = user;
752 atomic_inc(&user->fanotify_listeners);
753
f083441b 754 oevent = fanotify_alloc_event(NULL, FS_Q_OVERFLOW, NULL);
ff57cd58
JK
755 if (unlikely(!oevent)) {
756 fd = -ENOMEM;
757 goto out_destroy_group;
758 }
759 group->overflow_event = &oevent->fse;
ff57cd58 760
1e2ee49f
WW
761 if (force_o_largefile())
762 event_f_flags |= O_LARGEFILE;
80af2588 763 group->fanotify_data.f_flags = event_f_flags;
9e66e423 764#ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS
9e66e423
EP
765 init_waitqueue_head(&group->fanotify_data.access_waitq);
766 INIT_LIST_HEAD(&group->fanotify_data.access_list);
767#endif
4231a235
EP
768 switch (flags & FAN_ALL_CLASS_BITS) {
769 case FAN_CLASS_NOTIF:
770 group->priority = FS_PRIO_0;
771 break;
772 case FAN_CLASS_CONTENT:
773 group->priority = FS_PRIO_1;
774 break;
775 case FAN_CLASS_PRE_CONTENT:
776 group->priority = FS_PRIO_2;
777 break;
778 default:
779 fd = -EINVAL;
d8153d4d 780 goto out_destroy_group;
4231a235 781 }
cb2d429f 782
5dd03f55
EP
783 if (flags & FAN_UNLIMITED_QUEUE) {
784 fd = -EPERM;
785 if (!capable(CAP_SYS_ADMIN))
d8153d4d 786 goto out_destroy_group;
5dd03f55
EP
787 group->max_events = UINT_MAX;
788 } else {
789 group->max_events = FANOTIFY_DEFAULT_MAX_EVENTS;
790 }
2529a0df 791
ac7e22dc
EP
792 if (flags & FAN_UNLIMITED_MARKS) {
793 fd = -EPERM;
794 if (!capable(CAP_SYS_ADMIN))
d8153d4d 795 goto out_destroy_group;
ac7e22dc
EP
796 group->fanotify_data.max_marks = UINT_MAX;
797 } else {
798 group->fanotify_data.max_marks = FANOTIFY_DEFAULT_MAX_MARKS;
799 }
e7099d8a 800
52c923dd
EP
801 fd = anon_inode_getfd("[fanotify]", &fanotify_fops, group, f_flags);
802 if (fd < 0)
d8153d4d 803 goto out_destroy_group;
52c923dd
EP
804
805 return fd;
806
d8153d4d
LS
807out_destroy_group:
808 fsnotify_destroy_group(group);
52c923dd 809 return fd;
11637e4b 810}
bbaa4168 811
4a0fd5bf
AV
812SYSCALL_DEFINE5(fanotify_mark, int, fanotify_fd, unsigned int, flags,
813 __u64, mask, int, dfd,
814 const char __user *, pathname)
bbaa4168 815{
0ff21db9
EP
816 struct inode *inode = NULL;
817 struct vfsmount *mnt = NULL;
2a3edf86 818 struct fsnotify_group *group;
2903ff01 819 struct fd f;
2a3edf86 820 struct path path;
2903ff01 821 int ret;
2a3edf86
EP
822
823 pr_debug("%s: fanotify_fd=%d flags=%x dfd=%d pathname=%p mask=%llx\n",
824 __func__, fanotify_fd, flags, dfd, pathname, mask);
825
826 /* we only use the lower 32 bits as of right now. */
827 if (mask & ((__u64)0xffffffff << 32))
828 return -EINVAL;
829
88380fe6
AG
830 if (flags & ~FAN_ALL_MARK_FLAGS)
831 return -EINVAL;
4d92604c 832 switch (flags & (FAN_MARK_ADD | FAN_MARK_REMOVE | FAN_MARK_FLUSH)) {
1734dee4 833 case FAN_MARK_ADD: /* fallthrough */
88380fe6 834 case FAN_MARK_REMOVE:
1734dee4
LS
835 if (!mask)
836 return -EINVAL;
cc299a98 837 break;
4d92604c 838 case FAN_MARK_FLUSH:
cc299a98
HS
839 if (flags & ~(FAN_MARK_MOUNT | FAN_MARK_FLUSH))
840 return -EINVAL;
88380fe6
AG
841 break;
842 default:
843 return -EINVAL;
844 }
8fcd6528
EP
845
846 if (mask & FAN_ONDIR) {
847 flags |= FAN_MARK_ONDIR;
848 mask &= ~FAN_ONDIR;
849 }
850
b2d87909
EP
851#ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS
852 if (mask & ~(FAN_ALL_EVENTS | FAN_ALL_PERM_EVENTS | FAN_EVENT_ON_CHILD))
853#else
88380fe6 854 if (mask & ~(FAN_ALL_EVENTS | FAN_EVENT_ON_CHILD))
b2d87909 855#endif
2a3edf86
EP
856 return -EINVAL;
857
2903ff01
AV
858 f = fdget(fanotify_fd);
859 if (unlikely(!f.file))
2a3edf86
EP
860 return -EBADF;
861
862 /* verify that this is indeed an fanotify instance */
863 ret = -EINVAL;
2903ff01 864 if (unlikely(f.file->f_op != &fanotify_fops))
2a3edf86 865 goto fput_and_out;
2903ff01 866 group = f.file->private_data;
4231a235
EP
867
868 /*
869 * group->priority == FS_PRIO_0 == FAN_CLASS_NOTIF. These are not
870 * allowed to set permissions events.
871 */
872 ret = -EINVAL;
873 if (mask & FAN_ALL_PERM_EVENTS &&
874 group->priority == FS_PRIO_0)
875 goto fput_and_out;
2a3edf86 876
0a8dd2db
HS
877 if (flags & FAN_MARK_FLUSH) {
878 ret = 0;
879 if (flags & FAN_MARK_MOUNT)
880 fsnotify_clear_vfsmount_marks_by_group(group);
881 else
882 fsnotify_clear_inode_marks_by_group(group);
883 goto fput_and_out;
884 }
885
2a3edf86
EP
886 ret = fanotify_find_path(dfd, pathname, &path, flags);
887 if (ret)
888 goto fput_and_out;
889
890 /* inode held in place by reference to path; group by fget on fd */
eac8e9e8 891 if (!(flags & FAN_MARK_MOUNT))
0ff21db9
EP
892 inode = path.dentry->d_inode;
893 else
894 mnt = path.mnt;
2a3edf86
EP
895
896 /* create/update an inode mark */
0a8dd2db 897 switch (flags & (FAN_MARK_ADD | FAN_MARK_REMOVE)) {
c6223f46 898 case FAN_MARK_ADD:
eac8e9e8 899 if (flags & FAN_MARK_MOUNT)
b9e4e3bd 900 ret = fanotify_add_vfsmount_mark(group, mnt, mask, flags);
0ff21db9 901 else
b9e4e3bd 902 ret = fanotify_add_inode_mark(group, inode, mask, flags);
c6223f46
AG
903 break;
904 case FAN_MARK_REMOVE:
f3640192 905 if (flags & FAN_MARK_MOUNT)
b9e4e3bd 906 ret = fanotify_remove_vfsmount_mark(group, mnt, mask, flags);
f3640192 907 else
b9e4e3bd 908 ret = fanotify_remove_inode_mark(group, inode, mask, flags);
c6223f46
AG
909 break;
910 default:
911 ret = -EINVAL;
912 }
2a3edf86
EP
913
914 path_put(&path);
915fput_and_out:
2903ff01 916 fdput(f);
2a3edf86
EP
917 return ret;
918}
919
91c2e0bc
AV
920#ifdef CONFIG_COMPAT
921COMPAT_SYSCALL_DEFINE6(fanotify_mark,
922 int, fanotify_fd, unsigned int, flags,
923 __u32, mask0, __u32, mask1, int, dfd,
924 const char __user *, pathname)
925{
926 return sys_fanotify_mark(fanotify_fd, flags,
927#ifdef __BIG_ENDIAN
91c2e0bc 928 ((__u64)mask0 << 32) | mask1,
592f6b84
HC
929#else
930 ((__u64)mask1 << 32) | mask0,
91c2e0bc
AV
931#endif
932 dfd, pathname);
933}
934#endif
935
2a3edf86 936/*
ae0e47f0 937 * fanotify_user_setup - Our initialization function. Note that we cannot return
2a3edf86
EP
938 * error because we have compiled-in VFS hooks. So an (unlikely) failure here
939 * must result in panic().
940 */
941static int __init fanotify_user_setup(void)
942{
943 fanotify_mark_cache = KMEM_CACHE(fsnotify_mark, SLAB_PANIC);
7053aee2 944 fanotify_event_cachep = KMEM_CACHE(fanotify_event_info, SLAB_PANIC);
f083441b
JK
945#ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS
946 fanotify_perm_event_cachep = KMEM_CACHE(fanotify_perm_event_info,
947 SLAB_PANIC);
948#endif
2a3edf86
EP
949
950 return 0;
bbaa4168 951}
2a3edf86 952device_initcall(fanotify_user_setup);