From nobody Sat Jul 25 00:52:36 2026 Received: from out30-101.freemail.mail.aliyun.com (out30-101.freemail.mail.aliyun.com [115.124.30.101]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 9CCF1480DF8 for ; Tue, 21 Jul 2026 11:49:20 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=115.124.30.101 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784634563; cv=none; b=DnjjeWLAQte1yoin1Uax0ejDy8lgIpKJyRlH+hx3GLbMvvVZMmb3oppWjzcqCSEPX5lLu/AhaUclry9XjpZyq2gAHSWAMyHRD5plQU9GCw1yKeB7qhAOG8G/bwDVtO5k37jYQ4YYgsDU8bB4W9r/b8ry4S+4Dm8TOfPA7fXgayE= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784634563; c=relaxed/simple; bh=n+6V8MZEYNuMTfZWJYrG5/uWwDugg2aHPFbVBzCQOiQ=; h=From:To:Cc:Subject:Date:Message-Id:MIME-Version:Content-Type; b=mslxq/0Bm4Oi4B4JdTYgOvFRKO9UJ3CXruKURSgryL8cEvwotsctrQbN2p84uhlHZCAy2kwOrnQgCbPwIZWcsjKuG2w99Q0F28oJI0CW1ptiqw/C6WLtXnLNpIFnijFPV1U2OS7TAngbufQwvqqXlGqjguw8tFdDOLgbYaIcsjU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linux.alibaba.com; spf=pass smtp.mailfrom=linux.alibaba.com; dkim=pass (1024-bit key) header.d=linux.alibaba.com header.i=@linux.alibaba.com header.b=mYo5wCG1; arc=none smtp.client-ip=115.124.30.101 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linux.alibaba.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=linux.alibaba.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=linux.alibaba.com header.i=@linux.alibaba.com header.b="mYo5wCG1" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linux.alibaba.com; s=default; t=1784634557; h=From:To:Subject:Date:Message-Id:MIME-Version:Content-Type; bh=TlQBqXEKz2cBa162EBIUo9/YwhoWB5RUudVNVJH4xag=; b=mYo5wCG1EFiocdZuCh5UNlVtXtQ3Pr5zFoaK0qCOPfDDCDbhqfMczcmFKYf3obGS05Dt4ZfoTRBU9T0IQYa3s8OH6DdmMJR+X9sff5xZRUR7PDstd0GwR7VUHtrH7kFz74WpmzAvyAsJ1j59wyED8cGW69049A4Agw4tVlQmOJU= X-Alimail-AntiSpam: AC=PASS;BC=-1|-1;BR=01201311R171e4;CH=green;DM=||false|;DS=||;FP=0|-1|-1|-1|0|-1|-1|-1;HT=maildocker-contentspam033037026112;MF=joseph.qi@linux.alibaba.com;NM=1;PH=DS;RN=4;SR=0;TI=SMTPD_---0X7a1pAj_1784634556; Received: from localhost(mailfrom:joseph.qi@linux.alibaba.com fp:SMTPD_---0X7a1pAj_1784634556 cluster:ay36) by smtp.aliyun-inc.com; Tue, 21 Jul 2026 19:49:17 +0800 From: Joseph Qi To: Andrew Morton , Heming Zhao Cc: ocfs2-devel@lists.linux.dev, linux-kernel@vger.kernel.org Subject: [PATCH] ocfs2: cluster: don't sleep while holding o2hb_live_lock in o2hb_region_pin() Date: Tue, 21 Jul 2026 19:49:16 +0800 Message-Id: <20260721114916.2098617-1-joseph.qi@linux.alibaba.com> X-Mailer: git-send-email 2.39.3 Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable o2hb_region_pin() is always called with the o2hb_live_lock spinlock held (from o2hb_region_inc_user() and o2hb_heartbeat_group_drop_item()), but it calls o2nm_depend_item() -> configfs_depend_item(), which sleeps: it pins the configfs filesystem and takes the configfs root inode rwsem. Under CONFIG_DEBUG_ATOMIC_SLEEP this triggers: BUG: sleeping function called from invalid context at kernel/locking/rwse= m.c in_atomic(): 1, ... name: mount.ocfs2 down_write configfs_depend_item o2hb_region_pin o2hb_region_inc_user o2hb_register_callback dlm_register_domain_handlers ... ocfs2_dlm_init ocfs2_mount_volume ocfs2_fill_super Rework o2hb_region_pin() to pin one region at a time with the lock dropped across the sleeping call: under o2hb_live_lock find the next eligible region and take a config_item reference to keep it alive, drop the lock, call o2nm_depend_item(), then retake the lock and record the pin. The config_item_put() is done with the lock released as well, since o2hb_region_release() also acquires o2hb_live_lock and can sleep. The region list may change while unlocked, so the scan restarts from the top after each pin. Local heartbeat still pins only the matching region; global heartbeat pins all eligible regions. The unpin path is unaffected: configfs_undepend_item() only takes a spinlock and does not sleep. Fixes: 58a3158a5d17 ("ocfs2/cluster: Pin/unpin o2hb regions") Signed-off-by: Joseph Qi --- fs/ocfs2/cluster/heartbeat.c | 126 ++++++++++++++++++++++++++++------- 1 file changed, 101 insertions(+), 25 deletions(-) diff --git a/fs/ocfs2/cluster/heartbeat.c b/fs/ocfs2/cluster/heartbeat.c index 29542edbc992c..5ca1d9c0c6575 100644 --- a/fs/ocfs2/cluster/heartbeat.c +++ b/fs/ocfs2/cluster/heartbeat.c @@ -43,6 +43,14 @@ static DECLARE_RWSEM(o2hb_callback_sem); * whenever any of the threads sees activity from the node in its region. */ static DEFINE_SPINLOCK(o2hb_live_lock); +/* + * Serializes region pin/unpin dependency management (o2hb_dependent_users + * and the o2nm_depend_item()/o2nm_undepend_item() calls). o2hb_region_pin= () + * has to drop o2hb_live_lock across the sleeping o2nm_depend_item(), so t= he + * spinlock alone can no longer keep pin and unpin mutually exclusive; this + * mutex, taken outside o2hb_live_lock, does. + */ +static DEFINE_MUTEX(o2hb_dependency_mutex); static struct list_head o2hb_live_slots[O2NM_MAX_NODES]; static unsigned long o2hb_live_node_bitmap[BITS_TO_LONGS(O2NM_MAX_NODES)]; static LIST_HEAD(o2hb_node_events); @@ -2172,6 +2180,7 @@ static void o2hb_heartbeat_group_drop_item(struct con= fig_group *group, * If global heartbeat active and there are dependent users, * pin all regions if quorum region count <=3D CUT_OFF */ + mutex_lock(&o2hb_dependency_mutex); spin_lock(&o2hb_live_lock); =20 if (!o2hb_dependent_users) @@ -2183,6 +2192,7 @@ static void o2hb_heartbeat_group_drop_item(struct con= fig_group *group, =20 unlock: spin_unlock(&o2hb_live_lock); + mutex_unlock(&o2hb_dependency_mutex); } =20 static ssize_t o2hb_heartbeat_group_dead_threshold_show(struct config_item= *item, @@ -2322,46 +2332,108 @@ EXPORT_SYMBOL_GPL(o2hb_setup_callback); */ static int o2hb_region_pin(const char *region_uuid) { - int ret =3D 0, found =3D 0; - struct o2hb_region *reg; + int ret =3D 0, found; + struct o2hb_region *reg, *pinned; char *uuid; =20 assert_spin_locked(&o2hb_live_lock); =20 - list_for_each_entry(reg, &o2hb_all_regions, hr_all_item) { - if (reg->hr_item_dropped) - continue; + do { + found =3D 0; + pinned =3D NULL; =20 - uuid =3D config_item_name(®->hr_item); + list_for_each_entry(reg, &o2hb_all_regions, hr_all_item) { + if (reg->hr_item_dropped) + continue; =20 - /* local heartbeat */ - if (region_uuid) { - if (strcmp(region_uuid, uuid)) + uuid =3D config_item_name(®->hr_item); + + /* local heartbeat */ + if (region_uuid) { + if (strcmp(region_uuid, uuid)) + continue; + found =3D 1; + } + + if (reg->hr_item_pinned || reg->hr_item_dropped) { + if (found) + break; continue; - found =3D 1; + } + + /* + * Found a region that needs pinning. Take a reference + * so it stays alive while we drop the lock below. + */ + pinned =3D reg; + config_item_get(®->hr_item); + break; } =20 - if (reg->hr_item_pinned || reg->hr_item_dropped) - goto skip_pin; + if (!pinned) + break; + + uuid =3D config_item_name(&pinned->hr_item); + + /* + * o2nm_depend_item() -> configfs_depend_item() can sleep (it + * takes the configfs root inode rwsem), so it must not run + * under o2hb_live_lock. Drop the lock across it; @pinned is + * kept alive by the reference taken above. The region list may + * change while unlocked, so we rescan from the top afterwards. + */ + spin_unlock(&o2hb_live_lock); =20 /* Ignore ENOENT only for local hb (userdlm domain) */ - ret =3D o2nm_depend_item(®->hr_item); + ret =3D o2nm_depend_item(&pinned->hr_item); + + spin_lock(&o2hb_live_lock); if (!ret) { - mlog(ML_CLUSTER, "Pin region %s\n", uuid); - reg->hr_item_pinned =3D 1; - } else { - if (ret =3D=3D -ENOENT && found) - ret =3D 0; - else { - mlog(ML_ERROR, "Pin region %s fails with %d\n", - uuid, ret); + /* + * o2hb_live_lock was dropped across o2nm_depend_item(). + * o2hb_set_quorum_device() runs in the heartbeat thread + * without o2hb_dependency_mutex, so for global heartbeat + * it may have crossed O2HB_PIN_CUT_OFF and unpinned the + * regions while we slept. If that happened this pin is + * no longer wanted; undo it and stop rather than + * resurrecting it on the rescan below. + */ + if (!region_uuid && + bitmap_weight(o2hb_quorum_region_bitmap, + O2NM_MAX_REGIONS) > O2HB_PIN_CUT_OFF) { + o2nm_undepend_item(&pinned->hr_item); + spin_unlock(&o2hb_live_lock); + config_item_put(&pinned->hr_item); + spin_lock(&o2hb_live_lock); break; } + mlog(ML_CLUSTER, "Pin region %s\n", uuid); + pinned->hr_item_pinned =3D 1; + } else if (ret =3D=3D -ENOENT && (found || !region_uuid)) { + /* + * For local hb (found): ignore ENOENT from userdlm + * domains as before. For global hb (!region_uuid): + * the region may have been detached from configfs + * while the lock was dropped =E2=80=94 skip it and continue + * pinning the remaining regions. + */ + ret =3D 0; + } else { + mlog(ML_ERROR, "Pin region %s fails with %d\n", + uuid, ret); } -skip_pin: - if (found) - break; - } + + /* + * config_item_put() may drop the last reference and run + * o2hb_region_release(), which also grabs o2hb_live_lock and + * can sleep, so it must happen with the lock released. + */ + spin_unlock(&o2hb_live_lock); + config_item_put(&pinned->hr_item); + spin_lock(&o2hb_live_lock); + + /* local hb pins a single matching region */ + } while (!ret && !region_uuid); =20 return ret; } @@ -2406,6 +2478,7 @@ static int o2hb_region_inc_user(const char *region_uu= id) { int ret =3D 0; =20 + mutex_lock(&o2hb_dependency_mutex); spin_lock(&o2hb_live_lock); =20 /* local heartbeat */ @@ -2428,11 +2501,13 @@ static int o2hb_region_inc_user(const char *region_= uuid) =20 unlock: spin_unlock(&o2hb_live_lock); + mutex_unlock(&o2hb_dependency_mutex); return ret; } =20 static void o2hb_region_dec_user(const char *region_uuid) { + mutex_lock(&o2hb_dependency_mutex); spin_lock(&o2hb_live_lock); =20 /* local heartbeat */ @@ -2451,6 +2526,7 @@ static void o2hb_region_dec_user(const char *region_u= uid) =20 unlock: spin_unlock(&o2hb_live_lock); + mutex_unlock(&o2hb_dependency_mutex); } =20 int o2hb_register_callback(const char *region_uuid, --=20 2.39.3