Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) client-ip=2620:137:e000::1:20;
From:   Imran Khan <imran.f.khan@oracle.com>
To:     tj@kernel.org, gregkh@linuxfoundation.org, viro@zeniv.linux.org.uk
Cc:     linux-kernel@vger.kernel.org
Subject: [PATCH v6 3/4] kernfs: Introduce interface to access global kernfs_open_file_mutex.
Date:   Tue, 14 Jun 2022 17:03:45 +1000
Message-Id: <20220614070346.810168-4-imran.f.khan@oracle.com>
In-Reply-To: <20220614070346.810168-1-imran.f.khan@oracle.com>
References: <20220614070346.810168-1-imran.f.khan@oracle.com>
Content-Transfer-Encoding: 8bit
Content-Type: text/plain
MIME-Version: 1.0
X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1
X-MS-Exchange-AntiSpam-MessageData-0: =?us-ascii?Q?X9KHyY7QCPnHGbjdESyRDNLQ5bLFWRJ72mZtDgiNpB5j4ALaqT5rKZCM6p0j?=
 =?us-ascii?Q?/Vv7MuERp92RccT+itAU+RHx33AsSDJbudOzL0tn17frVcmOUriaHsqo9ErU?=
 =?us-ascii?Q?hWsUNe7H+SiLY0hZxiEM9bYs+Ub5TngYCmrA0eSk1Sa9xi9j99LanCyC49id?=
 =?us-ascii?Q?XbyUSerwBxM701Lt3UyLaEJlA8VTGmj1CMGeDJwqe54zqW6L+ddMQ3mFukX4?=
 =?us-ascii?Q?4OliDKdtJx/U9n6HoxmnGY1oHV3VMaexuD8LaNBMp4SkfpMLzmWPOd5E9wsK?=
 =?us-ascii?Q?Ys58TFfeMimzlQFYTnUrTDtlqrKayptf8bGmJk9icRi+brEHy/hL5RdbJYct?=
 =?us-ascii?Q?qzcKeW3p+Wx9cDDI4hUjlws6Dxm7u9DQJnjQqIYB9vP4/s1qhcu81zaJjYSC?=
 =?us-ascii?Q?BlOfg3T3vxtFF7k34V1mwt9iZ1buWFaLrejf/2d2ZSxcHFcurExGVUZiUQyA?=
 =?us-ascii?Q?T/W7QmZYu1Zlgfs8kBSbhH61c7iEPYwRJgGXHK3BDYiglKZ3jvOYMk9Mw2ww?=
 =?us-ascii?Q?K6+3jL0gPmCC6n2Hlu0rmrIL1St3V8rmyfts+SIU/4zGkEdW4HNAdpfCFWFF?=
 =?us-ascii?Q?k0SjkzkeEeieGy9QGJENCZgfRNhbFDX/6TWj3E6D0bnByJopP+hw9QU85Eq3?=
 =?us-ascii?Q?EZ1q3RXYi6t2lU300Su04JQarQGvv2r9WrjGnWu3HF2MHm4MU+0WELutvcVm?=
 =?us-ascii?Q?yPsZOyI6oi+wm+H3y9TkFYC9YRjBOeh1w4vSDqcx5wuiYnA8rWoiN3/iuchP?=
 =?us-ascii?Q?if/S4tYFovPn51AxCgHlihPulrdtRbNHwvmXnXgdmaxMAbhKap9CRUXn20wl?=
 =?us-ascii?Q?D1upzxHaMr/BRRxEvH8meUdRsHBYApAMMc6hpAtLftPl5lsKCdjDJqmupSNB?=
 =?us-ascii?Q?0t36MgFp0oa8WN5vweJUFzMjwY9EeRUpCTGzIjxz4G34/f/zwuTgBIXhrG/y?=
 =?us-ascii?Q?aAH1Eiq7iSznyKVPpdhIQN2Bm+LXmczsgmqM5IpdRupUQsrWWoVIgncwngCQ?=
 =?us-ascii?Q?pR3R2TxPRE6Zm5Ks+SEcOMuBaUtiro30GZqiAjqRi4aHTkgxFbECM810tDgG?=
 =?us-ascii?Q?Q378F2ZscfUhSfgi1XA0pFuhu1R+Tn31uwYfaE24nQE2FMUmeoEymDwRo2gm?=
 =?us-ascii?Q?paNqqO1qVQEDN45dVv5YrlF+PxA4lJ2Z3RuP68lmA9WChu5GIRsHrp5ewOu8?=
 =?us-ascii?Q?lnZr8M2d+F+K4FMQKRjMx1wgKAPbSp92kob+u/5jT52KsHQsVs3UbPnj2zUJ?=
 =?us-ascii?Q?zg90JxMgS3MzvKdC/h6jxhrpx0VXqjBXUmXdoo7myHkVyp7LzTsQP0dFv3To?=
 =?us-ascii?Q?wHwwz7J77jTdwig7/4vjjo4cJwg++WxG2CdL7O5R2Bi9ZyKjT+ARH9gCLJ1F?=
 =?us-ascii?Q?CPUBMW528yOteYf2+B8cml4xhPNH0Lr9kfuIEEj+P55zgQqzwUobiXheDy16?=
 =?us-ascii?Q?l+pfM1zB2Twhvc3QjXWv0ErHiiQP0gwG+Z+BDZ45/zcrOKWgH6ZELZwjU7eI?=
 =?us-ascii?Q?MDqu2rG/SWn/+D9hdmk+Kc7vXkOI6zodmKhKLT3fjlH0qbMHpL50bmarX55f?=
 =?us-ascii?Q?oP2yupJ0JS0qEtBRtuIV2ATRQoqkzITG8C3+t/ctmZIVJE1LuOL5q+BFOpgB?=
 =?us-ascii?Q?Fe+yJlFryllZINi759RsNm9VZ9zaR/bHSUM2cZkQqpMquZO4P0BPftReR8aR?=
 =?us-ascii?Q?Orv+XoRcTkhEB/I3dtgMLa1ayhgHP9cfShc6DYhVZonrpX1m1fj1FP3SHJ+/?=
 =?us-ascii?Q?zR2TNmg12wCMk9Snk8DWelO+88YGmp4=3D?=
