9 files changed, 265 insertions, 73 deletions

diff --git a/fs/notify/Makefile b/fs/notify/Makefile
index ae5f33a6d868..96d3420d0242 100644
--- a/fs/notify/Makefile
+++ b/fs/notify/Makefile
@@ -1,5 +1,5 @@
 obj-$(CONFIG_FSNOTIFY)          += fsnotify.o notification.o group.o inode_mark.o \
-                                   mark.o vfsmount_mark.o
+                                   mark.o vfsmount_mark.o fdinfo.o
 
 obj-y                   += dnotify/
 obj-y                   += inotify/
diff --git a/fs/notify/fanotify/Kconfig b/fs/notify/fanotify/Kconfig
index 7dceff005a67..e5f911bd80d2 100644
--- a/fs/notify/fanotify/Kconfig
+++ b/fs/notify/fanotify/Kconfig
@@ -4,7 +4,7 @@ config FANOTIFY
         select ANON_INODES
         default n
         ---help---
-           Say Y here to enable fanotify suport.  fanotify is a file access
+           Say Y here to enable fanotify support.  fanotify is a file access
            notification system which differs from inotify in that it sends
            an open file descriptor to the userspace listener along with
            the event.
diff --git a/fs/notify/fanotify/fanotify.c b/fs/notify/fanotify/fanotify.c
index aeb5b5abbd4f..0c2f9122b262 100644
--- a/fs/notify/fanotify/fanotify.c
+++ b/fs/notify/fanotify/fanotify.c
@@ -27,6 +27,7 @@ static bool should_merge(struct fsnotify_event *old, struct fsnotify_event *new)
                         if ((old->path.mnt == new->path.mnt) &&
                             (old->path.dentry == new->path.dentry))
                                 return true;
+                        break;
                 case (FSNOTIFY_EVENT_NONE):
                         return true;
                 default:
diff --git a/fs/notify/fanotify/fanotify_user.c b/fs/notify/fanotify/fanotify_user.c
index f0e7a57bc899..9ff4a5ee6e20 100644
--- a/fs/notify/fanotify/fanotify_user.c
+++ b/fs/notify/fanotify/fanotify_user.c
@@ -17,6 +17,7 @@
 #include <asm/ioctls.h>
 
 #include "../../mount.h"
+#include "../fdinfo.h"
 
 #define FANOTIFY_DEFAULT_MAX_EVENTS     16384
 #define FANOTIFY_DEFAULT_MAX_MARKS      8192
@@ -58,7 +59,9 @@ static struct fsnotify_event *get_one_event(struct fsnotify_group *group,
         return fsnotify_remove_notify_event(group);
 }
 
-static int create_fd(struct fsnotify_group *group, struct fsnotify_event *event)
+static int create_fd(struct fsnotify_group *group,
+                        struct fsnotify_event *event,
+                        struct file **file)
 {
         int client_fd;
         struct file *new_file;
@@ -98,7 +101,7 @@ static int create_fd(struct fsnotify_group *group, struct fsnotify_event *event)
                 put_unused_fd(client_fd);
                 client_fd = PTR_ERR(new_file);
         } else {
-                fd_install(client_fd, new_file);
+                *file = new_file;
         }
 
         return client_fd;
