From: Linus Torvalds <torvalds@linux-foundation.org>
Date: Fri, 21 Dec 2012 04:11:52 +0000 (-0800)
Subject: Merge branch 'for-next' of git://git.infradead.org/users/eparis/notify
X-Git-Tag: v3.8-rc1~11
X-Git-Url: https://git.kernelconcepts.de/?p=karo-tx-linux.git;a=commitdiff_plain;h=96680d2b9174668100824d763382240c71baa811

Merge branch 'for-next' of git://git.infradead.org/users/eparis/notify

Pull filesystem notification updates from Eric Paris:
 "This pull mostly is about locking changes in the fsnotify system.  By
  switching the group lock from a spin_lock() to a mutex() we can now
  hold the lock across things like iput().  This fixes a problem
  involving unmounting a fs and having inodes be busy, first pointed out
  by FAT, but reproducible with tmpfs.

  This also restores signal driven I/O for inotify, which has been
  broken since about 2.6.32."

Ugh.  I *hate* the timing of this.  It was rebased after the merge
window opened, and then left to sit with the pull request coming the day
before the merge window closes.  That's just crap.  But apparently the
patches themselves have been around for over a year, just gathering
dust, so now it's suddenly critical.

Fixed up semantic conflict in fs/notify/fdinfo.c as per Stephen
Rothwell's fixes from -next.

* 'for-next' of git://git.infradead.org/users/eparis/notify:
  inotify: automatically restart syscalls
  inotify: dont skip removal of watch descriptor if creation of ignored event failed
  fanotify: dont merge permission events
  fsnotify: make fasync generic for both inotify and fanotify
  fsnotify: change locking order
  fsnotify: dont put marks on temporary list when clearing marks by group
  fsnotify: introduce locked versions of fsnotify_add_mark() and fsnotify_remove_mark()
  fsnotify: pass group to fsnotify_destroy_mark()
  fsnotify: use a mutex instead of a spinlock to protect a groups mark list
  fanotify: add an extra flag to mark_remove_from_mask that indicates wheather a mark should be destroyed
  fsnotify: take groups mark_lock before mark lock
  fsnotify: use reference counting for groups
  fsnotify: introduce fsnotify_get_group()
  inotify, fanotify: replace fsnotify_put_group() with fsnotify_destroy_group()
---

96680d2b9174668100824d763382240c71baa811
diff --cc fs/notify/fdinfo.c
index 514c4b81483d,000000000000..238a5930cb3c
mode 100644,000000..100644
--- a/fs/notify/fdinfo.c
+++ b/fs/notify/fdinfo.c
@@@ -1,179 -1,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;
 +
- 	spin_lock(&group->mark_lock);
++	mutex_lock(&group->mark_mutex);
 +	list_for_each_entry(mark, &group->marks_list, g_list) {
 +		ret = show(m, mark);
 +		if (ret)
 +			break;
 +	}
- 	spin_unlock(&group->mark_lock);
++	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 --cc fs/notify/inotify/inotify_user.c
index 36cb013c7c13,463e828f1f31..228a2c2ad8d7
--- a/fs/notify/inotify/inotify_user.c
+++ b/fs/notify/inotify/inotify_user.c
@@@ -336,10 -329,9 +330,10 @@@ static long inotify_ioctl(struct file *
  }
  
  static const struct file_operations inotify_fops = {
 +	.show_fdinfo	= inotify_show_fdinfo,
  	.poll		= inotify_poll,
  	.read		= inotify_read,
- 	.fasync		= inotify_fasync,
+ 	.fasync		= fsnotify_fasync,
  	.release	= inotify_release,
  	.unlocked_ioctl	= inotify_ioctl,
  	.compat_ioctl	= inotify_ioctl,