X-OriginatorOrg: oracle.com
X-MS-Exchange-CrossTenant-Network-Message-Id: 64b8c0fb-0960-4dfa-e1e2-08da4dd410d0
X-MS-Exchange-CrossTenant-AuthSource: CO1PR10MB4468.namprd10.prod.outlook.com
X-MS-Exchange-CrossTenant-AuthAs: Internal
X-MS-Exchange-CrossTenant-OriginalArrivalTime: 14 Jun 2022 07:04:03.8126
 (UTC)
X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted
X-MS-Exchange-CrossTenant-Id: 4e2c6054-71cb-48f1-bd6c-3a9705aca71b
X-MS-Exchange-CrossTenant-MailboxType: HOSTED
X-MS-Exchange-CrossTenant-UserPrincipalName: gHsaE85xZETepmXNIC9n5Xwf5++Bak+eaKQ+b71V370c7xb+5cPwr877Wnrg7rAuXNkQqN7ISPIqUIzGqAj6qw==
X-MS-Exchange-Transport-CrossTenantHeadersStamped: DM8PR10MB5414
X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10434:6.0.517,18.0.874
 definitions=2022-06-14_02:2022-06-13,2022-06-14 signatures=0
X-Proofpoint-Spam-Details: rule=notspam policy=default score=0 bulkscore=0 phishscore=0 mlxscore=0
 mlxlogscore=999 suspectscore=0 malwarescore=0 adultscore=0 spamscore=0
 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-2204290000
 definitions=main-2206140026
X-Proofpoint-GUID: B2MuJ0zO4JQGo00jxQMYR4ZRcpPb-C-I
X-Proofpoint-ORIG-GUID: B2MuJ0zO4JQGo00jxQMYR4ZRcpPb-C-I
X-Spam-Status: No, score=-2.8 required=5.0 tests=BAYES_00,DKIM_SIGNED,
        DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RCVD_IN_DNSWL_LOW,
        RCVD_IN_MSPIKE_H2,SPF_HELO_NONE,SPF_NONE,T_SCC_BODY_TEXT_LINE
        autolearn=ham autolearn_force=no version=3.4.6