@@ -106,13 +109,15 @@ static int create_fd(struct fsnotify_group *group, struct fsnotify_event *event)
 
 static int fill_event_metadata(struct fsnotify_group *group,
                                    struct fanotify_event_metadata *metadata,
-                                   struct fsnotify_event *event)
+                                   struct fsnotify_event *event,
+                                   struct file **file)
 {
         int ret = 0;
 
         pr_debug("%s: group=%p metadata=%p event=%p\n", __func__,
                  group, metadata, event);
 
+        *file = NULL;
         metadata->event_len = FAN_EVENT_METADATA_LEN;
         metadata->metadata_len = FAN_EVENT_METADATA_LEN;
         metadata->vers = FANOTIFY_METADATA_VERSION;
@@ -121,7 +126,7 @@ static int fill_event_metadata(struct fsnotify_group *group,
         if (unlikely(event->mask & FAN_Q_OVERFLOW))
                 metadata->fd = FAN_NOFD;
         else {
-                metadata->fd = create_fd(group, event);
+                metadata->fd = create_fd(group, event, file);
                 if (metadata->fd < 0)
                         ret = metadata->fd;
         }
@@ -220,25 +225,6 @@ static int prepare_for_access_response(struct fsnotify_group *group,
         return 0;
 }
 
-static void remove_access_response(struct fsnotify_group *group,
-                                   struct fsnotify_event *event,
-                                   __s32 fd)
-{
-        struct fanotify_response_event *re;
-
-        if (!(event->mask & FAN_ALL_PERM_EVENTS))
-                return;
-
-        re = dequeue_re(group, fd);
-        if (!re)
-                return;
-
-        BUG_ON(re->event != event);
-
-        kmem_cache_free(fanotify_response_event_cache, re);
-
-        return;
-}
 #else
 static int prepare_for_access_response(struct fsnotify_group *group,
                                        struct fsnotify_event *event,
@@ -247,12 +233,6 @@ static int prepare_for_access_response(struct fsnotify_group *group,
         return 0;
 }
 
-static void remove_access_response(struct fsnotify_group *group,
-                                   struct fsnotify_event *event,
-                                   __s32 fd)
-{
-        return;
-}
 #endif
 
 static ssize_t copy_event_to_user(struct fsnotify_group *group,
@@ -260,31 +240,34 @@ static ssize_t copy_event_to_user(struct fsnotify_group *group,
                                   char __user *buf)
 {
         struct fanotify_event_metadata fanotify_event_metadata;
+        struct file *f;
         int fd, ret;
 
         pr_debug("%s: group=%p event=%p\n", __func__, group, event);
 
-        ret = fill_event_metadata(group, &fanotify_event_metadata, event);
+        ret = fill_event_metadata(group, &fanotify_event_metadata, event, &f);
         if (ret < 0)
                 goto out;
 
         fd = fanotify_event_metadata.fd;
-        ret = prepare_for_access_response(group, event, fd);
-        if (ret)
-                goto out_close_fd;
-
         ret = -EFAULT;
         if (copy_to_user(buf, &fanotify_event_metadata,
                          fanotify_event_metadata.event_len))
-                goto out_kill_access_response;
+                goto out_close_fd;
 
+        ret = prepare_for_access_response(group, event, fd);
+        if (ret)
+                goto out_close_fd;
+
+        if (fd != FAN_NOFD)
+                fd_install(fd, f);
         return fanotify_event_metadata.event_len;
 
-out_kill_access_response:
-        remove_access_response(group, event, fd);
 out_close_fd:
-        if (fd != FAN_NOFD)
-                sys_close(fd);
+        if (fd != FAN_NOFD) {
+                put_unused_fd(fd);
+                fput(f);
+        }
 out:
 #ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS
         if (event->mask & FAN_ALL_PERM_EVENTS) {
@@ -450,6 +433,7 @@ static long fanotify_ioctl(struct file *file, unsigned int cmd, unsigned long ar
 }
 
 static const struct file_operations fanotify_fops = {
+        .show_fdinfo    = fanotify_show_fdinfo,
         .poll           = fanotify_poll,
         .read           = fanotify_read,
         .write          = fanotify_write,
@@ -474,24 +458,22 @@ static int fanotify_find_path(int dfd, const char __user *filename,
                  dfd, filename, flags);
 
         if (filename == NULL) {
-                struct file *file;
-                int fput_needed;
+                struct fd f = fdget(dfd);
 
                 ret = -EBADF;
-                file = fget_light(dfd, &fput_needed);
-                if (!file)
+                if (!f.file)
                         goto out;
 
                 ret = -ENOTDIR;
                 if ((flags & FAN_MARK_ONLYDIR) &&
-                    !(S_ISDIR(file->f_path.dentry->d_inode->i_mode))) {
-                        fput_light(file, fput_needed);
+                    !(S_ISDIR(f.file->f_path.dentry->d_inode->i_mode))) {
+                        fdput(f);
                         goto out;
                 }
 
-                *path = file->f_path;
+                *path = f.file->f_path;
                 path_get(path);
-                fput_light(file, fput_needed);
+                fdput(f);
         } else {
                 unsigned int lookup_flags = 0;
 
@@ -780,9 +762,9 @@ SYSCALL_DEFINE(fanotify_mark)(int fanotify_fd, unsigned int flags,
         struct inode *inode = NULL;
         struct vfsmount *mnt = NULL;
         struct fsnotify_group *group;
-        struct file *filp;
+        struct fd f;
         struct path path;
-        int ret, fput_needed;
+        int ret;
 
         pr_debug("%s: fanotify_fd=%d flags=%x dfd=%d pathname=%p mask=%llx\n",
                  __func__, fanotify_fd, flags, dfd, pathname, mask);
@@ -816,15 +798,15 @@ SYSCALL_DEFINE(fanotify_mark)(int fanotify_fd, unsigned int flags,
 #endif
                 return -EINVAL;
 
-        filp = fget_light(fanotify_fd, &fput_needed);
-        if (unlikely(!filp))
+        f = fdget(fanotify_fd);
+        if (unlikely(!f.file))
                 return -EBADF;
 
         /* verify that this is indeed an fanotify instance */
         ret = -EINVAL;
-        if (unlikely(filp->f_op != &fanotify_fops))
+        if (unlikely(f.file->f_op != &fanotify_fops))
                 goto fput_and_out;
-        group = filp->private_data;
+        group = f.file->private_data;
 
         /*
          * group->priority == FS_PRIO_0 == FAN_CLASS_NOTIF.  These are not
@@ -871,7 +853,7 @@ SYSCALL_DEFINE(fanotify_mark)(int fanotify_fd, unsigned int flags,
 
         path_put(&path);
 fput_and_out:
-        fput_light(filp, fput_needed);
+        fdput(f);
         return ret;
 }
 
diff --git a/fs/notify/fdinfo.c b/fs/notify/fdinfo.c
new file mode 100644
index 000000000000..238a5930cb3c
--- /dev/null
+++ b/fs/notify/fdinfo.c
@@ -0,0 +1,179 @@
+#include <linux/file.h>
+#include <linux/fs.h>
+#include <linux/fsnotify_backend.h>
+#include <linux/idr.h>
+#include <linux/init.h>
+#include <linux/inotify.h>
+#include <linux/fanotify.h>
+#include <linux/kernel.h>
+#include <linux/namei.h>
+#include <linux/sched.h>
+#include <linux/types.h>
+#include <linux/seq_file.h>
+#include <linux/proc_fs.h>
+#include <linux/exportfs.h>
+
+#include "inotify/inotify.h"
+#include "../fs/mount.h"
+
+#if defined(CONFIG_PROC_FS)
+
+#if defined(CONFIG_INOTIFY_USER) || defined(CONFIG_FANOTIFY)
+
+static int show_fdinfo(struct seq_file *m, struct file *f,
+                       int (*show)(struct seq_file *m, struct fsnotify_mark *mark))
+{
+        struct fsnotify_group *group = f->private_data;
+        struct fsnotify_mark *mark;
+        int ret = 0;
+
+        mutex_lock(&group->mark_mutex);
+        list_for_each_entry(mark, &group->marks_list, g_list) {
+                ret = show(m, mark);
+                if (ret)
+                        break;
+        }
+        mutex_unlock(&group->mark_mutex);
+        return ret;
+}
+
+#if defined(CONFIG_EXPORTFS)
+static int show_mark_fhandle(struct seq_file *m, struct inode *inode)
+{
+        struct {
+                struct file_handle handle;
+                u8 pad[64];
+        } f;
+        int size, ret, i;
+
+        f.handle.handle_bytes = sizeof(f.pad);
+        size = f.handle.handle_bytes >> 2;
+
+        ret = exportfs_encode_inode_fh(inode, (struct fid *)f.handle.f_handle, &size, 0);
+        if ((ret == 255) || (ret == -ENOSPC)) {
+                WARN_ONCE(1, "Can't encode file handler for inotify: %d\n", ret);
+                return 0;
+        }
+
+        f.handle.handle_type = ret;
+        f.handle.handle_bytes = size * sizeof(u32);
+
+        ret = seq_printf(m, "fhandle-bytes:%x fhandle-type:%x f_handle:",
+                         f.handle.handle_bytes, f.handle.handle_type);
+
+        for (i = 0; i < f.handle.handle_bytes; i++)
+                ret |= seq_printf(m, "%02x", (int)f.handle.f_handle[i]);
+
+        return ret;
+}
+#else
+static int show_mark_fhandle(struct seq_file *m, struct inode *inode)
+{
+        return 0;
+}
+#endif
+
+#ifdef CONFIG_INOTIFY_USER
+
+static int inotify_fdinfo(struct seq_file *m, struct fsnotify_mark *mark)
+{
+        struct inotify_inode_mark *inode_mark;
+        struct inode *inode;
+        int ret = 0;
+
+        if (!(mark->flags & (FSNOTIFY_MARK_FLAG_ALIVE | FSNOTIFY_MARK_FLAG_INODE)))
+                return 0;
+
+        inode_mark = container_of(mark, struct inotify_inode_mark, fsn_mark);
+        inode = igrab(mark->i.inode);
+        if (inode) {
+                ret = seq_printf(m, "inotify wd:%x ino:%lx sdev:%x "
+                                 "mask:%x ignored_mask:%x ",
+                                 inode_mark->wd, inode->i_ino,
+                                 inode->i_sb->s_dev,
+                                 mark->mask, mark->ignored_mask);
+                ret |= show_mark_fhandle(m, inode);
+                ret |= seq_putc(m, '\n');
+                iput(inode);
+        }
+
+        return ret;
+}
+
+int inotify_show_fdinfo(struct seq_file *m, struct file *f)
+{
+        return show_fdinfo(m, f, inotify_fdinfo);
+}
+
+#endif /* CONFIG_INOTIFY_USER */
+
+#ifdef CONFIG_FANOTIFY
+
+static int fanotify_fdinfo(struct seq_file *m, struct fsnotify_mark *mark)
+{
+        unsigned int mflags = 0;
+        struct inode *inode;
+        int ret = 0;
+
+        if (!(mark->flags & FSNOTIFY_MARK_FLAG_ALIVE))
+                return 0;
+
+        if (mark->flags & FSNOTIFY_MARK_FLAG_IGNORED_SURV_MODIFY)
+                mflags |= FAN_MARK_IGNORED_SURV_MODIFY;
+
+        if (mark->flags & FSNOTIFY_MARK_FLAG_INODE) {
+                inode = igrab(mark->i.inode);
+                if (!inode)
+                        goto out;
+                ret = seq_printf(m, "fanotify ino:%lx sdev:%x "
+                                 "mflags:%x mask:%x ignored_mask:%x ",
+                                 inode->i_ino, inode->i_sb->s_dev,
+                                 mflags, mark->mask, mark->ignored_mask);
+                ret |= show_mark_fhandle(m, inode);
+                ret |= seq_putc(m, '\n');
+                iput(inode);
+        } else if (mark->flags & FSNOTIFY_MARK_FLAG_VFSMOUNT) {
+                struct mount *mnt = real_mount(mark->m.mnt);
+
+                ret = seq_printf(m, "fanotify mnt_id:%x mflags:%x mask:%x "
+                                 "ignored_mask:%x\n", mnt->mnt_id, mflags,
+                                 mark->mask, mark->ignored_mask);
+        }
+out:
+        return ret;
+}
+
+int fanotify_show_fdinfo(struct seq_file *m, struct file *f)
+{
+        struct fsnotify_group *group = f->private_data;
+        unsigned int flags = 0;
+
+        switch (group->priority) {
+        case FS_PRIO_0:
+                flags |= FAN_CLASS_NOTIF;
+                break;
+        case FS_PRIO_1:
+                flags |= FAN_CLASS_CONTENT;
+                break;
+        case FS_PRIO_2:
+                flags |= FAN_CLASS_PRE_CONTENT;
+                break;
+        }
+
+        if (group->max_events == UINT_MAX)
+                flags |= FAN_UNLIMITED_QUEUE;
+
+        if (group->fanotify_data.max_marks == UINT_MAX)
+                flags |= FAN_UNLIMITED_MARKS;
+
+        seq_printf(m, "fanotify flags:%x event-flags:%x\n",
+                   flags, group->fanotify_data.f_flags);
+
+        return show_fdinfo(m, f, fanotify_fdinfo);
+}
+
+#endif /* CONFIG_FANOTIFY */
+
+#endif /* CONFIG_INOTIFY_USER || CONFIG_FANOTIFY */
+
+#endif /* CONFIG_PROC_FS */
diff --git a/fs/notify/fdinfo.h b/fs/notify/fdinfo.h
new file mode 100644
index 000000000000..556afda990e9
--- /dev/null
+++ b/fs/notify/fdinfo.h
@@ -0,0 +1,27 @@
+#ifndef __FSNOTIFY_FDINFO_H__
+#define __FSNOTIFY_FDINFO_H__
+
+#include <linux/errno.h>
+#include <linux/proc_fs.h>
+
+struct seq_file;
+struct file;
+
+#ifdef CONFIG_PROC_FS
+
+#ifdef CONFIG_INOTIFY_USER
+extern int inotify_show_fdinfo(struct seq_file *m, struct file *f);
+#endif
+
+#ifdef CONFIG_FANOTIFY
+extern int fanotify_show_fdinfo(struct seq_file *m, struct file *f);
+#endif
+
+#else /* CONFIG_PROC_FS */
+
+#define inotify_show_fdinfo     NULL
+#define fanotify_show_fdinfo    NULL
+
+#endif /* CONFIG_PROC_FS */
+
+#endif /* __FSNOTIFY_FDINFO_H__ */
diff --git a/fs/notify/inode_mark.c b/fs/notify/inode_mark.c
index 21230209c957..f31e90fc050d 100644
--- a/fs/notify/inode_mark.c
+++ b/fs/notify/inode_mark.c
@@ -124,8 +124,9 @@ void fsnotify_clear_inode_marks_by_group(struct fsnotify_group *group)
  * given a group and inode, find the mark associated with that combination.
  * if found take a reference to that mark and return it, else return NULL
  */
-struct fsnotify_mark *fsnotify_find_inode_mark_locked(struct fsnotify_group *group,
-                                                      struct inode *inode)
+static struct fsnotify_mark *fsnotify_find_inode_mark_locked(
+                struct fsnotify_group *group,
+                struct inode *inode)
 {
         struct fsnotify_mark *mark;
         struct hlist_node *pos;
diff --git a/fs/notify/inotify/inotify_user.c b/fs/notify/inotify/inotify_user.c
index 463e828f1f31..228a2c2ad8d7 100644
--- a/fs/notify/inotify/inotify_user.c
+++ b/fs/notify/inotify/inotify_user.c
@@ -40,6 +40,7 @@
 #include <linux/wait.h>
 
 #include "inotify.h"
+#include "../fdinfo.h"
 
 #include <asm/ioctls.h>
 
@@ -329,6 +330,7 @@ static long inotify_ioctl(struct file *file, unsigned int cmd,
 }
 
 static const struct file_operations inotify_fops = {
+        .show_fdinfo    = inotify_show_fdinfo,
         .poll           = inotify_poll,
         .read           = inotify_read,
         .fasync         = fsnotify_fasync,
@@ -751,16 +753,16 @@ SYSCALL_DEFINE3(inotify_add_watch, int, fd, const char __user *, pathname,
         struct fsnotify_group *group;
         struct inode *inode;
         struct path path;
-        struct file *filp;
-        int ret, fput_needed;
+        struct fd f;
+        int ret;
         unsigned flags = 0;
 
-        filp = fget_light(fd, &fput_needed);
-        if (unlikely(!filp))
+        f = fdget(fd);
+        if (unlikely(!f.file))
                 return -EBADF;
 
         /* verify that this is indeed an inotify instance */
-        if (unlikely(filp->f_op != &inotify_fops)) {
+        if (unlikely(f.file->f_op != &inotify_fops)) {
                 ret = -EINVAL;
                 goto fput_and_out;
         }
@@ -776,13 +778,13 @@ SYSCALL_DEFINE3(inotify_add_watch, int, fd, const char __user *, pathname,
 
         /* inode held in place by reference to path; group by fget on fd */
         inode = path.dentry->d_inode;
-        group = filp->private_data;
+        group = f.file->private_data;
 
         /* create/update an inode mark */
         ret = inotify_update_watch(group, inode, mask);
         path_put(&path);
 fput_and_out:
-        fput_light(filp, fput_needed);
+        fdput(f);
         return ret;
 }
 
@@ -790,19 +792,19 @@ SYSCALL_DEFINE2(inotify_rm_watch, int, fd, __s32, wd)
 {
         struct fsnotify_group *group;
         struct inotify_inode_mark *i_mark;
-        struct file *filp;
-        int ret = 0, fput_needed;
+        struct fd f;
+        int ret = 0;
 
-        filp = fget_light(fd, &fput_needed);
-        if (unlikely(!filp))
+        f = fdget(fd);
+        if (unlikely(!f.file))
                 return -EBADF;
 
         /* verify that this is indeed an inotify instance */
         ret = -EINVAL;
-        if (unlikely(filp->f_op != &inotify_fops))
+        if (unlikely(f.file->f_op != &inotify_fops))
                 goto out;
 
-        group = filp->private_data;
+        group = f.file->private_data;
 
         ret = -EINVAL;
         i_mark = inotify_idr_find(group, wd);
@@ -817,7 +819,7 @@ SYSCALL_DEFINE2(inotify_rm_watch, int, fd, __s32, wd)
         fsnotify_put_mark(&i_mark->fsn_mark);
 
 out:
-        fput_light(filp, fput_needed);
+        fdput(f);
         return ret;
 }
 
diff --git a/fs/notify/notification.c b/fs/notify/notification.c
index b3963d8c9988..7b51b05f160c 100644
--- a/fs/notify/notification.c
+++ b/fs/notify/notification.c
@@ -18,7 +18,7 @@
 
 /*
  * Basic idea behind the notification queue: An fsnotify group (like inotify)
- * sends the userspace notification about events asyncronously some time after
+ * sends the userspace notification about events asynchronously some time after
  * the event happened.  When inotify gets an event it will need to add that
  * event to the group notify queue.  Since a single event might need to be on
  * multiple group's notification queues we can't add the event directly to each