From patchwork Fri Apr 20 23:10:56 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Amir Goldstein X-Patchwork-Id: 10353839 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork.web.codeaurora.org (Postfix) with ESMTP id D1C2C6023A for ; Fri, 20 Apr 2018 23:10:02 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id C1ED4288DB for ; Fri, 20 Apr 2018 23:10:02 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id B6060288E6; Fri, 20 Apr 2018 23:10:02 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-8.0 required=2.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, FREEMAIL_FROM, MAILING_LIST_MULTI, RCVD_IN_DNSWL_HI autolearn=ham version=3.3.1 Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 8B51C288DB for ; Fri, 20 Apr 2018 23:10:01 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752634AbeDTXJ4 (ORCPT ); Fri, 20 Apr 2018 19:09:56 -0400 Received: from mail-pf0-f196.google.com ([209.85.192.196]:39535 "EHLO mail-pf0-f196.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752243AbeDTXJv (ORCPT ); Fri, 20 Apr 2018 19:09:51 -0400 Received: by mail-pf0-f196.google.com with SMTP id z9so4902919pfe.6 for ; Fri, 20 Apr 2018 16:09:51 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=Lfl8nUobF35kpGyLbdJ887F3YOCvCwHLW/cwjIqCCYg=; b=BkMRWsqqu8qJhhaUesUl6mHVMlWMEdMS6venDpiU64X+sEj2Y40c2Zn/JIhvENb9+m oSHlcJjQemfPy/rzX9xQ6ve3DlaZ/08v7RDbQMevzmpgK7lT1rcp4hm/rtCBNi26/rls iylgxLyfvWoF+zGRteb+zakVDGq+VEBqr4SXch044Mq49E33+UW95wK01OS9rRdDZuge FOpWeCx/0K6CwpB3aAENqihm3bZ+WEIjKR7L95vus22B9NHfLE6TwaTTCAQFjTU98NSl LtMxzhJ0YO2qwutuLw4rWSitfxu/xr+VP0+z2kiAL7Idy0K2hE/xYS8nEWbraAz5dKUZ FBpQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=Lfl8nUobF35kpGyLbdJ887F3YOCvCwHLW/cwjIqCCYg=; b=POja0P6CA2aE0tab5yUImPQ0AXiuonEQaDLVgap1Qd2dc2iYH6dqxVhjw0TQHqkce0 qhn6iZxUiJcAtO7/dOi4FdGYB13dzvQTgxWD07x7c5HDdHuT2pmHfGlu2zOaSqGJCPm2 fHSabs0ELsLbbL8Hj6vmO1DEnF5BvcCmUeX6cFUpkueULjsc5gFOrBk4hXxoU8xCpsYP fV90aybvGZehIDw/kVQEq+PPRglBT7w5VdlS1kt9rWCbDQ74Am67zwM4493WCJZnshQ0 +YP5iPUX0vIDGGH2lUcOG4rDl8qPGi5/6YFhZQ6BpWe1wyi/L6vW2cVV4ZtdGfOgiH3E m2ew== X-Gm-Message-State: ALQs6tBfB8PxuMthQkbOrpZ87z9+0dqF5AE4kOC++v2pLq3I0H6wIvbX NHd4nGeCkFA5ITNBZ4FwCBg= X-Google-Smtp-Source: AIpwx4+eSVdl5vwajuZYvBJLwZx97+KU1ENsqjP1tpONVcg1gxoQ2HXIcPUOCSUFMWN+dicK6MwYtw== X-Received: by 10.98.31.200 with SMTP id l69mr11292264pfj.49.1524265790498; Fri, 20 Apr 2018 16:09:50 -0700 (PDT) Received: from amir-VirtualBox.localdomain (c-24-5-85-70.hsd1.ca.comcast.net. [24.5.85.70]) by smtp.gmail.com with ESMTPSA id c12sm10541220pfn.13.2018.04.20.16.09.49 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Fri, 20 Apr 2018 16:09:49 -0700 (PDT) From: Amir Goldstein To: Jan Kara Cc: linux-fsdevel@vger.kernel.org Subject: [PATCH v3 08/13] fsnotify: introduce prototype struct fsnotify_obj Date: Fri, 20 Apr 2018 16:10:56 -0700 Message-Id: <1524265861-6316-9-git-send-email-amir73il@gmail.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1524265861-6316-1-git-send-email-amir73il@gmail.com> References: <1524265861-6316-1-git-send-email-amir73il@gmail.com> Sender: linux-fsdevel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-fsdevel@vger.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP struct inode and struct mount are both types of objects, which marks can be attached to. Let them "inherit" from a prototype struct, so that marks manipulation code can be made more generic. Introduce helpers fsnotify_obj_{inode,mount} to get the concrete object from the abstract object. Signed-off-by: Amir Goldstein --- fs/inode.c | 2 +- fs/mount.h | 11 +++++++++-- fs/notify/dnotify/dnotify.c | 8 ++++---- fs/notify/fanotify/fanotify_user.c | 24 ++++++++++++------------ fs/notify/fsnotify.c | 22 +++++++++++----------- fs/notify/fsnotify.h | 4 ++-- fs/notify/inotify/inotify_user.c | 6 +++--- fs/notify/mark.c | 16 ++++++++-------- include/linux/fs.h | 6 ++---- include/linux/fsnotify_backend.h | 10 ++++++++-- include/linux/fsnotify_obj.h | 14 ++++++++++++++ kernel/audit_tree.c | 2 +- kernel/audit_watch.c | 2 +- kernel/auditsc.c | 4 ++-- 14 files changed, 78 insertions(+), 53 deletions(-) create mode 100644 include/linux/fsnotify_obj.h diff --git a/fs/inode.c b/fs/inode.c index 13ceb98c3bd3..9eadddd2be94 100644 --- a/fs/inode.c +++ b/fs/inode.c @@ -190,7 +190,7 @@ int inode_init_always(struct super_block *sb, struct inode *inode) #endif #ifdef CONFIG_FSNOTIFY - inode->i_fsnotify_mask = 0; + inode->i_fsnotify.mask = 0; #endif inode->i_flctx = NULL; this_cpu_inc(nr_inodes); diff --git a/fs/mount.h b/fs/mount.h index f39bc9da4d73..718bb8073b90 100644 --- a/fs/mount.h +++ b/fs/mount.h @@ -4,6 +4,7 @@ #include #include #include +#include struct mnt_namespace { atomic_t count; @@ -61,8 +62,7 @@ struct mount { struct hlist_node mnt_mp_list; /* list mounts with the same mountpoint */ struct list_head mnt_umounting; /* list entry for umount propagation */ #ifdef CONFIG_FSNOTIFY - struct fsnotify_mark_connector __rcu *mnt_fsnotify_marks; - __u32 mnt_fsnotify_mask; + struct fsnotify_obj mnt_fsnotify; #endif int mnt_id; /* mount identifier */ int mnt_group_id; /* peer group identifier */ @@ -79,6 +79,13 @@ static inline struct mount *real_mount(struct vfsmount *mnt) return container_of(mnt, struct mount, mnt); } +#ifdef CONFIG_FSNOTIFY +static inline struct mount *fsnotify_obj_mount(struct fsnotify_obj *obj) +{ + return container_of(obj, struct mount, mnt_fsnotify); +} +#endif + static inline int mnt_has_parent(struct mount *mnt) { return mnt != mnt->mnt_parent; diff --git a/fs/notify/dnotify/dnotify.c b/fs/notify/dnotify/dnotify.c index e2bea2ac5dfb..d46167c69c99 100644 --- a/fs/notify/dnotify/dnotify.c +++ b/fs/notify/dnotify/dnotify.c @@ -33,7 +33,7 @@ static struct kmem_cache *dnotify_mark_cache __read_mostly; static struct fsnotify_group *dnotify_group __read_mostly; /* - * dnotify will attach one of these to each inode (i_fsnotify_marks) which + * dnotify will attach one of these to each inode (i_fsnotify.marks) which * is being watched by dnotify. If multiple userspace applications are watching * the same directory with dnotify their information is chained in dn */ @@ -158,7 +158,7 @@ void dnotify_flush(struct file *filp, fl_owner_t id) if (!S_ISDIR(inode->i_mode)) return; - fsn_mark = fsnotify_find_mark(&inode->i_fsnotify_marks, dnotify_group); + fsn_mark = fsnotify_find_mark(&inode->i_fsnotify.marks, dnotify_group); if (!fsn_mark) return; dn_mark = container_of(fsn_mark, struct dnotify_mark, fsn_mark); @@ -218,7 +218,7 @@ static __u32 convert_arg(unsigned long arg) /* * If multiple processes watch the same inode with dnotify there is only one - * dnotify mark in inode->i_fsnotify_marks but we chain a dnotify_struct + * dnotify mark in inode->i_fsnotify.marks but we chain a dnotify_struct * onto that mark. This function either attaches the new dnotify_struct onto * that list, or it |= the mask onto an existing dnofiy_struct. */ @@ -314,7 +314,7 @@ int fcntl_dirnotify(int fd, struct file *filp, unsigned long arg) mutex_lock(&dnotify_group->mark_mutex); /* add the new_fsn_mark or find an old one. */ - fsn_mark = fsnotify_find_mark(&inode->i_fsnotify_marks, dnotify_group); + fsn_mark = fsnotify_find_mark(&inode->i_fsnotify.marks, dnotify_group); if (fsn_mark) { dn_mark = container_of(fsn_mark, struct dnotify_mark, fsn_mark); spin_lock(&fsn_mark->lock); diff --git a/fs/notify/fanotify/fanotify_user.c b/fs/notify/fanotify/fanotify_user.c index ec4d8c59d0e3..ed87880c42f0 100644 --- a/fs/notify/fanotify/fanotify_user.c +++ b/fs/notify/fanotify/fanotify_user.c @@ -533,7 +533,7 @@ static int fanotify_remove_vfsmount_mark(struct fsnotify_group *group, int destroy_mark; mutex_lock(&group->mark_mutex); - fsn_mark = fsnotify_find_mark(&real_mount(mnt)->mnt_fsnotify_marks, + fsn_mark = fsnotify_find_mark(&real_mount(mnt)->mnt_fsnotify.marks, group); if (!fsn_mark) { mutex_unlock(&group->mark_mutex); @@ -542,8 +542,8 @@ static int fanotify_remove_vfsmount_mark(struct fsnotify_group *group, removed = fanotify_mark_remove_from_mask(fsn_mark, mask, flags, &destroy_mark); - if (removed & real_mount(mnt)->mnt_fsnotify_mask) - fsnotify_recalc_mask(real_mount(mnt)->mnt_fsnotify_marks); + if (removed & real_mount(mnt)->mnt_fsnotify.mask) + fsnotify_recalc_mask(real_mount(mnt)->mnt_fsnotify.marks); if (destroy_mark) fsnotify_detach_mark(fsn_mark); mutex_unlock(&group->mark_mutex); @@ -563,7 +563,7 @@ static int fanotify_remove_inode_mark(struct fsnotify_group *group, int destroy_mark; mutex_lock(&group->mark_mutex); - fsn_mark = fsnotify_find_mark(&inode->i_fsnotify_marks, group); + fsn_mark = fsnotify_find_mark(&inode->i_fsnotify.marks, group); if (!fsn_mark) { mutex_unlock(&group->mark_mutex); return -ENOENT; @@ -571,8 +571,8 @@ static int fanotify_remove_inode_mark(struct fsnotify_group *group, removed = fanotify_mark_remove_from_mask(fsn_mark, mask, flags, &destroy_mark); - if (removed & inode->i_fsnotify_mask) - fsnotify_recalc_mask(inode->i_fsnotify_marks); + if (removed & inode->i_fsnotify.mask) + fsnotify_recalc_mask(inode->i_fsnotify.marks); if (destroy_mark) fsnotify_detach_mark(fsn_mark); mutex_unlock(&group->mark_mutex); @@ -647,7 +647,7 @@ static int fanotify_add_vfsmount_mark(struct fsnotify_group *group, __u32 added; mutex_lock(&group->mark_mutex); - fsn_mark = fsnotify_find_mark(&real_mount(mnt)->mnt_fsnotify_marks, + fsn_mark = fsnotify_find_mark(&real_mount(mnt)->mnt_fsnotify.marks, group); if (!fsn_mark) { fsn_mark = fanotify_add_new_mark(group, NULL, mnt); @@ -657,8 +657,8 @@ static int fanotify_add_vfsmount_mark(struct fsnotify_group *group, } } added = fanotify_mark_add_to_mask(fsn_mark, mask, flags); - if (added & ~real_mount(mnt)->mnt_fsnotify_mask) - fsnotify_recalc_mask(real_mount(mnt)->mnt_fsnotify_marks); + if (added & ~real_mount(mnt)->mnt_fsnotify.mask) + fsnotify_recalc_mask(real_mount(mnt)->mnt_fsnotify.marks); mutex_unlock(&group->mark_mutex); fsnotify_put_mark(fsn_mark); @@ -685,7 +685,7 @@ static int fanotify_add_inode_mark(struct fsnotify_group *group, return 0; mutex_lock(&group->mark_mutex); - fsn_mark = fsnotify_find_mark(&inode->i_fsnotify_marks, group); + fsn_mark = fsnotify_find_mark(&inode->i_fsnotify.marks, group); if (!fsn_mark) { fsn_mark = fanotify_add_new_mark(group, inode, NULL); if (IS_ERR(fsn_mark)) { @@ -694,8 +694,8 @@ static int fanotify_add_inode_mark(struct fsnotify_group *group, } } added = fanotify_mark_add_to_mask(fsn_mark, mask, flags); - if (added & ~inode->i_fsnotify_mask) - fsnotify_recalc_mask(inode->i_fsnotify_marks); + if (added & ~inode->i_fsnotify.mask) + fsnotify_recalc_mask(inode->i_fsnotify.marks); mutex_unlock(&group->mark_mutex); fsnotify_put_mark(fsn_mark); diff --git a/fs/notify/fsnotify.c b/fs/notify/fsnotify.c index f174397b63a0..ea1003bc39d3 100644 --- a/fs/notify/fsnotify.c +++ b/fs/notify/fsnotify.c @@ -160,7 +160,7 @@ int __fsnotify_parent(const struct path *path, struct dentry *dentry, __u32 mask if (unlikely(!fsnotify_inode_watches_children(p_inode))) __fsnotify_update_child_dentry_flags(p_inode); - else if (p_inode->i_fsnotify_mask & mask) { + else if (p_inode->i_fsnotify.mask & mask) { struct name_snapshot name; /* we are notifying a parent so come up with the new mask which @@ -331,13 +331,13 @@ int fsnotify(struct inode *to_tell, __u32 mask, const void *data, int data_is, /* * Optimization: srcu_read_lock() has a memory barrier which can - * be expensive. It protects walking the *_fsnotify_marks lists. + * be expensive. It protects walking the *_fsnotify.marks lists. * However, if we do not walk the lists, we do not have to do * 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)) + if (!to_tell->i_fsnotify.marks && + (!mnt || !mnt->mnt_fsnotify.marks)) return 0; /* * if this is a modify event we may need to clear the ignored masks @@ -345,24 +345,24 @@ int fsnotify(struct inode *to_tell, __u32 mask, const void *data, int data_is, * this type of event. */ if (!(mask & FS_MODIFY) && - !(test_mask & to_tell->i_fsnotify_mask) && - !(mnt && test_mask & mnt->mnt_fsnotify_mask)) + !(test_mask & to_tell->i_fsnotify.mask) && + !(mnt && test_mask & mnt->mnt_fsnotify.mask)) return 0; iter_info.srcu_idx = srcu_read_lock(&fsnotify_mark_srcu); if ((mask & FS_MODIFY) || - (test_mask & to_tell->i_fsnotify_mask)) { + (test_mask & to_tell->i_fsnotify.mask)) { iter_info.marks[FSNOTIFY_OBJ_TYPE_INODE] = - fsnotify_first_mark(&to_tell->i_fsnotify_marks); + fsnotify_first_mark(&to_tell->i_fsnotify.marks); } if (mnt && ((mask & FS_MODIFY) || - (test_mask & mnt->mnt_fsnotify_mask))) { + (test_mask & mnt->mnt_fsnotify.mask))) { iter_info.marks[FSNOTIFY_OBJ_TYPE_INODE] = - fsnotify_first_mark(&to_tell->i_fsnotify_marks); + fsnotify_first_mark(&to_tell->i_fsnotify.marks); iter_info.marks[FSNOTIFY_OBJ_TYPE_VFSMOUNT] = - fsnotify_first_mark(&mnt->mnt_fsnotify_marks); + fsnotify_first_mark(&mnt->mnt_fsnotify.marks); } /* diff --git a/fs/notify/fsnotify.h b/fs/notify/fsnotify.h index 34515d2c4ba3..8f4d3e43b5b5 100644 --- a/fs/notify/fsnotify.h +++ b/fs/notify/fsnotify.h @@ -24,12 +24,12 @@ extern void fsnotify_destroy_marks(struct fsnotify_mark_connector __rcu **connp) /* run the list of all marks associated with inode and destroy them */ static inline void fsnotify_clear_marks_by_inode(struct inode *inode) { - fsnotify_destroy_marks(&inode->i_fsnotify_marks); + fsnotify_destroy_marks(&inode->i_fsnotify.marks); } /* run the list of all marks associated with vfsmount and destroy them */ static inline void fsnotify_clear_marks_by_mount(struct vfsmount *mnt) { - fsnotify_destroy_marks(&real_mount(mnt)->mnt_fsnotify_marks); + fsnotify_destroy_marks(&real_mount(mnt)->mnt_fsnotify.marks); } /* Wait until all marks queued for destruction are destroyed */ extern void fsnotify_wait_marks_destroyed(void); diff --git a/fs/notify/inotify/inotify_user.c b/fs/notify/inotify/inotify_user.c index 1cf5b779d862..8eaa3b468b5c 100644 --- a/fs/notify/inotify/inotify_user.c +++ b/fs/notify/inotify/inotify_user.c @@ -514,7 +514,7 @@ static int inotify_update_existing_watch(struct fsnotify_group *group, mask = inotify_arg_to_mask(arg); - fsn_mark = fsnotify_find_mark(&inode->i_fsnotify_marks, group); + fsn_mark = fsnotify_find_mark(&inode->i_fsnotify.marks, group); if (!fsn_mark) return -ENOENT; @@ -533,11 +533,11 @@ static int inotify_update_existing_watch(struct fsnotify_group *group, /* more bits in old than in new? */ int dropped = (old_mask & ~new_mask); /* more bits in this fsn_mark than the inode's mask? */ - int do_inode = (new_mask & ~inode->i_fsnotify_mask); + int do_inode = (new_mask & ~inode->i_fsnotify.mask); /* update the inode with this new fsn_mark */ if (dropped || do_inode) - fsnotify_recalc_mask(inode->i_fsnotify_marks); + fsnotify_recalc_mask(inode->i_fsnotify.marks); } diff --git a/fs/notify/mark.c b/fs/notify/mark.c index 61f4c5fa34c7..4f0c17e5db53 100644 --- a/fs/notify/mark.c +++ b/fs/notify/mark.c @@ -120,9 +120,9 @@ static void __fsnotify_recalc_mask(struct fsnotify_mark_connector *conn) new_mask |= mark->mask; } if (conn->type == FSNOTIFY_OBJ_TYPE_INODE) - conn->inode->i_fsnotify_mask = new_mask; + conn->inode->i_fsnotify.mask = new_mask; else if (conn->type == FSNOTIFY_OBJ_TYPE_VFSMOUNT) - real_mount(conn->mnt)->mnt_fsnotify_mask = new_mask; + real_mount(conn->mnt)->mnt_fsnotify.mask = new_mask; } /* @@ -168,14 +168,14 @@ static struct inode *fsnotify_detach_connector_from_object( if (conn->type == FSNOTIFY_OBJ_TYPE_INODE) { inode = conn->inode; - rcu_assign_pointer(inode->i_fsnotify_marks, NULL); - inode->i_fsnotify_mask = 0; + rcu_assign_pointer(inode->i_fsnotify.marks, NULL); + inode->i_fsnotify.mask = 0; conn->inode = NULL; conn->type = FSNOTIFY_OBJ_TYPE_DETACHED; } else if (conn->type == FSNOTIFY_OBJ_TYPE_VFSMOUNT) { - rcu_assign_pointer(real_mount(conn->mnt)->mnt_fsnotify_marks, + rcu_assign_pointer(real_mount(conn->mnt)->mnt_fsnotify.marks, NULL); - real_mount(conn->mnt)->mnt_fsnotify_mask = 0; + real_mount(conn->mnt)->mnt_fsnotify.mask = 0; conn->mnt = NULL; conn->type = FSNOTIFY_OBJ_TYPE_DETACHED; } @@ -515,9 +515,9 @@ static int fsnotify_add_mark_list(struct fsnotify_mark *mark, if (WARN_ON(!inode && !mnt)) return -EINVAL; if (inode) - connp = &inode->i_fsnotify_marks; + connp = &inode->i_fsnotify.marks; else - connp = &real_mount(mnt)->mnt_fsnotify_marks; + connp = &real_mount(mnt)->mnt_fsnotify.marks; restart: spin_lock(&mark->lock); conn = fsnotify_grab_connector(connp); diff --git a/include/linux/fs.h b/include/linux/fs.h index 760d8da1b6c7..46af8e9a1111 100644 --- a/include/linux/fs.h +++ b/include/linux/fs.h @@ -36,6 +36,7 @@ #include #include #include +#include #include #include @@ -560,8 +561,6 @@ is_uncached_acl(struct posix_acl *acl) #define IOP_XATTR 0x0008 #define IOP_DEFAULT_READLINK 0x0010 -struct fsnotify_mark_connector; - /* * Keep mostly read-only and often accessed (especially for * the RCU path lookup and 'stat' data) fields at the beginning @@ -661,8 +660,7 @@ struct inode { __u32 i_generation; #ifdef CONFIG_FSNOTIFY - __u32 i_fsnotify_mask; /* all events this inode cares about */ - struct fsnotify_mark_connector __rcu *i_fsnotify_marks; + struct fsnotify_obj i_fsnotify; #endif #if IS_ENABLED(CONFIG_FS_ENCRYPTION) diff --git a/include/linux/fsnotify_backend.h b/include/linux/fsnotify_backend.h index b38964a7a521..a2cd8c51860e 100644 --- a/include/linux/fsnotify_backend.h +++ b/include/linux/fsnotify_backend.h @@ -19,6 +19,7 @@ #include #include #include +#include /* * IN_* from inotfy.h lines up EXACTLY with FS_*, this is so we can easily @@ -268,6 +269,11 @@ struct fsnotify_mark_connector { struct hlist_head list; }; +static inline struct inode *fsnotify_obj_inode(struct fsnotify_obj *obj) +{ + return container_of(obj, struct inode, i_fsnotify); +} + /* * A mark is simply an object attached to an in core inode which allows an * fsnotify listener to indicate they are either no longer interested in events @@ -324,11 +330,11 @@ extern u32 fsnotify_get_cookie(void); static inline int fsnotify_inode_watches_children(struct inode *inode) { /* FS_EVENT_ON_CHILD is set if the inode may care */ - if (!(inode->i_fsnotify_mask & FS_EVENT_ON_CHILD)) + if (!(inode->i_fsnotify.mask & FS_EVENT_ON_CHILD)) return 0; /* this inode might care about child events, does it care about the * specific set of events that can happen on a child? */ - return inode->i_fsnotify_mask & FS_EVENTS_POSS_ON_CHILD; + return inode->i_fsnotify.mask & FS_EVENTS_POSS_ON_CHILD; } /* diff --git a/include/linux/fsnotify_obj.h b/include/linux/fsnotify_obj.h new file mode 100644 index 000000000000..437e78e60f82 --- /dev/null +++ b/include/linux/fsnotify_obj.h @@ -0,0 +1,14 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _LINUX_FSNOTIFY_OBJ_H +#define _LINUX_FSNOTIFY_OBJ_H + +struct fsnotify_mark_connector; + +/* struct to embed in objects, which marks can be attached to */ +struct fsnotify_obj { + struct fsnotify_mark_connector __rcu *marks; + /* all events this object cares about */ + __u32 mask; +}; + +#endif diff --git a/kernel/audit_tree.c b/kernel/audit_tree.c index c99ebaae5abc..0124eb3999a5 100644 --- a/kernel/audit_tree.c +++ b/kernel/audit_tree.c @@ -393,7 +393,7 @@ static int tag_chunk(struct inode *inode, struct audit_tree *tree) struct node *p; int n; - old_entry = fsnotify_find_mark(&inode->i_fsnotify_marks, + old_entry = fsnotify_find_mark(&inode->i_fsnotify.marks, audit_tree_group); if (!old_entry) return create_chunk(inode, tree); diff --git a/kernel/audit_watch.c b/kernel/audit_watch.c index 439a3a01368c..1b017875b8d2 100644 --- a/kernel/audit_watch.c +++ b/kernel/audit_watch.c @@ -103,7 +103,7 @@ static inline struct audit_parent *audit_find_parent(struct inode *inode) struct audit_parent *parent = NULL; struct fsnotify_mark *entry; - entry = fsnotify_find_mark(&inode->i_fsnotify_marks, audit_watch_group); + entry = fsnotify_find_mark(&inode->i_fsnotify.marks, audit_watch_group); if (entry) parent = container_of(entry, struct audit_parent, mark); diff --git a/kernel/auditsc.c b/kernel/auditsc.c index 4e0a4ac803db..87098b93ab79 100644 --- a/kernel/auditsc.c +++ b/kernel/auditsc.c @@ -1598,7 +1598,7 @@ static inline void handle_one(const struct inode *inode) struct audit_tree_refs *p; struct audit_chunk *chunk; int count; - if (likely(!inode->i_fsnotify_marks)) + if (likely(!inode->i_fsnotify.marks)) return; context = current->audit_context; p = context->trees; @@ -1641,7 +1641,7 @@ static void handle_path(const struct dentry *dentry) seq = read_seqbegin(&rename_lock); for(;;) { struct inode *inode = d_backing_inode(d); - if (inode && unlikely(inode->i_fsnotify_marks)) { + if (inode && unlikely(inode->i_fsnotify.marks)) { struct audit_chunk *chunk; chunk = audit_tree_lookup(inode); if (chunk) {