X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on
        lindbergh.monkeyblade.net
Precedence: bulk
List-ID: <linux-kernel.vger.kernel.org>
X-Mailing-List: linux-kernel@vger.kernel.org

This allows to change underlying mutex locking, without needing to change
the users of the lock. For example next patch modifies this interface to
use hashed mutexes in place of a single global kernfs_open_file_mutex.

Signed-off-by: Imran Khan <imran.f.khan@oracle.com>
Acked-by: Tejun Heo <tj@kernel.org>
---
 fs/kernfs/file.c | 56 ++++++++++++++++++++++++++++++++----------------
 1 file changed, 38 insertions(+), 18 deletions(-)

diff --git a/fs/kernfs/file.c b/fs/kernfs/file.c
index 77aeb0b6f992b..38fb71b2c671e 100644
--- a/fs/kernfs/file.c
+++ b/fs/kernfs/file.c
@@ -49,6 +49,22 @@ struct kernfs_open_node {
 
 static LLIST_HEAD(kernfs_notify_list);
 
+static inline struct mutex *kernfs_open_file_mutex_ptr(struct kernfs_node *kn)
+{
+	return &kernfs_open_file_mutex;
+}
+
+static inline struct mutex *kernfs_open_file_mutex_lock(struct kernfs_node *kn)
+{
+	struct mutex *lock;
+
+	lock = kernfs_open_file_mutex_ptr(kn);
+
+	mutex_lock(lock);
+
+	return lock;
+}
+
 /**
  * kernfs_deref_open_node - Get kernfs_open_node corresponding to @kn.
  *
@@ -79,9 +95,9 @@ kernfs_deref_open_node(struct kernfs_open_file *of, struct kernfs_node *kn)
  * @kn: target kernfs_node.
  *
  * Fetch and return ->attr.open of @kn when caller holds the
- * kernfs_open_file_mutex.
+ * kernfs_open_file_mutex_ptr(kn).
  *
- * Update of ->attr.open happens under kernfs_open_file_mutex. So when
+ * Update of ->attr.open happens under kernfs_open_file_mutex_ptr(kn). So when
  * the caller guarantees that this mutex is being held, other updaters can't
  * change ->attr.open and this means that we can safely deref ->attr.open
  * outside RCU read-side critical section.
@@ -92,7 +108,7 @@ static struct kernfs_open_node *
 kernfs_deref_open_node_protected(struct kernfs_node *kn)
 {
 	return rcu_dereference_check(kn->attr.open,
-				lockdep_is_held(&kernfs_open_file_mutex));
+				lockdep_is_held(kernfs_open_file_mutex_ptr(kn)));
 }
 
 static struct kernfs_open_file *kernfs_of(struct file *file)
@@ -575,19 +591,20 @@ static int kernfs_get_open_node(struct kernfs_node *kn,
 				struct kernfs_open_file *of)
 {
 	struct kernfs_open_node *on, *new_on = NULL;
+	struct mutex *mutex = NULL;
 
-	mutex_lock(&kernfs_open_file_mutex);
+	mutex = kernfs_open_file_mutex_lock(kn);
 	on = kernfs_deref_open_node_protected(kn);
 
 	if (on) {
 		list_add_tail(&of->list, &on->files);
-		mutex_unlock(&kernfs_open_file_mutex);
+		mutex_unlock(mutex);
 		return 0;
 	} else {
 		/* not there, initialize a new one */
 		new_on = kmalloc(sizeof(*new_on), GFP_KERNEL);
 		if (!new_on) {
-			mutex_unlock(&kernfs_open_file_mutex);
+			mutex_unlock(mutex);
 			return -ENOMEM;
 		}
 		atomic_set(&new_on->event, 1);
@@ -596,7 +613,7 @@ static int kernfs_get_open_node(struct kernfs_node *kn,
 		list_add_tail(&of->list, &new_on->files);
 		rcu_assign_pointer(kn->attr.open, new_on);
 	}
-	mutex_unlock(&kernfs_open_file_mutex);
+	mutex_unlock(mutex);
 
 	return 0;
 }
