1 #include <linux/fanotify.h> 2 #include <linux/fcntl.h> 3 #include <linux/file.h> 4 #include <linux/fs.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/slab.h> 14 #include <linux/types.h> 15 #include <linux/uaccess.h> 16 17 #include <asm/ioctls.h> 18 19 #define FANOTIFY_DEFAULT_MAX_EVENTS 16384 20 #define FANOTIFY_DEFAULT_MAX_MARKS 8192 21 #define FANOTIFY_DEFAULT_MAX_LISTENERS 128 22 23 extern const struct fsnotify_ops fanotify_fsnotify_ops; 24 25 static struct kmem_cache *fanotify_mark_cache __read_mostly; 26 static struct kmem_cache *fanotify_response_event_cache __read_mostly; 27 28 struct fanotify_response_event { 29 struct list_head list; 30 __s32 fd; 31 struct fsnotify_event *event; 32 }; 33 34 /* 35 * Get an fsnotify notification event if one exists and is small 36 * enough to fit in "count". Return an error pointer if the count 37 * is not large enough. 38 * 39 * Called with the group->notification_mutex held. 40 */ 41 static struct fsnotify_event *get_one_event(struct fsnotify_group *group, 42 size_t count) 43 { 44 BUG_ON(!mutex_is_locked(&group->notification_mutex)); 45 46 pr_debug("%s: group=%p count=%zd\n", __func__, group, count); 47 48 if (fsnotify_notify_queue_is_empty(group)) 49 return NULL; 50 51 if (FAN_EVENT_METADATA_LEN > count) 52 return ERR_PTR(-EINVAL); 53 54 /* held the notification_mutex the whole time, so this is the 55 * same event we peeked above */ 56 return fsnotify_remove_notify_event(group); 57 } 58 59 static int create_fd(struct fsnotify_group *group, struct fsnotify_event *event) 60 { 61 int client_fd; 62 struct dentry *dentry; 63 struct vfsmount *mnt; 64 struct file *new_file; 65 66 pr_debug("%s: group=%p event=%p\n", __func__, group, event); 67 68 client_fd = get_unused_fd(); 69 if (client_fd < 0) 70 return client_fd; 71 72 if (event->data_type != FSNOTIFY_EVENT_PATH) { 73 WARN_ON(1); 74 put_unused_fd(client_fd); 75 return -EINVAL; 76 } 77 78 /* 79 * we need a new file handle for the userspace program so it can read even if it was 80 * originally opened O_WRONLY. 81 */ 82 dentry = dget(event->path.dentry); 83 mnt = mntget(event->path.mnt); 84 /* it's possible this event was an overflow event. in that case dentry and mnt 85 * are NULL; That's fine, just don't call dentry open */ 86 if (dentry && mnt) 87 new_file = dentry_open(dentry, mnt, 88 group->fanotify_data.f_flags | FMODE_NONOTIFY, 89 current_cred()); 90 else 91 new_file = ERR_PTR(-EOVERFLOW); 92 if (IS_ERR(new_file)) { 93 /* 94 * we still send an event even if we can't open the file. this 95 * can happen when say tasks are gone and we try to open their 96 * /proc files or we try to open a WRONLY file like in sysfs 97 * we just send the errno to userspace since there isn't much 98 * else we can do. 99 */ 100 put_unused_fd(client_fd); 101 client_fd = PTR_ERR(new_file); 102 } else { 103 fd_install(client_fd, new_file); 104 } 105 106 return client_fd; 107 } 108 109 static int fill_event_metadata(struct fsnotify_group *group, 110 struct fanotify_event_metadata *metadata, 111 struct fsnotify_event *event) 112 { 113 int ret = 0; 114 115 pr_debug("%s: group=%p metadata=%p event=%p\n", __func__, 116 group, metadata, event); 117 118 metadata->event_len = FAN_EVENT_METADATA_LEN; 119 metadata->metadata_len = FAN_EVENT_METADATA_LEN; 120 metadata->vers = FANOTIFY_METADATA_VERSION; 121 metadata->mask = event->mask & FAN_ALL_OUTGOING_EVENTS; 122 metadata->pid = pid_vnr(event->tgid); 123 if (unlikely(event->mask & FAN_Q_OVERFLOW)) 124 metadata->fd = FAN_NOFD; 125 else { 126 metadata->fd = create_fd(group, event); 127 if (metadata->fd < 0) 128 ret = metadata->fd; 129 } 130 131 return ret; 132 } 133 134 #ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS 135 static struct fanotify_response_event *dequeue_re(struct fsnotify_group *group, 136 __s32 fd) 137 { 138 struct fanotify_response_event *re, *return_re = NULL; 139 140 mutex_lock(&group->fanotify_data.access_mutex); 141 list_for_each_entry(re, &group->fanotify_data.access_list, list) { 142 if (re->fd != fd) 143 continue; 144 145 list_del_init(&re->list); 146 return_re = re; 147 break; 148 } 149 mutex_unlock(&group->fanotify_data.access_mutex); 150 151 pr_debug("%s: found return_re=%p\n", __func__, return_re); 152 153 return return_re; 154 } 155 156 static int process_access_response(struct fsnotify_group *group, 157 struct fanotify_response *response_struct) 158 { 159 struct fanotify_response_event *re; 160 __s32 fd = response_struct->fd; 161 __u32 response = response_struct->response; 162 163 pr_debug("%s: group=%p fd=%d response=%d\n", __func__, group, 164 fd, response); 165 /* 166 * make sure the response is valid, if invalid we do nothing and either 167 * userspace can send a valid responce or we will clean it up after the 168 * timeout 169 */ 170 switch (response) { 171 case FAN_ALLOW: 172 case FAN_DENY: 173 break; 174 default: 175 return -EINVAL; 176 } 177 178 if (fd < 0) 179 return -EINVAL; 180 181 re = dequeue_re(group, fd); 182 if (!re) 183 return -ENOENT; 184 185 re->event->response = response; 186 187 wake_up(&group->fanotify_data.access_waitq); 188 189 kmem_cache_free(fanotify_response_event_cache, re); 190 191 return 0; 192 } 193 194 static int prepare_for_access_response(struct fsnotify_group *group, 195 struct fsnotify_event *event, 196 __s32 fd) 197 { 198 struct fanotify_response_event *re; 199 200 if (!(event->mask & FAN_ALL_PERM_EVENTS)) 201 return 0; 202 203 re = kmem_cache_alloc(fanotify_response_event_cache, GFP_KERNEL); 204 if (!re) 205 return -ENOMEM; 206 207 re->event = event; 208 re->fd = fd; 209 210 mutex_lock(&group->fanotify_data.access_mutex); 211 212 if (atomic_read(&group->fanotify_data.bypass_perm)) { 213 mutex_unlock(&group->fanotify_data.access_mutex); 214 kmem_cache_free(fanotify_response_event_cache, re); 215 event->response = FAN_ALLOW; 216 return 0; 217 } 218 219 list_add_tail(&re->list, &group->fanotify_data.access_list); 220 mutex_unlock(&group->fanotify_data.access_mutex); 221 222 return 0; 223 } 224 225 static void remove_access_response(struct fsnotify_group *group, 226 struct fsnotify_event *event, 227 __s32 fd) 228 { 229 struct fanotify_response_event *re; 230 231 if (!(event->mask & FAN_ALL_PERM_EVENTS)) 232 return; 233 234 re = dequeue_re(group, fd); 235 if (!re) 236 return; 237 238 BUG_ON(re->event != event); 239 240 kmem_cache_free(fanotify_response_event_cache, re); 241 242 return; 243 } 244 #else 245 static int prepare_for_access_response(struct fsnotify_group *group, 246 struct fsnotify_event *event, 247 __s32 fd) 248 { 249 return 0; 250 } 251 252 static void remove_access_response(struct fsnotify_group *group, 253 struct fsnotify_event *event, 254 __s32 fd) 255 { 256 return; 257 } 258 #endif 259 260 static ssize_t copy_event_to_user(struct fsnotify_group *group, 261 struct fsnotify_event *event, 262 char __user *buf) 263 { 264 struct fanotify_event_metadata fanotify_event_metadata; 265 int fd, ret; 266 267 pr_debug("%s: group=%p event=%p\n", __func__, group, event); 268 269 ret = fill_event_metadata(group, &fanotify_event_metadata, event); 270 if (ret < 0) 271 goto out; 272 273 fd = fanotify_event_metadata.fd; 274 ret = prepare_for_access_response(group, event, fd); 275 if (ret) 276 goto out_close_fd; 277 278 ret = -EFAULT; 279 if (copy_to_user(buf, &fanotify_event_metadata, 280 fanotify_event_metadata.event_len)) 281 goto out_kill_access_response; 282 283 return fanotify_event_metadata.event_len; 284 285 out_kill_access_response: 286 remove_access_response(group, event, fd); 287 out_close_fd: 288 if (fd != FAN_NOFD) 289 sys_close(fd); 290 out: 291 #ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS 292 if (event->mask & FAN_ALL_PERM_EVENTS) { 293 event->response = FAN_DENY; 294 wake_up(&group->fanotify_data.access_waitq); 295 } 296 #endif 297 return ret; 298 } 299 300 /* intofiy userspace file descriptor functions */ 301 static unsigned int fanotify_poll(struct file *file, poll_table *wait) 302 { 303 struct fsnotify_group *group = file->private_data; 304 int ret = 0; 305 306 poll_wait(file, &group->notification_waitq, wait); 307 mutex_lock(&group->notification_mutex); 308 if (!fsnotify_notify_queue_is_empty(group)) 309 ret = POLLIN | POLLRDNORM; 310 mutex_unlock(&group->notification_mutex); 311 312 return ret; 313 } 314 315 static ssize_t fanotify_read(struct file *file, char __user *buf, 316 size_t count, loff_t *pos) 317 { 318 struct fsnotify_group *group; 319 struct fsnotify_event *kevent; 320 char __user *start; 321 int ret; 322 DEFINE_WAIT(wait); 323 324 start = buf; 325 group = file->private_data; 326 327 pr_debug("%s: group=%p\n", __func__, group); 328 329 while (1) { 330 prepare_to_wait(&group->notification_waitq, &wait, TASK_INTERRUPTIBLE); 331 332 mutex_lock(&group->notification_mutex); 333 kevent = get_one_event(group, count); 334 mutex_unlock(&group->notification_mutex); 335 336 if (kevent) { 337 ret = PTR_ERR(kevent); 338 if (IS_ERR(kevent)) 339 break; 340 ret = copy_event_to_user(group, kevent, buf); 341 fsnotify_put_event(kevent); 342 if (ret < 0) 343 break; 344 buf += ret; 345 count -= ret; 346 continue; 347 } 348 349 ret = -EAGAIN; 350 if (file->f_flags & O_NONBLOCK) 351 break; 352 ret = -ERESTARTSYS; 353 if (signal_pending(current)) 354 break; 355 356 if (start != buf) 357 break; 358 359 schedule(); 360 } 361 362 finish_wait(&group->notification_waitq, &wait); 363 if (start != buf && ret != -EFAULT) 364 ret = buf - start; 365 return ret; 366 } 367 368 static ssize_t fanotify_write(struct file *file, const char __user *buf, size_t count, loff_t *pos) 369 { 370 #ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS 371 struct fanotify_response response = { .fd = -1, .response = -1 }; 372 struct fsnotify_group *group; 373 int ret; 374 375 group = file->private_data; 376 377 if (count > sizeof(response)) 378 count = sizeof(response); 379 380 pr_debug("%s: group=%p count=%zu\n", __func__, group, count); 381 382 if (copy_from_user(&response, buf, count)) 383 return -EFAULT; 384 385 ret = process_access_response(group, &response); 386 if (ret < 0) 387 count = ret; 388 389 return count; 390 #else 391 return -EINVAL; 392 #endif 393 } 394 395 static int fanotify_release(struct inode *ignored, struct file *file) 396 { 397 struct fsnotify_group *group = file->private_data; 398 399 #ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS 400 struct fanotify_response_event *re, *lre; 401 402 mutex_lock(&group->fanotify_data.access_mutex); 403 404 atomic_inc(&group->fanotify_data.bypass_perm); 405 406 list_for_each_entry_safe(re, lre, &group->fanotify_data.access_list, list) { 407 pr_debug("%s: found group=%p re=%p event=%p\n", __func__, group, 408 re, re->event); 409 410 list_del_init(&re->list); 411 re->event->response = FAN_ALLOW; 412 413 kmem_cache_free(fanotify_response_event_cache, re); 414 } 415 mutex_unlock(&group->fanotify_data.access_mutex); 416 417 wake_up(&group->fanotify_data.access_waitq); 418 #endif 419 /* matches the fanotify_init->fsnotify_alloc_group */ 420 fsnotify_put_group(group); 421 422 return 0; 423 } 424 425 static long fanotify_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 426 { 427 struct fsnotify_group *group; 428 struct fsnotify_event_holder *holder; 429 void __user *p; 430 int ret = -ENOTTY; 431 size_t send_len = 0; 432 433 group = file->private_data; 434 435 p = (void __user *) arg; 436 437 switch (cmd) { 438 case FIONREAD: 439 mutex_lock(&group->notification_mutex); 440 list_for_each_entry(holder, &group->notification_list, event_list) 441 send_len += FAN_EVENT_METADATA_LEN; 442 mutex_unlock(&group->notification_mutex); 443 ret = put_user(send_len, (int __user *) p); 444 break; 445 } 446 447 return ret; 448 } 449 450 static const struct file_operations fanotify_fops = { 451 .poll = fanotify_poll, 452 .read = fanotify_read, 453 .write = fanotify_write, 454 .fasync = NULL, 455 .release = fanotify_release, 456 .unlocked_ioctl = fanotify_ioctl, 457 .compat_ioctl = fanotify_ioctl, 458 .llseek = noop_llseek, 459 }; 460 461 static void fanotify_free_mark(struct fsnotify_mark *fsn_mark) 462 { 463 kmem_cache_free(fanotify_mark_cache, fsn_mark); 464 } 465 466 static int fanotify_find_path(int dfd, const char __user *filename, 467 struct path *path, unsigned int flags) 468 { 469 int ret; 470 471 pr_debug("%s: dfd=%d filename=%p flags=%x\n", __func__, 472 dfd, filename, flags); 473 474 if (filename == NULL) { 475 struct file *file; 476 int fput_needed; 477 478 ret = -EBADF; 479 file = fget_light(dfd, &fput_needed); 480 if (!file) 481 goto out; 482 483 ret = -ENOTDIR; 484 if ((flags & FAN_MARK_ONLYDIR) && 485 !(S_ISDIR(file->f_path.dentry->d_inode->i_mode))) { 486 fput_light(file, fput_needed); 487 goto out; 488 } 489 490 *path = file->f_path; 491 path_get(path); 492 fput_light(file, fput_needed); 493 } else { 494 unsigned int lookup_flags = 0; 495 496 if (!(flags & FAN_MARK_DONT_FOLLOW)) 497 lookup_flags |= LOOKUP_FOLLOW; 498 if (flags & FAN_MARK_ONLYDIR) 499 lookup_flags |= LOOKUP_DIRECTORY; 500 501 ret = user_path_at(dfd, filename, lookup_flags, path); 502 if (ret) 503 goto out; 504 } 505 506 /* you can only watch an inode if you have read permissions on it */ 507 ret = inode_permission(path->dentry->d_inode, MAY_READ); 508 if (ret) 509 path_put(path); 510 out: 511 return ret; 512 } 513 514 static __u32 fanotify_mark_remove_from_mask(struct fsnotify_mark *fsn_mark, 515 __u32 mask, 516 unsigned int flags) 517 { 518 __u32 oldmask; 519 520 spin_lock(&fsn_mark->lock); 521 if (!(flags & FAN_MARK_IGNORED_MASK)) { 522 oldmask = fsn_mark->mask; 523 fsnotify_set_mark_mask_locked(fsn_mark, (oldmask & ~mask)); 524 } else { 525 oldmask = fsn_mark->ignored_mask; 526 fsnotify_set_mark_ignored_mask_locked(fsn_mark, (oldmask & ~mask)); 527 } 528 spin_unlock(&fsn_mark->lock); 529 530 if (!(oldmask & ~mask)) 531 fsnotify_destroy_mark(fsn_mark); 532 533 return mask & oldmask; 534 } 535 536 static int fanotify_remove_vfsmount_mark(struct fsnotify_group *group, 537 struct vfsmount *mnt, __u32 mask, 538 unsigned int flags) 539 { 540 struct fsnotify_mark *fsn_mark = NULL; 541 __u32 removed; 542 543 fsn_mark = fsnotify_find_vfsmount_mark(group, mnt); 544 if (!fsn_mark) 545 return -ENOENT; 546 547 removed = fanotify_mark_remove_from_mask(fsn_mark, mask, flags); 548 fsnotify_put_mark(fsn_mark); 549 if (removed & mnt->mnt_fsnotify_mask) 550 fsnotify_recalc_vfsmount_mask(mnt); 551 552 return 0; 553 } 554 555 static int fanotify_remove_inode_mark(struct fsnotify_group *group, 556 struct inode *inode, __u32 mask, 557 unsigned int flags) 558 { 559 struct fsnotify_mark *fsn_mark = NULL; 560 __u32 removed; 561 562 fsn_mark = fsnotify_find_inode_mark(group, inode); 563 if (!fsn_mark) 564 return -ENOENT; 565 566 removed = fanotify_mark_remove_from_mask(fsn_mark, mask, flags); 567 /* matches the fsnotify_find_inode_mark() */ 568 fsnotify_put_mark(fsn_mark); 569 if (removed & inode->i_fsnotify_mask) 570 fsnotify_recalc_inode_mask(inode); 571 572 return 0; 573 } 574 575 static __u32 fanotify_mark_add_to_mask(struct fsnotify_mark *fsn_mark, 576 __u32 mask, 577 unsigned int flags) 578 { 579 __u32 oldmask = -1; 580 581 spin_lock(&fsn_mark->lock); 582 if (!(flags & FAN_MARK_IGNORED_MASK)) { 583 oldmask = fsn_mark->mask; 584 fsnotify_set_mark_mask_locked(fsn_mark, (oldmask | mask)); 585 } else { 586 __u32 tmask = fsn_mark->ignored_mask | mask; 587 fsnotify_set_mark_ignored_mask_locked(fsn_mark, tmask); 588 if (flags & FAN_MARK_IGNORED_SURV_MODIFY) 589 fsn_mark->flags |= FSNOTIFY_MARK_FLAG_IGNORED_SURV_MODIFY; 590 } 591 592 if (!(flags & FAN_MARK_ONDIR)) { 593 __u32 tmask = fsn_mark->ignored_mask | FAN_ONDIR; 594 fsnotify_set_mark_ignored_mask_locked(fsn_mark, tmask); 595 } 596 597 spin_unlock(&fsn_mark->lock); 598 599 return mask & ~oldmask; 600 } 601 602 static int fanotify_add_vfsmount_mark(struct fsnotify_group *group, 603 struct vfsmount *mnt, __u32 mask, 604 unsigned int flags) 605 { 606 struct fsnotify_mark *fsn_mark; 607 __u32 added; 608 int ret = 0; 609 610 fsn_mark = fsnotify_find_vfsmount_mark(group, mnt); 611 if (!fsn_mark) { 612 if (atomic_read(&group->num_marks) > group->fanotify_data.max_marks) 613 return -ENOSPC; 614 615 fsn_mark = kmem_cache_alloc(fanotify_mark_cache, GFP_KERNEL); 616 if (!fsn_mark) 617 return -ENOMEM; 618 619 fsnotify_init_mark(fsn_mark, fanotify_free_mark); 620 ret = fsnotify_add_mark(fsn_mark, group, NULL, mnt, 0); 621 if (ret) 622 goto err; 623 } 624 added = fanotify_mark_add_to_mask(fsn_mark, mask, flags); 625 626 if (added & ~mnt->mnt_fsnotify_mask) 627 fsnotify_recalc_vfsmount_mask(mnt); 628 err: 629 fsnotify_put_mark(fsn_mark); 630 return ret; 631 } 632 633 static int fanotify_add_inode_mark(struct fsnotify_group *group, 634 struct inode *inode, __u32 mask, 635 unsigned int flags) 636 { 637 struct fsnotify_mark *fsn_mark; 638 __u32 added; 639 int ret = 0; 640 641 pr_debug("%s: group=%p inode=%p\n", __func__, group, inode); 642 643 /* 644 * If some other task has this inode open for write we should not add 645 * an ignored mark, unless that ignored mark is supposed to survive 646 * modification changes anyway. 647 */ 648 if ((flags & FAN_MARK_IGNORED_MASK) && 649 !(flags & FAN_MARK_IGNORED_SURV_MODIFY) && 650 (atomic_read(&inode->i_writecount) > 0)) 651 return 0; 652 653 fsn_mark = fsnotify_find_inode_mark(group, inode); 654 if (!fsn_mark) { 655 if (atomic_read(&group->num_marks) > group->fanotify_data.max_marks) 656 return -ENOSPC; 657 658 fsn_mark = kmem_cache_alloc(fanotify_mark_cache, GFP_KERNEL); 659 if (!fsn_mark) 660 return -ENOMEM; 661 662 fsnotify_init_mark(fsn_mark, fanotify_free_mark); 663 ret = fsnotify_add_mark(fsn_mark, group, inode, NULL, 0); 664 if (ret) 665 goto err; 666 } 667 added = fanotify_mark_add_to_mask(fsn_mark, mask, flags); 668 669 if (added & ~inode->i_fsnotify_mask) 670 fsnotify_recalc_inode_mask(inode); 671 err: 672 fsnotify_put_mark(fsn_mark); 673 return ret; 674 } 675 676 /* fanotify syscalls */ 677 SYSCALL_DEFINE2(fanotify_init, unsigned int, flags, unsigned int, event_f_flags) 678 { 679 struct fsnotify_group *group; 680 int f_flags, fd; 681 struct user_struct *user; 682 683 pr_debug("%s: flags=%d event_f_flags=%d\n", 684 __func__, flags, event_f_flags); 685 686 if (!capable(CAP_SYS_ADMIN)) 687 return -EPERM; 688 689 if (flags & ~FAN_ALL_INIT_FLAGS) 690 return -EINVAL; 691 692 user = get_current_user(); 693 if (atomic_read(&user->fanotify_listeners) > FANOTIFY_DEFAULT_MAX_LISTENERS) { 694 free_uid(user); 695 return -EMFILE; 696 } 697 698 f_flags = O_RDWR | FMODE_NONOTIFY; 699 if (flags & FAN_CLOEXEC) 700 f_flags |= O_CLOEXEC; 701 if (flags & FAN_NONBLOCK) 702 f_flags |= O_NONBLOCK; 703 704 /* fsnotify_alloc_group takes a ref. Dropped in fanotify_release */ 705 group = fsnotify_alloc_group(&fanotify_fsnotify_ops); 706 if (IS_ERR(group)) { 707 free_uid(user); 708 return PTR_ERR(group); 709 } 710 711 group->fanotify_data.user = user; 712 atomic_inc(&user->fanotify_listeners); 713 714 group->fanotify_data.f_flags = event_f_flags; 715 #ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS 716 mutex_init(&group->fanotify_data.access_mutex); 717 init_waitqueue_head(&group->fanotify_data.access_waitq); 718 INIT_LIST_HEAD(&group->fanotify_data.access_list); 719 atomic_set(&group->fanotify_data.bypass_perm, 0); 720 #endif 721 switch (flags & FAN_ALL_CLASS_BITS) { 722 case FAN_CLASS_NOTIF: 723 group->priority = FS_PRIO_0; 724 break; 725 case FAN_CLASS_CONTENT: 726 group->priority = FS_PRIO_1; 727 break; 728 case FAN_CLASS_PRE_CONTENT: 729 group->priority = FS_PRIO_2; 730 break; 731 default: 732 fd = -EINVAL; 733 goto out_put_group; 734 } 735 736 if (flags & FAN_UNLIMITED_QUEUE) { 737 fd = -EPERM; 738 if (!capable(CAP_SYS_ADMIN)) 739 goto out_put_group; 740 group->max_events = UINT_MAX; 741 } else { 742 group->max_events = FANOTIFY_DEFAULT_MAX_EVENTS; 743 } 744 745 if (flags & FAN_UNLIMITED_MARKS) { 746 fd = -EPERM; 747 if (!capable(CAP_SYS_ADMIN)) 748 goto out_put_group; 749 group->fanotify_data.max_marks = UINT_MAX; 750 } else { 751 group->fanotify_data.max_marks = FANOTIFY_DEFAULT_MAX_MARKS; 752 } 753 754 fd = anon_inode_getfd("[fanotify]", &fanotify_fops, group, f_flags); 755 if (fd < 0) 756 goto out_put_group; 757 758 return fd; 759 760 out_put_group: 761 fsnotify_put_group(group); 762 return fd; 763 } 764 765 SYSCALL_DEFINE(fanotify_mark)(int fanotify_fd, unsigned int flags, 766 __u64 mask, int dfd, 767 const char __user * pathname) 768 { 769 struct inode *inode = NULL; 770 struct vfsmount *mnt = NULL; 771 struct fsnotify_group *group; 772 struct file *filp; 773 struct path path; 774 int ret, fput_needed; 775 776 pr_debug("%s: fanotify_fd=%d flags=%x dfd=%d pathname=%p mask=%llx\n", 777 __func__, fanotify_fd, flags, dfd, pathname, mask); 778 779 /* we only use the lower 32 bits as of right now. */ 780 if (mask & ((__u64)0xffffffff << 32)) 781 return -EINVAL; 782 783 if (flags & ~FAN_ALL_MARK_FLAGS) 784 return -EINVAL; 785 switch (flags & (FAN_MARK_ADD | FAN_MARK_REMOVE | FAN_MARK_FLUSH)) { 786 case FAN_MARK_ADD: /* fallthrough */ 787 case FAN_MARK_REMOVE: 788 if (!mask) 789 return -EINVAL; 790 case FAN_MARK_FLUSH: 791 break; 792 default: 793 return -EINVAL; 794 } 795 796 if (mask & FAN_ONDIR) { 797 flags |= FAN_MARK_ONDIR; 798 mask &= ~FAN_ONDIR; 799 } 800 801 #ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS 802 if (mask & ~(FAN_ALL_EVENTS | FAN_ALL_PERM_EVENTS | FAN_EVENT_ON_CHILD)) 803 #else 804 if (mask & ~(FAN_ALL_EVENTS | FAN_EVENT_ON_CHILD)) 805 #endif 806 return -EINVAL; 807 808 filp = fget_light(fanotify_fd, &fput_needed); 809 if (unlikely(!filp)) 810 return -EBADF; 811 812 /* verify that this is indeed an fanotify instance */ 813 ret = -EINVAL; 814 if (unlikely(filp->f_op != &fanotify_fops)) 815 goto fput_and_out; 816 group = filp->private_data; 817 818 /* 819 * group->priority == FS_PRIO_0 == FAN_CLASS_NOTIF. These are not 820 * allowed to set permissions events. 821 */ 822 ret = -EINVAL; 823 if (mask & FAN_ALL_PERM_EVENTS && 824 group->priority == FS_PRIO_0) 825 goto fput_and_out; 826 827 ret = fanotify_find_path(dfd, pathname, &path, flags); 828 if (ret) 829 goto fput_and_out; 830 831 /* inode held in place by reference to path; group by fget on fd */ 832 if (!(flags & FAN_MARK_MOUNT)) 833 inode = path.dentry->d_inode; 834 else 835 mnt = path.mnt; 836 837 /* create/update an inode mark */ 838 switch (flags & (FAN_MARK_ADD | FAN_MARK_REMOVE | FAN_MARK_FLUSH)) { 839 case FAN_MARK_ADD: 840 if (flags & FAN_MARK_MOUNT) 841 ret = fanotify_add_vfsmount_mark(group, mnt, mask, flags); 842 else 843 ret = fanotify_add_inode_mark(group, inode, mask, flags); 844 break; 845 case FAN_MARK_REMOVE: 846 if (flags & FAN_MARK_MOUNT) 847 ret = fanotify_remove_vfsmount_mark(group, mnt, mask, flags); 848 else 849 ret = fanotify_remove_inode_mark(group, inode, mask, flags); 850 break; 851 case FAN_MARK_FLUSH: 852 if (flags & FAN_MARK_MOUNT) 853 fsnotify_clear_vfsmount_marks_by_group(group); 854 else 855 fsnotify_clear_inode_marks_by_group(group); 856 break; 857 default: 858 ret = -EINVAL; 859 } 860 861 path_put(&path); 862 fput_and_out: 863 fput_light(filp, fput_needed); 864 return ret; 865 } 866 867 #ifdef CONFIG_HAVE_SYSCALL_WRAPPERS 868 asmlinkage long SyS_fanotify_mark(long fanotify_fd, long flags, __u64 mask, 869 long dfd, long pathname) 870 { 871 return SYSC_fanotify_mark((int) fanotify_fd, (unsigned int) flags, 872 mask, (int) dfd, 873 (const char __user *) pathname); 874 } 875 SYSCALL_ALIAS(sys_fanotify_mark, SyS_fanotify_mark); 876 #endif 877 878 /* 879 * fanotify_user_setup - Our initialization function. Note that we cannnot return 880 * error because we have compiled-in VFS hooks. So an (unlikely) failure here 881 * must result in panic(). 882 */ 883 static int __init fanotify_user_setup(void) 884 { 885 fanotify_mark_cache = KMEM_CACHE(fsnotify_mark, SLAB_PANIC); 886 fanotify_response_event_cache = KMEM_CACHE(fanotify_response_event, 887 SLAB_PANIC); 888 889 return 0; 890 } 891 device_initcall(fanotify_user_setup); 892