fs/notify/fanotify/fanotify_user.c

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