@@ -618,12 +635,13 @@ static void kernfs_unlink_open_file(struct kernfs_node *kn,
 				 struct kernfs_open_file *of)
 {
 	struct kernfs_open_node *on;
+	struct mutex *mutex = NULL;
 
-	mutex_lock(&kernfs_open_file_mutex);
+	mutex = kernfs_open_file_mutex_lock(kn);
 
 	on = kernfs_deref_open_node_protected(kn);
 	if (!on) {
-		mutex_unlock(&kernfs_open_file_mutex);
+		mutex_unlock(mutex);
 		return;
 	}
 
@@ -635,7 +653,7 @@ static void kernfs_unlink_open_file(struct kernfs_node *kn,
 		kfree_rcu(on, rcu_head);
 	}
 
-	mutex_unlock(&kernfs_open_file_mutex);
+	mutex_unlock(mutex);
 }
 
 static int kernfs_fop_open(struct inode *inode, struct file *file)
@@ -773,11 +791,11 @@ static void kernfs_release_file(struct kernfs_node *kn,
 	/*
 	 * @of is guaranteed to have no other file operations in flight and
 	 * we just want to synchronize release and drain paths.
-	 * @kernfs_open_file_mutex is enough.  @of->mutex can't be used
+	 * @kernfs_open_file_mutex_ptr(kn) is enough. @of->mutex can't be used
 	 * here because drain path may be called from places which can
 	 * cause circular dependency.
 	 */
-	lockdep_assert_held(&kernfs_open_file_mutex);
+	lockdep_assert_held(kernfs_open_file_mutex_ptr(kn));
 
 	if (!of->released) {
 		/*
@@ -794,11 +812,12 @@ static int kernfs_fop_release(struct inode *inode, struct file *filp)
 {
 	struct kernfs_node *kn = inode->i_private;
 	struct kernfs_open_file *of = kernfs_of(filp);
+	struct mutex *mutex = NULL;
 
 	if (kn->flags & KERNFS_HAS_RELEASE) {
-		mutex_lock(&kernfs_open_file_mutex);
+		mutex = kernfs_open_file_mutex_lock(kn);
 		kernfs_release_file(kn, of);
-		mutex_unlock(&kernfs_open_file_mutex);
+		mutex_unlock(mutex);
 	}
 
 	kernfs_unlink_open_file(kn, of);
@@ -813,6 +832,7 @@ void kernfs_drain_open_files(struct kernfs_node *kn)
 {
 	struct kernfs_open_node *on;
 	struct kernfs_open_file *of;
+	struct mutex *mutex = NULL;
 
 	if (!(kn->flags & (KERNFS_HAS_MMAP | KERNFS_HAS_RELEASE)))
 		return;
@@ -822,16 +842,16 @@ void kernfs_drain_open_files(struct kernfs_node *kn)
 	 * ->attr.open at this point of time. This check allows early bail out
 	 * if ->attr.open is already NULL. kernfs_unlink_open_file makes
 	 * ->attr.open NULL only while holding kernfs_open_file_mutex so below
-	 * check under kernfs_open_file_mutex will ensure bailing out if
+	 * check under kernfs_open_file_mutex_ptr(kn) will ensure bailing out if
 	 * ->attr.open became NULL while waiting for the mutex.
 	 */
 	if (!rcu_access_pointer(kn->attr.open))
 		return;
 
-	mutex_lock(&kernfs_open_file_mutex);
+	mutex = kernfs_open_file_mutex_lock(kn);
 	on = kernfs_deref_open_node_protected(kn);
 	if (!on) {
-		mutex_unlock(&kernfs_open_file_mutex);
+		mutex_unlock(mutex);
 		return;
 	}
 
@@ -845,7 +865,7 @@ void kernfs_drain_open_files(struct kernfs_node *kn)
 			kernfs_release_file(kn, of);
 	}
 
-	mutex_unlock(&kernfs_open_file_mutex);
+	mutex_unlock(mutex);
 }
 
 /*
-- 
2.30.2