Merge tag 'fsnotify_for_v5.1-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/jack/linux-fs (0556161f) · Commits · 戴 / test

fs/notify/fanotify/Kconfig

+1 −0

Original line number	Diff line number	Diff line
		@@ -2,6 +2,7 @@ config FANOTIFY
		bool "Filesystem wide access notification"
		select FSNOTIFY
		select ANON_INODES
		select EXPORTFS
		default n
		---help---
		Say Y here to enable fanotify support. fanotify is a file access

fs/notify/fanotify/fanotify.c

+225 −42

Original line number	Diff line number	Diff line
		@@ -13,22 +13,40 @@
		#include <linux/wait.h>
		#include <linux/audit.h>
		#include <linux/sched/mm.h>
		#include <linux/statfs.h>

		#include "fanotify.h"

		static bool should_merge(struct fsnotify_event *old_fsn,
		struct fsnotify_event *new_fsn)
		{
		struct fanotify_event_info old, new;
		struct fanotify_event old, new;

		pr_debug("%s: old=%p new=%p\n", __func__, old_fsn, new_fsn);
		old = FANOTIFY_E(old_fsn);
		new = FANOTIFY_E(new_fsn);

		if (old_fsn->inode == new_fsn->inode && old->pid == new->pid &&
		old->path.mnt == new->path.mnt &&
		old->path.dentry == new->path.dentry)
		return true;
		if (old_fsn->inode != new_fsn->inode \|\| old->pid != new->pid \|\|
		old->fh_type != new->fh_type \|\| old->fh_len != new->fh_len)
		return false;

		if (fanotify_event_has_path(old)) {
		return old->path.mnt == new->path.mnt &&
		old->path.dentry == new->path.dentry;
		} else if (fanotify_event_has_fid(old)) {
		/*
		* We want to merge many dirent events in the same dir (i.e.
		* creates/unlinks/renames), but we do not want to merge dirent
		* events referring to subdirs with dirent events referring to
		* non subdirs, otherwise, user won't be able to tell from a
		* mask FAN_CREATE\|FAN_DELETE\|FAN_ONDIR if it describes mkdir+
		* unlink pair or rmdir+create pair of events.
		*/
		return (old->mask & FS_ISDIR) == (new->mask & FS_ISDIR) &&
		fanotify_fid_equal(&old->fid, &new->fid, old->fh_len);
		}

		/* Do not merge events if we failed to encode fid */
		return false;
		}

		@@ -36,20 +54,22 @@ static bool should_merge(struct fsnotify_event *old_fsn,
		static int fanotify_merge(struct list_head list, struct fsnotify_event event)
		{
		struct fsnotify_event *test_event;
		struct fanotify_event *new;

		pr_debug("%s: list=%p event=%p\n", __func__, list, event);
		new = FANOTIFY_E(event);

		/*
		* Don't merge a permission event with any other event so that we know
		* the event structure we have created in fanotify_handle_event() is the
		* one we should check for permission response.
		*/
		if (fanotify_is_perm_event(event->mask))
		if (fanotify_is_perm_event(new->mask))
		return 0;

		list_for_each_entry_reverse(test_event, list, list) {
		if (should_merge(test_event, event)) {
		test_event->mask \|= event->mask;
		FANOTIFY_E(test_event)->mask \|= new->mask;
		return 1;
		}
		}
		@@ -57,15 +77,44 @@ static int fanotify_merge(struct list_head list, struct fsnotify_event event)
		return 0;
		}

		/*
		* Wait for response to permission event. The function also takes care of
		* freeing the permission event (or offloads that in case the wait is canceled
		* by a signal). The function returns 0 in case access got allowed by userspace,
		* -EPERM in case userspace disallowed the access, and -ERESTARTSYS in case
		* the wait got interrupted by a signal.
		*/
		static int fanotify_get_response(struct fsnotify_group *group,
		struct fanotify_perm_event_info *event,
		struct fanotify_perm_event *event,
		struct fsnotify_iter_info *iter_info)
		{
		int ret;

		pr_debug("%s: group=%p event=%p\n", __func__, group, event);

		wait_event(group->fanotify_data.access_waitq, event->response);
		ret = wait_event_killable(group->fanotify_data.access_waitq,
		event->state == FAN_EVENT_ANSWERED);
		/* Signal pending? */
		if (ret < 0) {
		spin_lock(&group->notification_lock);
		/* Event reported to userspace and no answer yet? */
		if (event->state == FAN_EVENT_REPORTED) {
		/* Event will get freed once userspace answers to it */
		event->state = FAN_EVENT_CANCELED;
		spin_unlock(&group->notification_lock);
		return ret;
		}
		/* Event not yet reported? Just remove it. */
		if (event->state == FAN_EVENT_INIT)
		fsnotify_remove_queued_event(group, &event->fae.fse);
		/*
		* Event may be also answered in case signal delivery raced
		* with wakeup. In that case we have nothing to do besides
		* freeing the event and reporting error.
		*/
		spin_unlock(&group->notification_lock);
		goto out;
		}

		/* userspace responded, convert to something usable */
		switch (event->response & ~FAN_AUDIT) {
		@@ -81,10 +130,10 @@ static int fanotify_get_response(struct fsnotify_group *group,
		if (event->response & FAN_AUDIT)
		audit_fanotify(event->response & ~FAN_AUDIT);

		event->response = 0;

		pr_debug("%s: group=%p event=%p about to return ret=%d\n", __func__,
		group, event, ret);
		out:
		fsnotify_destroy_event(group, &event->fae.fse);

		return ret;
		}
		@@ -95,11 +144,13 @@ static int fanotify_get_response(struct fsnotify_group *group,
		* been included within the event mask, but have not been explicitly
		* requested by the user, will not be present in the returned mask.
		*/
		static u32 fanotify_group_event_mask(struct fsnotify_iter_info *iter_info,
		static u32 fanotify_group_event_mask(struct fsnotify_group *group,
		struct fsnotify_iter_info *iter_info,
		u32 event_mask, const void *data,
		int data_type)
		{
		__u32 marks_mask = 0, marks_ignored_mask = 0;
		__u32 test_mask, user_mask = FANOTIFY_OUTGOING_EVENTS;
		const struct path *path = data;
		struct fsnotify_mark *mark;
		int type;
		@@ -107,14 +158,14 @@ static u32 fanotify_group_event_mask(struct fsnotify_iter_info *iter_info,
		pr_debug("%s: report_mask=%x mask=%x data=%p data_type=%d\n",
		__func__, iter_info->report_mask, event_mask, data, data_type);

		/* If we don't have enough info to send an event to userspace say no */
		if (!FAN_GROUP_FLAG(group, FAN_REPORT_FID)) {
		/* Do we have path to open a file descriptor? */
		if (data_type != FSNOTIFY_EVENT_PATH)
		return 0;

		/* Sorry, fanotify only gives a damn about files and dirs */
		if (!d_is_reg(path->dentry) &&
		!d_can_lookup(path->dentry))
		/* Path type events are only relevant for files and dirs */
		if (!d_is_reg(path->dentry) && !d_can_lookup(path->dentry))
		return 0;
		}

		fsnotify_foreach_obj_type(type) {
		if (!fsnotify_iter_should_report_type(iter_info, type))
		@@ -133,20 +184,106 @@ static u32 fanotify_group_event_mask(struct fsnotify_iter_info *iter_info,
		marks_ignored_mask \|= mark->ignored_mask;
		}

		if (d_is_dir(path->dentry) &&
		test_mask = event_mask & marks_mask & ~marks_ignored_mask;

		/*
		* dirent modification events (create/delete/move) do not carry the
		* child entry name/inode information. Instead, we report FAN_ONDIR
		* for mkdir/rmdir so user can differentiate them from creat/unlink.
		*
		* For backward compatibility and consistency, do not report FAN_ONDIR
		* to user in legacy fanotify mode (reporting fd) and report FAN_ONDIR
		* to user in FAN_REPORT_FID mode for all event types.
		*/
		if (FAN_GROUP_FLAG(group, FAN_REPORT_FID)) {
		/* Do not report FAN_ONDIR without any event */
		if (!(test_mask & ~FAN_ONDIR))
		return 0;
		} else {
		user_mask &= ~FAN_ONDIR;
		}

		if (event_mask & FS_ISDIR &&
		!(marks_mask & FS_ISDIR & ~marks_ignored_mask))
		return 0;

		return event_mask & FANOTIFY_OUTGOING_EVENTS & marks_mask &
		~marks_ignored_mask;
		return test_mask & user_mask;
		}

		static int fanotify_encode_fid(struct fanotify_event *event,
		struct inode *inode, gfp_t gfp,
		__kernel_fsid_t *fsid)
		{
		struct fanotify_fid *fid = &event->fid;
		int dwords, bytes = 0;
		int err, type;

		fid->ext_fh = NULL;
		dwords = 0;
		err = -ENOENT;
		type = exportfs_encode_inode_fh(inode, NULL, &dwords, NULL);
		if (!dwords)
		goto out_err;

		bytes = dwords << 2;
		if (bytes > FANOTIFY_INLINE_FH_LEN) {
		/* Treat failure to allocate fh as failure to allocate event */
		err = -ENOMEM;
		fid->ext_fh = kmalloc(bytes, gfp);
		if (!fid->ext_fh)
		goto out_err;
		}

		struct fanotify_event_info fanotify_alloc_event(struct fsnotify_group group,
		type = exportfs_encode_inode_fh(inode, fanotify_fid_fh(fid, bytes),
		&dwords, NULL);
		err = -EINVAL;
		if (!type \|\| type == FILEID_INVALID \|\| bytes != dwords << 2)
		goto out_err;

		fid->fsid = *fsid;
		event->fh_len = bytes;

		return type;

		out_err:
		pr_warn_ratelimited("fanotify: failed to encode fid (fsid=%x.%x, "
		"type=%d, bytes=%d, err=%i)\n",
		fsid->val[0], fsid->val[1], type, bytes, err);
		kfree(fid->ext_fh);
		fid->ext_fh = NULL;
		event->fh_len = 0;

		return FILEID_INVALID;
		}

		/*
		* The inode to use as identifier when reporting fid depends on the event.
		* Report the modified directory inode on dirent modification events.
		* Report the "victim" inode otherwise.
		* For example:
		* FS_ATTRIB reports the child inode even if reported on a watched parent.
		* FS_CREATE reports the modified dir inode and not the created inode.
		*/
		static struct inode fanotify_fid_inode(struct inode to_tell, u32 event_mask,
		const void *data, int data_type)
		{
		if (event_mask & ALL_FSNOTIFY_DIRENT_EVENTS)
		return to_tell;
		else if (data_type == FSNOTIFY_EVENT_INODE)
		return (struct inode *)data;
		else if (data_type == FSNOTIFY_EVENT_PATH)
		return d_inode(((struct path *)data)->dentry);
		return NULL;
		}

		struct fanotify_event fanotify_alloc_event(struct fsnotify_group group,
		struct inode *inode, u32 mask,
		const struct path *path)
		const void *data, int data_type,
		__kernel_fsid_t *fsid)
		{
		struct fanotify_event_info *event = NULL;
		struct fanotify_event *event = NULL;
		gfp_t gfp = GFP_KERNEL_ACCOUNT;
		struct inode *id = fanotify_fid_inode(inode, mask, data, data_type);

		/*
		* For queues with unlimited length lost events are not expected and
		@@ -160,28 +297,36 @@ struct fanotify_event_info fanotify_alloc_event(struct fsnotify_group group,
		memalloc_use_memcg(group->memcg);

		if (fanotify_is_perm_event(mask)) {
		struct fanotify_perm_event_info *pevent;
		struct fanotify_perm_event *pevent;

		pevent = kmem_cache_alloc(fanotify_perm_event_cachep, gfp);
		if (!pevent)
		goto out;
		event = &pevent->fae;
		pevent->response = 0;
		pevent->state = FAN_EVENT_INIT;
		goto init;
		}
		event = kmem_cache_alloc(fanotify_event_cachep, gfp);
		if (!event)
		goto out;
		init: __maybe_unused
		fsnotify_init_event(&event->fse, inode, mask);
		fsnotify_init_event(&event->fse, inode);
		event->mask = mask;
		if (FAN_GROUP_FLAG(group, FAN_REPORT_TID))
		event->pid = get_pid(task_pid(current));
		else
		event->pid = get_pid(task_tgid(current));
		if (path) {
		event->path = *path;
		event->fh_len = 0;
		if (id && FAN_GROUP_FLAG(group, FAN_REPORT_FID)) {
		/* Report the event without a file identifier on encode error */
		event->fh_type = fanotify_encode_fid(event, id, gfp, fsid);
		} else if (data_type == FSNOTIFY_EVENT_PATH) {
		event->fh_type = FILEID_ROOT;
		event->path = ((struct path )data);
		path_get(&event->path);
		} else {
		event->fh_type = FILEID_INVALID;
		event->path.mnt = NULL;
		event->path.dentry = NULL;
		}
		@@ -190,6 +335,29 @@ out:
		return event;
		}

		/*
		* Get cached fsid of the filesystem containing the object from any connector.
		* All connectors are supposed to have the same fsid, but we do not verify that
		* here.
		*/
		static __kernel_fsid_t fanotify_get_fsid(struct fsnotify_iter_info *iter_info)
		{
		int type;
		__kernel_fsid_t fsid = {};

		fsnotify_foreach_obj_type(type) {
		if (!fsnotify_iter_should_report_type(iter_info, type))
		continue;

		fsid = iter_info->marks[type]->connector->fsid;
		if (WARN_ON_ONCE(!fsid.val[0] && !fsid.val[1]))
		continue;
		return fsid;
		}

		return fsid;
		}

		static int fanotify_handle_event(struct fsnotify_group *group,
		struct inode *inode,
		u32 mask, const void *data, int data_type,
		@@ -197,14 +365,22 @@ static int fanotify_handle_event(struct fsnotify_group *group,
		struct fsnotify_iter_info *iter_info)
		{
		int ret = 0;
		struct fanotify_event_info *event;
		struct fanotify_event *event;
		struct fsnotify_event *fsn_event;
		__kernel_fsid_t fsid = {};

		BUILD_BUG_ON(FAN_ACCESS != FS_ACCESS);
		BUILD_BUG_ON(FAN_MODIFY != FS_MODIFY);
		BUILD_BUG_ON(FAN_ATTRIB != FS_ATTRIB);
		BUILD_BUG_ON(FAN_CLOSE_NOWRITE != FS_CLOSE_NOWRITE);
		BUILD_BUG_ON(FAN_CLOSE_WRITE != FS_CLOSE_WRITE);
		BUILD_BUG_ON(FAN_OPEN != FS_OPEN);
		BUILD_BUG_ON(FAN_MOVED_TO != FS_MOVED_TO);
		BUILD_BUG_ON(FAN_MOVED_FROM != FS_MOVED_FROM);
		BUILD_BUG_ON(FAN_CREATE != FS_CREATE);
		BUILD_BUG_ON(FAN_DELETE != FS_DELETE);
		BUILD_BUG_ON(FAN_DELETE_SELF != FS_DELETE_SELF);
		BUILD_BUG_ON(FAN_MOVE_SELF != FS_MOVE_SELF);
		BUILD_BUG_ON(FAN_EVENT_ON_CHILD != FS_EVENT_ON_CHILD);
		BUILD_BUG_ON(FAN_Q_OVERFLOW != FS_Q_OVERFLOW);
		BUILD_BUG_ON(FAN_OPEN_PERM != FS_OPEN_PERM);
		@@ -213,9 +389,10 @@ static int fanotify_handle_event(struct fsnotify_group *group,
		BUILD_BUG_ON(FAN_OPEN_EXEC != FS_OPEN_EXEC);
		BUILD_BUG_ON(FAN_OPEN_EXEC_PERM != FS_OPEN_EXEC_PERM);

		BUILD_BUG_ON(HWEIGHT32(ALL_FANOTIFY_EVENT_BITS) != 12);
		BUILD_BUG_ON(HWEIGHT32(ALL_FANOTIFY_EVENT_BITS) != 19);

		mask = fanotify_group_event_mask(iter_info, mask, data, data_type);
		mask = fanotify_group_event_mask(group, iter_info, mask, data,
		data_type);
		if (!mask)
		return 0;

		@@ -231,7 +408,11 @@ static int fanotify_handle_event(struct fsnotify_group *group,
		return 0;
		}

		event = fanotify_alloc_event(group, inode, mask, data);
		if (FAN_GROUP_FLAG(group, FAN_REPORT_FID))
		fsid = fanotify_get_fsid(iter_info);

		event = fanotify_alloc_event(group, inode, mask, data, data_type,
		&fsid);
		ret = -ENOMEM;
		if (unlikely(!event)) {
		/*
		@@ -255,7 +436,6 @@ static int fanotify_handle_event(struct fsnotify_group *group,
		} else if (fanotify_is_perm_event(mask)) {
		ret = fanotify_get_response(group, FANOTIFY_PE(fsn_event),
		iter_info);
		fsnotify_destroy_event(group, fsn_event);
		}
		finish:
		if (fanotify_is_perm_event(mask))
		@@ -275,12 +455,15 @@ static void fanotify_free_group_priv(struct fsnotify_group *group)

		static void fanotify_free_event(struct fsnotify_event *fsn_event)
		{
		struct fanotify_event_info *event;
		struct fanotify_event *event;

		event = FANOTIFY_E(fsn_event);
		if (fanotify_event_has_path(event))
		path_put(&event->path);
		else if (fanotify_event_has_ext_fh(event))
		kfree(event->fid.ext_fh);
		put_pid(event->pid);
		if (fanotify_is_perm_event(fsn_event->mask)) {
		if (fanotify_is_perm_event(event->mask)) {
		kmem_cache_free(fanotify_perm_event_cachep,
		FANOTIFY_PE(fsn_event));
		return;

fs/notify/fanotify/fanotify.h

+102 −14

Original line number	Diff line number	Diff line
		@@ -2,26 +2,112 @@
		#include <linux/fsnotify_backend.h>
		#include <linux/path.h>
		#include <linux/slab.h>
		#include <linux/exportfs.h>

		extern struct kmem_cache *fanotify_mark_cache;
		extern struct kmem_cache *fanotify_event_cachep;
		extern struct kmem_cache *fanotify_perm_event_cachep;

		/* Possible states of the permission event */
		enum {
		FAN_EVENT_INIT,
		FAN_EVENT_REPORTED,
		FAN_EVENT_ANSWERED,
		FAN_EVENT_CANCELED,
		};

		/*
		* 3 dwords are sufficient for most local fs (64bit ino, 32bit generation).
		* For 32bit arch, fid increases the size of fanotify_event by 12 bytes and
		* fh_* fields increase the size of fanotify_event by another 4 bytes.
		* For 64bit arch, fid increases the size of fanotify_fid by 8 bytes and
		* fh_* fields are packed in a hole after mask.
		*/
		#if BITS_PER_LONG == 32
		#define FANOTIFY_INLINE_FH_LEN (3 << 2)
		#else
		#define FANOTIFY_INLINE_FH_LEN (4 << 2)
		#endif

		struct fanotify_fid {
		__kernel_fsid_t fsid;
		union {
		unsigned char fh[FANOTIFY_INLINE_FH_LEN];
		unsigned char *ext_fh;
		};
		};

		static inline void fanotify_fid_fh(struct fanotify_fid fid,
		unsigned int fh_len)
		{
		return fh_len <= FANOTIFY_INLINE_FH_LEN ? fid->fh : fid->ext_fh;
		}

		static inline bool fanotify_fid_equal(struct fanotify_fid *fid1,
		struct fanotify_fid *fid2,
		unsigned int fh_len)
		{
		return fid1->fsid.val[0] == fid2->fsid.val[0] &&
		fid1->fsid.val[1] == fid2->fsid.val[1] &&
		!memcmp(fanotify_fid_fh(fid1, fh_len),
		fanotify_fid_fh(fid2, fh_len), fh_len);
		}

		/*
		* Structure for normal fanotify events. It gets allocated in
		* fanotify_handle_event() and freed when the information is retrieved by
		* userspace
		*/
		struct fanotify_event_info {
		struct fanotify_event {
		struct fsnotify_event fse;
		u32 mask;
		/*
		* Those fields are outside fanotify_fid to pack fanotify_event nicely
		* on 64bit arch and to use fh_type as an indication of whether path
		* or fid are used in the union:
		* FILEID_ROOT (0) for path, > 0 for fid, FILEID_INVALID for neither.
		*/
		u8 fh_type;
		u8 fh_len;
		u16 pad;
		union {
		/*
		* We hold ref to this path so it may be dereferenced at any point
		* during this object's lifetime
		* We hold ref to this path so it may be dereferenced at any
		* point during this object's lifetime
		*/
		struct path path;
		/*
		* With FAN_REPORT_FID, we do not hold any reference on the
		* victim object. Instead we store its NFS file handle and its
		* filesystem's fsid as a unique identifier.
		*/
		struct fanotify_fid fid;
		};
		struct pid *pid;
		};

		static inline bool fanotify_event_has_path(struct fanotify_event *event)
		{
		return event->fh_type == FILEID_ROOT;
		}

		static inline bool fanotify_event_has_fid(struct fanotify_event *event)
		{
		return event->fh_type != FILEID_ROOT &&
		event->fh_type != FILEID_INVALID;
		}

		static inline bool fanotify_event_has_ext_fh(struct fanotify_event *event)
		{
		return fanotify_event_has_fid(event) &&
		event->fh_len > FANOTIFY_INLINE_FH_LEN;
		}

		static inline void fanotify_event_fh(struct fanotify_event event)
		{
		return fanotify_fid_fh(&event->fid, event->fh_len);
		}

		/*
		* Structure for permission fanotify events. It gets allocated and freed in
		* fanotify_handle_event() since we wait there for user response. When the
		@@ -29,16 +115,17 @@ struct fanotify_event_info {
		* group->notification_list to group->fanotify_data.access_list to wait for
		* user response.
		*/
		struct fanotify_perm_event_info {
		struct fanotify_event_info fae;
		int response; /* userspace answer to question */
		struct fanotify_perm_event {
		struct fanotify_event fae;
		unsigned short response; /* userspace answer to the event */
		unsigned short state; /* state of the event */
		int fd; /* fd we passed to userspace for this event */
		};

		static inline struct fanotify_perm_event_info *
		static inline struct fanotify_perm_event *
		FANOTIFY_PE(struct fsnotify_event *fse)
		{
		return container_of(fse, struct fanotify_perm_event_info, fae.fse);
		return container_of(fse, struct fanotify_perm_event, fae.fse);
		}

		static inline bool fanotify_is_perm_event(u32 mask)
		@@ -47,11 +134,12 @@ static inline bool fanotify_is_perm_event(u32 mask)
		mask & FANOTIFY_PERM_EVENTS;
		}

		static inline struct fanotify_event_info FANOTIFY_E(struct fsnotify_event fse)
		static inline struct fanotify_event FANOTIFY_E(struct fsnotify_event fse)
		{
		return container_of(fse, struct fanotify_event_info, fse);
		return container_of(fse, struct fanotify_event, fse);
		}

		struct fanotify_event_info fanotify_alloc_event(struct fsnotify_group group,
		struct fanotify_event fanotify_alloc_event(struct fsnotify_group group,
		struct inode *inode, u32 mask,
		const struct path *path);
		const void *data, int data_type,
		__kernel_fsid_t *fsid);

fs/notify/fanotify/fanotify_user.c

+255 −118

File changed.

Preview size limit exceeded, changes collapsed.

fs/notify/fsnotify.c

+7 −8

Original line number	Diff line number	Diff line
		@@ -328,16 +328,15 @@ int fsnotify(struct inode to_tell, __u32 mask, const void data, int data_is,
		const unsigned char *file_name, u32 cookie)
		{
		struct fsnotify_iter_info iter_info = {};
		struct super_block *sb = NULL;
		struct super_block *sb = to_tell->i_sb;
		struct mount *mnt = NULL;
		__u32 mnt_or_sb_mask = 0;
		__u32 mnt_or_sb_mask = sb->s_fsnotify_mask;
		int ret = 0;
		__u32 test_mask = (mask & ALL_FSNOTIFY_EVENTS);

		if (data_is == FSNOTIFY_EVENT_PATH) {
		mnt = real_mount(((const struct path *)data)->mnt);
		sb = mnt->mnt.mnt_sb;
		mnt_or_sb_mask = mnt->mnt_fsnotify_mask \| sb->s_fsnotify_mask;
		mnt_or_sb_mask \|= mnt->mnt_fsnotify_mask;
		}
		/* An event "on child" is not intended for a mount/sb mark */
		if (mask & FS_EVENT_ON_CHILD)
		@@ -350,8 +349,8 @@ int fsnotify(struct inode to_tell, __u32 mask, const void data, int data_is,
		* SRCU because we have no references to any objects and do not
		* need SRCU to keep them "alive".
		*/
		if (!to_tell->i_fsnotify_marks &&
		(!mnt \|\| (!mnt->mnt_fsnotify_marks && !sb->s_fsnotify_marks)))
		if (!to_tell->i_fsnotify_marks && !sb->s_fsnotify_marks &&
		(!mnt \|\| !mnt->mnt_fsnotify_marks))
		return 0;
		/*
		* if this is a modify event we may need to clear the ignored masks
		@@ -366,11 +365,11 @@ int fsnotify(struct inode to_tell, __u32 mask, const void data, int data_is,

		iter_info.marks[FSNOTIFY_OBJ_TYPE_INODE] =
		fsnotify_first_mark(&to_tell->i_fsnotify_marks);
		iter_info.marks[FSNOTIFY_OBJ_TYPE_SB] =
		fsnotify_first_mark(&sb->s_fsnotify_marks);
		if (mnt) {
		iter_info.marks[FSNOTIFY_OBJ_TYPE_VFSMOUNT] =
		fsnotify_first_mark(&mnt->mnt_fsnotify_marks);
		iter_info.marks[FSNOTIFY_OBJ_TYPE_SB] =
		fsnotify_first_mark(&sb->s_fsnotify_marks);
		}

		/*

Admin message