From patchwork Wed Mar 26 11:22:15 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Luis Chamberlain X-Patchwork-Id: 14029986 Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (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 A66991D8DFB; Wed, 26 Mar 2025 11:22:27 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=198.137.202.133 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1742988150; cv=none; b=qhaLHNVOnI67FO0TaIeGnM8/lB4mFEw+Vv3bgj3PYuseKMuIDtHgBLf3K0sJOCXnL6rYyYPECX52Px4KF6nkvAfrKFyB95uy5f+LgdsNhS5KP8BDQnOSVUT8xB3xnCxw1FAt13vHcyaPpzc2tcIERDyrFBkXEvgRqsdJ5z8yTiw= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1742988150; c=relaxed/simple; bh=M/wSutNyy+ZGfJfHShf3iBWQw7da6uDLGlisrMuWiRo=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=c1fjCV216gRgfoYGzPbru4AtA0RKDfWqLdJvozNIXL6KcOZIx7bj6GgM6NAGyFob8EkUNE3/KtRoSpiJQ1zUzVSCrxjjUDyrnTFVY4vWjYlhsSX8lmTr5hoXwdqThCH7Tacky7oBTtnUCSJROhDneoPMy2ruBcbpPAojch37gEY= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=fail (p=quarantine dis=none) header.from=kernel.org; spf=none smtp.mailfrom=infradead.org; dkim=pass (2048-bit key) header.d=infradead.org header.i=@infradead.org header.b=rtNQg6Yk; arc=none smtp.client-ip=198.137.202.133 Authentication-Results: smtp.subspace.kernel.org; dmarc=fail (p=quarantine dis=none) header.from=kernel.org Authentication-Results: smtp.subspace.kernel.org; spf=none smtp.mailfrom=infradead.org Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=infradead.org header.i=@infradead.org header.b="rtNQg6Yk" DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=bombadil.20210309; h=Sender:Content-Transfer-Encoding: MIME-Version:References:In-Reply-To:Message-ID:Date:Subject:Cc:To:From: Reply-To:Content-Type:Content-ID:Content-Description; bh=8GbqvDo+p6D77xOjNMaIDYrw4/7pE8LqHMvAonozkEw=; b=rtNQg6YkIwEVOQso6nFzRhw1tG cfBwORfr+bWDBRGs0RgAOEJmxd4Nc0nlQ6WXKUvjeCc+D8V4ItCquagnOq3z32wonkWLz9BJZ7Fy7 yE+LKUKeBtzNC5bF6JdJ7sbb7E3DwZnfUYt1DhOFpe6AeyAttvJWD8ooh0O/QLsbvvb+vE3u7R6JG Yj4VouiLmIRcUC8+r/MrTJZAIpp76OviF2iSEjIdnwc81W5Fk24POjG7IBmGcfkFgCFYxSfDJuvGc HsWXawu149YsgzJBWqPfhNFQgV1bpReYmGFuf/AjpBYq1DbTDWF80zy5LIxcA65e33ADVLOQNTgz/ UH1Ekxqw==; Received: from mcgrof by bombadil.infradead.org with local (Exim 4.98.1 #2 (Red Hat Linux)) id 1txOq0-00000008LLk-2ikD; Wed, 26 Mar 2025 11:22:24 +0000 From: Luis Chamberlain To: jack@suse.cz, hch@infradead.org, James.Bottomley@HansenPartnership.com, david@fromorbit.com, rafael@kernel.org, djwong@kernel.org, pavel@kernel.org, song@kernel.org Cc: linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, gost.dev@samsung.com, Luis Chamberlain Subject: [RFC 1/6] fs: add frozen sb state helpers Date: Wed, 26 Mar 2025 04:22:15 -0700 Message-ID: <20250326112220.1988619-2-mcgrof@kernel.org> X-Mailer: git-send-email 2.49.0 In-Reply-To: <20250326112220.1988619-1-mcgrof@kernel.org> References: <20250326112220.1988619-1-mcgrof@kernel.org> Precedence: bulk X-Mailing-List: linux-fsdevel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Sender: Luis Chamberlain Provide helpers so that we can check a superblock frozen state. This will make subsequent changes easier to read. This makes no functional changes. Reviewed-by: Jan Kara Signed-off-by: Luis Chamberlain --- fs/ext4/ext4_jbd2.c | 2 +- fs/gfs2/sys.c | 2 +- fs/quota/quota.c | 3 ++- fs/super.c | 8 ++++---- fs/xfs/xfs_trans.c | 3 +-- include/linux/fs.h | 22 ++++++++++++++++++++++ 6 files changed, 31 insertions(+), 9 deletions(-) diff --git a/fs/ext4/ext4_jbd2.c b/fs/ext4/ext4_jbd2.c index 135e278c832e..5f5c2121d2ad 100644 --- a/fs/ext4/ext4_jbd2.c +++ b/fs/ext4/ext4_jbd2.c @@ -75,7 +75,7 @@ static int ext4_journal_check_start(struct super_block *sb) if (WARN_ON_ONCE(sb_rdonly(sb))) return -EROFS; - WARN_ON(sb->s_writers.frozen == SB_FREEZE_COMPLETE); + WARN_ON(sb_is_frozen(sb)); journal = EXT4_SB(sb)->s_journal; /* * Special case here: if the journal has aborted behind our diff --git a/fs/gfs2/sys.c b/fs/gfs2/sys.c index ecc699f8d9fc..08ec5904a208 100644 --- a/fs/gfs2/sys.c +++ b/fs/gfs2/sys.c @@ -156,7 +156,7 @@ static ssize_t uuid_show(struct gfs2_sbd *sdp, char *buf) static ssize_t freeze_show(struct gfs2_sbd *sdp, char *buf) { struct super_block *sb = sdp->sd_vfs; - int frozen = (sb->s_writers.frozen == SB_UNFROZEN) ? 0 : 1; + int frozen = sb_is_unfrozen(sb) ? 0 : 1; return snprintf(buf, PAGE_SIZE, "%d\n", frozen); } diff --git a/fs/quota/quota.c b/fs/quota/quota.c index 7c2b75a44485..9b4e0a80f386 100644 --- a/fs/quota/quota.c +++ b/fs/quota/quota.c @@ -890,11 +890,12 @@ static struct super_block *quotactl_block(const char __user *special, int cmd) sb = user_get_super(dev, excl); if (!sb) return ERR_PTR(-ENODEV); - if (thawed && sb->s_writers.frozen != SB_UNFROZEN) { + if (thawed && !sb_is_unfrozen(sb)) { if (excl) up_write(&sb->s_umount); else up_read(&sb->s_umount); + /* Wait for sb to unfreeze */ sb_start_write(sb); sb_end_write(sb); diff --git a/fs/super.c b/fs/super.c index 97a17f9d9023..117bd1bfe09f 100644 --- a/fs/super.c +++ b/fs/super.c @@ -1029,7 +1029,7 @@ int reconfigure_super(struct fs_context *fc) if (fc->sb_flags_mask & ~MS_RMT_MASK) return -EINVAL; - if (sb->s_writers.frozen != SB_UNFROZEN) + if (!(sb_is_unfrozen(sb))) return -EBUSY; retval = security_sb_remount(sb, fc->security); @@ -1053,7 +1053,7 @@ int reconfigure_super(struct fs_context *fc) __super_lock_excl(sb); if (!sb->s_root) return 0; - if (sb->s_writers.frozen != SB_UNFROZEN) + if (!sb_is_unfrozen(sb)) return -EBUSY; remount_ro = !sb_rdonly(sb); } @@ -2009,7 +2009,7 @@ int freeze_super(struct super_block *sb, enum freeze_holder who) atomic_inc(&sb->s_active); retry: - if (sb->s_writers.frozen == SB_FREEZE_COMPLETE) { + if (sb_is_frozen(sb)) { if (may_freeze(sb, who)) ret = !!WARN_ON_ONCE(freeze_inc(sb, who) == 1); else @@ -2019,7 +2019,7 @@ int freeze_super(struct super_block *sb, enum freeze_holder who) return ret; } - if (sb->s_writers.frozen != SB_UNFROZEN) { + if (sb_is_unfrozen(sb)) { ret = wait_for_partially_frozen(sb); if (ret) { deactivate_locked_super(sb); diff --git a/fs/xfs/xfs_trans.c b/fs/xfs/xfs_trans.c index c6657072361a..3a5088865064 100644 --- a/fs/xfs/xfs_trans.c +++ b/fs/xfs/xfs_trans.c @@ -269,8 +269,7 @@ xfs_trans_alloc( * Zero-reservation ("empty") transactions can't modify anything, so * they're allowed to run while we're frozen. */ - WARN_ON(resp->tr_logres > 0 && - mp->m_super->s_writers.frozen == SB_FREEZE_COMPLETE); + WARN_ON(resp->tr_logres > 0 && sb_is_frozen(mp->m_super)); ASSERT(!(flags & XFS_TRANS_RES_FDBLKS) || xfs_has_lazysbcount(mp)); diff --git a/include/linux/fs.h b/include/linux/fs.h index 016b0fe1536e..1d9a9c557e1a 100644 --- a/include/linux/fs.h +++ b/include/linux/fs.h @@ -1971,6 +1971,28 @@ static inline bool sb_start_intwrite_trylock(struct super_block *sb) return __sb_start_write_trylock(sb, SB_FREEZE_FS); } +/** + * sb_is_frozen - is superblock frozen + * @sb: the super to check + * + * Returns true if the super is frozen. + */ +static inline bool sb_is_frozen(struct super_block *sb) +{ + return sb->s_writers.frozen == SB_FREEZE_COMPLETE; +} + +/** + * sb_is_unfrozen - is superblock unfrozen + * @sb: the super to check + * + * Returns true if the super is unfrozen. + */ +static inline bool sb_is_unfrozen(struct super_block *sb) +{ + return sb->s_writers.frozen == SB_UNFROZEN; +} + bool inode_owner_or_capable(struct mnt_idmap *idmap, const struct inode *inode); From patchwork Wed Mar 26 11:22:16 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Luis Chamberlain X-Patchwork-Id: 14029980 Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (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 741B41C84BB; Wed, 26 Mar 2025 11:22:27 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=198.137.202.133 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1742988149; cv=none; b=HdbCCuqmCIN74UBGh2HPm9WK/I5C+zh6o0vgzFjAXhTB+NF9nmP77O2n7gtJv66cZHr/QZlq0i+wghSkShn5fsFFOo6mm5rO+HmU0yV8/ytgOQZwykSusCBlYcC4FZI59VJPunK0+kI34kBxGgfy1BNQ6WP106Y+hstUR7zpduA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1742988149; c=relaxed/simple; bh=KbPXXfRMPMbRC7rd9iUF2nVKYlz6F7zzKUNd4WnEUvg=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=ncZvzgnQ+lT782lsf3+22zsxPpahC0seHVFSb/TLjTVZ4ym4Lnlm6OM6uWvMm7Y19zZo1JyaurqfdGpGMw+2QhVh6/IvJofANKyVj7nZpxps6Jyqxi5xXbZmTUULmNZh4fMStC1JHDm3y8tcTOq8K9e+DaRLnLHVJFeayj6UUQk= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=fail (p=quarantine dis=none) header.from=kernel.org; spf=none smtp.mailfrom=infradead.org; dkim=pass (2048-bit key) header.d=infradead.org header.i=@infradead.org header.b=GbbtMXX1; arc=none smtp.client-ip=198.137.202.133 Authentication-Results: smtp.subspace.kernel.org; dmarc=fail (p=quarantine dis=none) header.from=kernel.org Authentication-Results: smtp.subspace.kernel.org; spf=none smtp.mailfrom=infradead.org Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=infradead.org header.i=@infradead.org header.b="GbbtMXX1" DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=bombadil.20210309; h=Sender:Content-Transfer-Encoding: MIME-Version:References:In-Reply-To:Message-ID:Date:Subject:Cc:To:From: Reply-To:Content-Type:Content-ID:Content-Description; bh=Y+mzxJMNAix6hEe0DMlkLUt+uC5JhVrR/pZpXYCHRMQ=; b=GbbtMXX1LGV/vYNBrFxO31ruQ0 Fj4L4U+vbfbUqhqNJvYtrfZ4GoazeLoUu5LrWE7OmsSNj/oU2YQtwTsji286abAbmEwSwsvJmp9or Qm0pHSHnD/rrM3Oyo/MTmwEQFgxygLiLWk7rqz75IhunfwUIVH0L2yAl886cLGIQmginu9TriXV54 22Vc4OO+D5syZRjUnaKENEpdjDg+OPmREuPvFejz6H1DAg6/PNRWdYnSXBWxyfJa1YIMEZ8VUMmpV 25xuT8jqEWNjfwO/eB2ulr8/jXI+e/nDV2T2S95K/5NJXP5EqTjDXBcbGscHaJYOsWaPZMeOLmeLm hZrZjTyA==; Received: from mcgrof by bombadil.infradead.org with local (Exim 4.98.1 #2 (Red Hat Linux)) id 1txOq0-00000008LLq-2wo8; Wed, 26 Mar 2025 11:22:24 +0000 From: Luis Chamberlain To: jack@suse.cz, hch@infradead.org, James.Bottomley@HansenPartnership.com, david@fromorbit.com, rafael@kernel.org, djwong@kernel.org, pavel@kernel.org, song@kernel.org Cc: linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, gost.dev@samsung.com, Luis Chamberlain Subject: [RFC 2/6] fs: add iterate_supers_excl() and iterate_supers_reverse_excl() Date: Wed, 26 Mar 2025 04:22:16 -0700 Message-ID: <20250326112220.1988619-3-mcgrof@kernel.org> X-Mailer: git-send-email 2.49.0 In-Reply-To: <20250326112220.1988619-1-mcgrof@kernel.org> References: <20250326112220.1988619-1-mcgrof@kernel.org> Precedence: bulk X-Mailing-List: linux-fsdevel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Sender: Luis Chamberlain There are use cases where we wish to traverse the superblock list but also capture errors, and in which case we want to avoid having our callers issue a lock themselves since we can do the locking for the callers. Provide a iterate_supers_excl() which calls a function with the write lock held. If an error occurs we capture it and propagate it. Likewise there are use cases where we wish to traverse the superblock list but in reverse order. The new iterate_supers_reverse_excl() helpers does this but also also captures any errors encountered. Reviewed-by: Jan Kara Signed-off-by: Luis Chamberlain --- fs/super.c | 91 ++++++++++++++++++++++++++++++++++++++++++++++ include/linux/fs.h | 2 + 2 files changed, 93 insertions(+) diff --git a/fs/super.c b/fs/super.c index 117bd1bfe09f..9995546cf159 100644 --- a/fs/super.c +++ b/fs/super.c @@ -945,6 +945,97 @@ void iterate_supers(void (*f)(struct super_block *, void *), void *arg) spin_unlock(&sb_lock); } +/** + * iterate_supers_excl - exclusively call func for all active superblocks + * @f: function to call + * @arg: argument to pass to it + * + * Scans the superblock list and calls given function, passing it + * locked superblock and given argument. Returns 0 unless an error + * occurred on calling the function on any superblock. + */ +int iterate_supers_excl(int (*f)(struct super_block *, void *), void *arg) +{ + struct super_block *sb, *p = NULL; + int error = 0; + + spin_lock(&sb_lock); + list_for_each_entry(sb, &super_blocks, s_list) { + if (hlist_unhashed(&sb->s_instances)) + continue; + sb->s_count++; + spin_unlock(&sb_lock); + + down_write(&sb->s_umount); + if (sb->s_root && (sb->s_flags & SB_BORN)) { + error = f(sb, arg); + if (error) { + up_write(&sb->s_umount); + spin_lock(&sb_lock); + __put_super(sb); + break; + } + } + up_write(&sb->s_umount); + + spin_lock(&sb_lock); + if (p) + __put_super(p); + p = sb; + } + if (p) + __put_super(p); + spin_unlock(&sb_lock); + + return error; +} + +/** + * iterate_supers_reverse_excl - exclusively calls func in reverse order + * @f: function to call + * @arg: argument to pass to it + * + * Scans the superblock list and calls given function, passing it + * locked superblock and given argument, in reverse order, and holding + * the s_umount write lock. Returns if an error occurred. + */ +int iterate_supers_reverse_excl(int (*f)(struct super_block *, void *), + void *arg) +{ + struct super_block *sb, *p = NULL; + int error = 0; + + spin_lock(&sb_lock); + list_for_each_entry_reverse(sb, &super_blocks, s_list) { + if (hlist_unhashed(&sb->s_instances)) + continue; + sb->s_count++; + spin_unlock(&sb_lock); + + down_write(&sb->s_umount); + if (sb->s_root && (sb->s_flags & SB_BORN)) { + error = f(sb, arg); + if (error) { + up_write(&sb->s_umount); + spin_lock(&sb_lock); + __put_super(sb); + break; + } + } + up_write(&sb->s_umount); + + spin_lock(&sb_lock); + if (p) + __put_super(p); + p = sb; + } + if (p) + __put_super(p); + spin_unlock(&sb_lock); + + return error; +} + /** * iterate_supers_type - call function for superblocks of given type * @type: fs type diff --git a/include/linux/fs.h b/include/linux/fs.h index 1d9a9c557e1a..da17fd74961c 100644 --- a/include/linux/fs.h +++ b/include/linux/fs.h @@ -3538,6 +3538,8 @@ extern struct file_system_type *get_fs_type(const char *name); extern void drop_super(struct super_block *sb); extern void drop_super_exclusive(struct super_block *sb); extern void iterate_supers(void (*)(struct super_block *, void *), void *); +extern int iterate_supers_excl(int (*f)(struct super_block *, void *), void *arg); +extern int iterate_supers_reverse_excl(int (*)(struct super_block *, void *), void *); extern void iterate_supers_type(struct file_system_type *, void (*)(struct super_block *, void *), void *); From patchwork Wed Mar 26 11:22:17 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Luis Chamberlain X-Patchwork-Id: 14029984 Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (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 A66441D8DE0; Wed, 26 Mar 2025 11:22:27 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=198.137.202.133 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1742988149; cv=none; b=dgk2Ac86Py2RPSZsqnXVbGUmoqcgm2c+1zPR4Eni3kiMP/dNvW8UkbfCPkDhzMerzKNGyNzp507d9ZBO+kyZbJb+Upl62MVDeKq8W6QfDGHEqIamPC56mlnnO+EU1yciIoJu+gn8zxnXiF4HpvIbZ1fq3VJSrSGfFnNijSsKlmQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1742988149; c=relaxed/simple; bh=cHgdN7gWDB4dt77oGk/eTkwyIMD7VtmKnRK3RgBWl6w=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=TogsOSJA/bwyrFn/WKet1RABytwmtn1v47ma280BFenjS0XxEBoEUG8Yn+t5awUOesY1zB0WIK4wvx1nMHwEsmeEAftgqrFbXnSY4E5/9iD5dX6Q8n8k2CiEX+kp3hjrwk1VP+mHxzaTrf47nJyyPvpMGmGKTpVJ11cx1vJfOsQ= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=fail (p=quarantine dis=none) header.from=kernel.org; spf=none smtp.mailfrom=infradead.org; dkim=pass (2048-bit key) header.d=infradead.org header.i=@infradead.org header.b=h36czRjN; arc=none smtp.client-ip=198.137.202.133 Authentication-Results: smtp.subspace.kernel.org; dmarc=fail (p=quarantine dis=none) header.from=kernel.org Authentication-Results: smtp.subspace.kernel.org; spf=none smtp.mailfrom=infradead.org Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=infradead.org header.i=@infradead.org header.b="h36czRjN" DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=bombadil.20210309; h=Sender:Content-Transfer-Encoding: MIME-Version:References:In-Reply-To:Message-ID:Date:Subject:Cc:To:From: Reply-To:Content-Type:Content-ID:Content-Description; bh=+MGNjMu3WNO8uPE/bWA2D/wE7wdDKnoflkN5EGzt/Vg=; b=h36czRjNdUVA53MmC5yclcX5qo DsUksJKxA9gYvKCw49INTEkXKbTScwesZ6/c4OY70Lr1Mj8Ex64XWCKik7eyUM8JSHI86B0znWwj7 oQi2CieuSHfUlfdUu4aPV80b8K+57y8vwVg36L2O4X9BNwHNdyTPw9sjgo5mE7VP0+kU50PAbHoQR 8/eLKNdVFx3H+z9WFEFcHCbY6AaayTjEc8GdrWhrIO4Pcrre62H77f2KC1rTCP2OIEyHeHiOxVdU5 8mLsVgsFdsldIEtqjMksrAfSYwu4fouAvZagSch4RAEVwgKknRZlV11YXY9KydB5vE/LFETdSo8H6 +sXp1NXQ==; Received: from mcgrof by bombadil.infradead.org with local (Exim 4.98.1 #2 (Red Hat Linux)) id 1txOq0-00000008LLz-36Vw; Wed, 26 Mar 2025 11:22:24 +0000 From: Luis Chamberlain To: jack@suse.cz, hch@infradead.org, James.Bottomley@HansenPartnership.com, david@fromorbit.com, rafael@kernel.org, djwong@kernel.org, pavel@kernel.org, song@kernel.org Cc: linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, gost.dev@samsung.com, Luis Chamberlain Subject: [RFC 3/6] fs: add automatic kernel fs freeze / thaw and remove kthread freezing Date: Wed, 26 Mar 2025 04:22:17 -0700 Message-ID: <20250326112220.1988619-4-mcgrof@kernel.org> X-Mailer: git-send-email 2.49.0 In-Reply-To: <20250326112220.1988619-1-mcgrof@kernel.org> References: <20250326112220.1988619-1-mcgrof@kernel.org> Precedence: bulk X-Mailing-List: linux-fsdevel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Sender: Luis Chamberlain Add support to automatically handle freezing and thawing filesystems during the kernel's suspend/resume cycle. This is needed so that we properly really stop IO in flight without races after userspace has been frozen. Without this we rely on kthread freezing and its semantics are loose and error prone. For instance, even though a kthread may use try_to_freeze() and end up being frozen we have no way of being sure that everything that has been spawned asynchronously from it (such as timers) have also been stopped as well. A long term advantage of also adding filesystem freeze / thawing supporting during suspend / hibernation is that long term we may be able to eventually drop the kernel's thread freezing completely as it was originally added to stop disk IO in flight as we hibernate or suspend. This does not remove the superfluous freezer calls on all filesystems. Each filesystem must remove all the kthread freezer stuff and peg the fs_type flags as supporting auto-freezing with the FS_AUTOFREEZE flag. Subsequent patches remove the kthread freezer usage from each filesystem, one at a time to make all this work bisectable. Once all filesystems remove the usage of the kthread freezer we can remove the FS_AUTOFREEZE flag. Reviewed-by: Jan Kara Signed-off-by: Luis Chamberlain --- fs/super.c | 50 ++++++++++++++++++++++++++++++++++++++++++ include/linux/fs.h | 14 ++++++++++++ kernel/power/process.c | 15 ++++++++++++- 3 files changed, 78 insertions(+), 1 deletion(-) diff --git a/fs/super.c b/fs/super.c index 9995546cf159..7428f0b2251c 100644 --- a/fs/super.c +++ b/fs/super.c @@ -2279,3 +2279,53 @@ int sb_init_dio_done_wq(struct super_block *sb) return 0; } EXPORT_SYMBOL_GPL(sb_init_dio_done_wq); + +#ifdef CONFIG_PM_SLEEP +static bool super_should_freeze(struct super_block *sb) +{ + if (!(sb->s_type->fs_flags & FS_AUTOFREEZE)) + return false; + /* + * We don't freeze virtual filesystems, we skip those filesystems with + * no backing device. + */ + if (sb->s_bdi == &noop_backing_dev_info) + return false; + + return true; +} + +int fs_suspend_freeze_sb(struct super_block *sb, void *priv) +{ + int error = 0; + + if (!super_should_freeze(sb)) + goto out; + + pr_info("%s (%s): freezing\n", sb->s_type->name, sb->s_id); + + error = freeze_super(sb, false); + if (error && error != -EBUSY) + pr_notice("%s (%s): Unable to freeze, error=%d", + sb->s_type->name, sb->s_id, error); +out: + return error; +} + +int fs_suspend_thaw_sb(struct super_block *sb, void *priv) +{ + int error = 0; + + if (!super_should_freeze(sb)) + goto out; + + pr_info("%s (%s): thawing\n", sb->s_type->name, sb->s_id); + + error = thaw_super(sb, false); + if (error && error != -EBUSY) + pr_notice("%s (%s): Unable to unfreeze, error=%d", + sb->s_type->name, sb->s_id, error); +out: + return error; +} +#endif /* CONFIG_PM_SLEEP */ diff --git a/include/linux/fs.h b/include/linux/fs.h index da17fd74961c..e0614c3d376e 100644 --- a/include/linux/fs.h +++ b/include/linux/fs.h @@ -2638,6 +2638,7 @@ struct file_system_type { #define FS_MGTIME 64 /* FS uses multigrain timestamps */ #define FS_LBS 128 /* FS supports LBS */ #define FS_RENAME_DOES_D_MOVE 32768 /* FS will handle d_move() during rename() internally. */ +#define FS_AUTOFREEZE (1<<16) /* temporary as we phase kthread freezer out */ int (*init_fs_context)(struct fs_context *); const struct fs_parameter_spec *parameters; struct dentry *(*mount) (struct file_system_type *, int, @@ -2729,6 +2730,19 @@ extern int user_statfs(const char __user *, struct kstatfs *); extern int fd_statfs(int, struct kstatfs *); int freeze_super(struct super_block *super, enum freeze_holder who); int thaw_super(struct super_block *super, enum freeze_holder who); +#ifdef CONFIG_PM_SLEEP +int fs_suspend_freeze_sb(struct super_block *sb, void *priv); +int fs_suspend_thaw_sb(struct super_block *sb, void *priv); +#else +static inline int fs_suspend_freeze_sb(struct super_block *sb, void *priv) +{ + return 0; +} +static inline int fs_suspend_thaw_sb(struct super_block *sb, void *priv) +{ + return 0; +} +#endif extern __printf(2, 3) int super_setup_bdi_name(struct super_block *sb, char *fmt, ...); extern int super_setup_bdi(struct super_block *sb); diff --git a/kernel/power/process.c b/kernel/power/process.c index 66ac067d9ae6..d0f540a89c39 100644 --- a/kernel/power/process.c +++ b/kernel/power/process.c @@ -140,6 +140,16 @@ int freeze_processes(void) BUG_ON(in_atomic()); + pr_info("Freezing filesystems ... "); + error = iterate_supers_reverse_excl(fs_suspend_freeze_sb, NULL); + if (error) { + pr_cont("failed\n"); + iterate_supers_excl(fs_suspend_thaw_sb, NULL); + thaw_processes(); + return error; + } + pr_cont("done.\n"); + /* * Now that the whole userspace is frozen we need to disable * the OOM killer to disallow any further interference with @@ -149,8 +159,10 @@ int freeze_processes(void) if (!error && !oom_killer_disable(msecs_to_jiffies(freeze_timeout_msecs))) error = -EBUSY; - if (error) + if (error) { + iterate_supers_excl(fs_suspend_thaw_sb, NULL); thaw_processes(); + } return error; } @@ -188,6 +200,7 @@ void thaw_processes(void) pm_nosig_freezing = false; oom_killer_enable(); + iterate_supers_excl(fs_suspend_thaw_sb, NULL); pr_info("Restarting tasks ... "); From patchwork Wed Mar 26 11:22:18 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Luis Chamberlain X-Patchwork-Id: 14029985 Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (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 742101C8635; Wed, 26 Mar 2025 11:22:27 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=198.137.202.133 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1742988149; cv=none; b=uuBAQW2mLOIlEogvUibPU7NtBD63aI3FPH+rAbiLWcqb+9gIrhVVfQUpW6D9FkCd1qInf6UkbfdbLSX3X3eNbcyuYmsln7UGn7eHTzzvfK+4ajQ770lfE3Oyo+tor01f5y+7z+xbyX+Pm+j1M37Kxzdo3KAv+Dl9dczK823gRig= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1742988149; c=relaxed/simple; bh=7oEB3iyiQ+3DRRjgaNKNQIcZL+vSTPPPNL/kxJwh2i0=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=Aq3MfNEtYo/8zQNadLXtl59w8SfaD4vrRxUBxSGR0hx/3/B6oAXbq9s807uwbsGyE9iWH7AM1UbDOwAzxAGoSvft106Geh/uHDw6wVWVf4Z5Ut3JhZJkL4rtAxfH1/Z0F38FVcl3H4j/fFfeD8rdJOc1iYUAcXCSjMcamGdAEaw= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=fail (p=quarantine dis=none) header.from=kernel.org; spf=none smtp.mailfrom=infradead.org; dkim=pass (2048-bit key) header.d=infradead.org header.i=@infradead.org header.b=E2HwO4rh; arc=none smtp.client-ip=198.137.202.133 Authentication-Results: smtp.subspace.kernel.org; dmarc=fail (p=quarantine dis=none) header.from=kernel.org Authentication-Results: smtp.subspace.kernel.org; spf=none smtp.mailfrom=infradead.org Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=infradead.org header.i=@infradead.org header.b="E2HwO4rh" DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=bombadil.20210309; h=Sender:Content-Transfer-Encoding: MIME-Version:References:In-Reply-To:Message-ID:Date:Subject:Cc:To:From: Reply-To:Content-Type:Content-ID:Content-Description; bh=84t0ULXhvJVB5iCtiqB96HKwPHTuYkS+RDsGjxv7yJ8=; b=E2HwO4rhIJg+H9626l3KLfQDl9 y/6dLebcHCJYdXQiHUwNc31o2HC9poJGeOKH0wQjmlXC7bGya+pRLUj2qj/pOEIQ0b6/d1Cj2KISI k17P04jGFxiKwfplwfIAVfGSB434gBGIECpfP1YM5eOdVFX0OWfnmrcnQ1oAChucfn2SmaEHGN4K0 igiMYj9/o9OC/tcwxfz5wlQXq9S3TP89E8xJi/j6qwoUL6bEBToFzbQMOh6RaPFHx1N7TLfHOSMue SE3TDWXkpN9x5+Z9kGAVc96M3LnVxMk7lJWFavWaECSPl24lu6pHyEQw5+j+J8r9ftvs19LzvFnIb ryZiGwRw==; Received: from mcgrof by bombadil.infradead.org with local (Exim 4.98.1 #2 (Red Hat Linux)) id 1txOq0-00000008LM5-3FP6; Wed, 26 Mar 2025 11:22:24 +0000 From: Luis Chamberlain To: jack@suse.cz, hch@infradead.org, James.Bottomley@HansenPartnership.com, david@fromorbit.com, rafael@kernel.org, djwong@kernel.org, pavel@kernel.org, song@kernel.org Cc: linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, gost.dev@samsung.com, Luis Chamberlain Subject: [RFC 4/6] ext4: replace kthread freezing with auto fs freezing Date: Wed, 26 Mar 2025 04:22:18 -0700 Message-ID: <20250326112220.1988619-5-mcgrof@kernel.org> X-Mailer: git-send-email 2.49.0 In-Reply-To: <20250326112220.1988619-1-mcgrof@kernel.org> References: <20250326112220.1988619-1-mcgrof@kernel.org> Precedence: bulk X-Mailing-List: linux-fsdevel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Sender: Luis Chamberlain The kernel power management now supports allowing the VFS to handle filesystem freezing freezes and thawing. Take advantage of that and remove the kthread freezing. This is needed so that we properly really stop IO in flight without races after userspace has been frozen. Without this we rely on kthread freezing and its semantics are loose and error prone. The filesystem therefore is in charge of properly dealing with quiescing of the filesystem through its callbacks if it thinks it knows better than how the VFS handles it. The following Coccinelle rule was used as to remove the now superfluous freezer calls: make coccicheck MODE=patch SPFLAGS="--in-place --no-show-diff" COCCI=./fs-freeze-cleanup.cocci M=fs/ext4 virtual patch @ remove_set_freezable @ expression time; statement S, S2; expression task, current; @@ ( - set_freezable(); | - if (try_to_freeze()) - continue; | - try_to_freeze(); | - freezable_schedule(); + schedule(); | - freezable_schedule_timeout(time); + schedule_timeout(time); | - if (freezing(task)) { S } | - if (freezing(task)) { S } - else { S2 } | - freezing(current) ) @ remove_wq_freezable @ expression WQ_E, WQ_ARG1, WQ_ARG2, WQ_ARG3, WQ_ARG4; identifier fs_wq_fn; @@ ( WQ_E = alloc_workqueue(WQ_ARG1, - WQ_ARG2 | WQ_FREEZABLE, + WQ_ARG2, ...); | WQ_E = alloc_workqueue(WQ_ARG1, - WQ_ARG2 | WQ_FREEZABLE | WQ_ARG3, + WQ_ARG2 | WQ_ARG3, ...); | WQ_E = alloc_workqueue(WQ_ARG1, - WQ_ARG2 | WQ_ARG3 | WQ_FREEZABLE, + WQ_ARG2 | WQ_ARG3, ...); | WQ_E = alloc_workqueue(WQ_ARG1, - WQ_ARG2 | WQ_ARG3 | WQ_FREEZABLE | WQ_ARG4, + WQ_ARG2 | WQ_ARG3 | WQ_ARG4, ...); | WQ_E = - WQ_ARG1 | WQ_FREEZABLE + WQ_ARG1 | WQ_E = - WQ_ARG1 | WQ_FREEZABLE | WQ_ARG3 + WQ_ARG1 | WQ_ARG3 | fs_wq_fn( - WQ_FREEZABLE | WQ_ARG2 | WQ_ARG3 + WQ_ARG2 | WQ_ARG3 ) | fs_wq_fn( - WQ_FREEZABLE | WQ_ARG2 + WQ_ARG2 ) | fs_wq_fn( - WQ_FREEZABLE + 0 ) ) @ add_auto_flag @ expression E1; identifier fs_type; @@ struct file_system_type fs_type = { .fs_flags = E1 + | FS_AUTOFREEZE , }; Generated-by: Coccinelle SmPL Signed-off-by: Luis Chamberlain --- fs/ext4/mballoc.c | 2 +- fs/ext4/super.c | 9 +++------ 2 files changed, 4 insertions(+), 7 deletions(-) diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c index 0d523e9fb3d5..ae235ec5ff3a 100644 --- a/fs/ext4/mballoc.c +++ b/fs/ext4/mballoc.c @@ -6782,7 +6782,7 @@ static ext4_grpblk_t ext4_last_grp_cluster(struct super_block *sb, static bool ext4_trim_interrupted(void) { - return fatal_signal_pending(current) || freezing(current); + return fatal_signal_pending(current); } static int ext4_try_to_trim_range(struct super_block *sb, diff --git a/fs/ext4/super.c b/fs/ext4/super.c index 8cafcd3e9f5f..4241043262c8 100644 --- a/fs/ext4/super.c +++ b/fs/ext4/super.c @@ -136,7 +136,7 @@ static struct file_system_type ext2_fs_type = { .init_fs_context = ext4_init_fs_context, .parameters = ext4_param_specs, .kill_sb = ext4_kill_sb, - .fs_flags = FS_REQUIRES_DEV, + .fs_flags = FS_REQUIRES_DEV | FS_AUTOFREEZE, }; MODULE_ALIAS_FS("ext2"); MODULE_ALIAS("ext2"); @@ -152,7 +152,7 @@ static struct file_system_type ext3_fs_type = { .init_fs_context = ext4_init_fs_context, .parameters = ext4_param_specs, .kill_sb = ext4_kill_sb, - .fs_flags = FS_REQUIRES_DEV, + .fs_flags = FS_REQUIRES_DEV | FS_AUTOFREEZE, }; MODULE_ALIAS_FS("ext3"); MODULE_ALIAS("ext3"); @@ -3776,7 +3776,6 @@ static int ext4_lazyinit_thread(void *arg) unsigned long next_wakeup, cur; BUG_ON(NULL == eli); - set_freezable(); cont_thread: while (true) { @@ -3835,8 +3834,6 @@ static int ext4_lazyinit_thread(void *arg) } mutex_unlock(&eli->li_list_mtx); - try_to_freeze(); - cur = jiffies; if (!next_wakeup_initialized || time_after_eq(cur, next_wakeup)) { cond_resched(); @@ -7404,7 +7401,7 @@ static struct file_system_type ext4_fs_type = { .init_fs_context = ext4_init_fs_context, .parameters = ext4_param_specs, .kill_sb = ext4_kill_sb, - .fs_flags = FS_REQUIRES_DEV | FS_ALLOW_IDMAP | FS_MGTIME, + .fs_flags = FS_REQUIRES_DEV | FS_ALLOW_IDMAP | FS_MGTIME | FS_AUTOFREEZE, }; MODULE_ALIAS_FS("ext4"); From patchwork Wed Mar 26 11:22:19 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Luis Chamberlain X-Patchwork-Id: 14029983 Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (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 A65D61D7E54; Wed, 26 Mar 2025 11:22:27 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=198.137.202.133 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1742988149; cv=none; b=NGu2YS679PkKrsvzaUAiJelVaMlCWNdHLaCf38LySLGaO6Je+6S0N65Mao1ANBxgtnYtl7HYfqGU80GStmLgPq1OFFSMd4CerzriH4fJQv8zpAlmt5+5bMNdtcAbbeuTesmHkkvVAz5ricqenb1+I4pz90d4/B5f9ttCCdCsjfk= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1742988149; c=relaxed/simple; bh=hQmD8Ne/zZ/7oILam905jmXxWAOBDGDDhXw5kV1cutY=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=mCLvgiigdj9O1f43b7fl5FttciLMLQYRf5PiEGfrBPPxtnKUzeoqjgtjGUXY2yNfPSvd7UoE5ujq8XP7uTjKmlJjhQ4Yl5oMlqPOrH4b5lMKDxTOkBksfMDzYYITEoRowCyY63yRPc8et/arJ7VnadMZ3eliMQ9xMsK7MXsigR0= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=fail (p=quarantine dis=none) header.from=kernel.org; spf=none smtp.mailfrom=infradead.org; dkim=pass (2048-bit key) header.d=infradead.org header.i=@infradead.org header.b=VrLxQf1m; arc=none smtp.client-ip=198.137.202.133 Authentication-Results: smtp.subspace.kernel.org; dmarc=fail (p=quarantine dis=none) header.from=kernel.org Authentication-Results: smtp.subspace.kernel.org; spf=none smtp.mailfrom=infradead.org Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=infradead.org header.i=@infradead.org header.b="VrLxQf1m" DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=bombadil.20210309; h=Sender:Content-Transfer-Encoding: MIME-Version:References:In-Reply-To:Message-ID:Date:Subject:Cc:To:From: Reply-To:Content-Type:Content-ID:Content-Description; bh=pdczgHoQ3gJoGYNTPNCpioUWf2FhTA/MekqoAmjq6go=; b=VrLxQf1mv7g2AsZ9CjHeHgjGTp coHNkOSAclf5NumdxeToua2tseVq70wGIMOAmROTVso5X/mSMQFDC84jspLT6HMclEWIO+BhsLwX2 0R0TLQz0+AokaMad0DJBq0s6/NQExIFog8syQqc0koMymLuEZgT1wHe0Sh1OtmkzalHKhIzcuOzU2 LKXaDsBr+cLlMllkXm7BCy+4zDMdlo+MQinOmGzTI8Jaa9g5rsZgIZ8+tIW25sRYRxK9MWRHWFOjJ OxinKT8FQQHM2IyY6lfiDPoBcM8aC3/GCWUZdVNjs+SZsg7iZ+jUhrcvZIgFEIPR6JcbKNxpyck0B wTwG/+rw==; Received: from mcgrof by bombadil.infradead.org with local (Exim 4.98.1 #2 (Red Hat Linux)) id 1txOq0-00000008LM8-3O8f; Wed, 26 Mar 2025 11:22:24 +0000 From: Luis Chamberlain To: jack@suse.cz, hch@infradead.org, James.Bottomley@HansenPartnership.com, david@fromorbit.com, rafael@kernel.org, djwong@kernel.org, pavel@kernel.org, song@kernel.org Cc: linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, gost.dev@samsung.com, Luis Chamberlain Subject: [RFC 5/6] btrfs: replace kthread freezing with auto fs freezing Date: Wed, 26 Mar 2025 04:22:19 -0700 Message-ID: <20250326112220.1988619-6-mcgrof@kernel.org> X-Mailer: git-send-email 2.49.0 In-Reply-To: <20250326112220.1988619-1-mcgrof@kernel.org> References: <20250326112220.1988619-1-mcgrof@kernel.org> Precedence: bulk X-Mailing-List: linux-fsdevel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Sender: Luis Chamberlain The kernel power management now supports allowing the VFS to handle filesystem freezing freezes and thawing. Take advantage of that and remove the kthread freezing. This is needed so that we properly really stop IO in flight without races after userspace has been frozen. Without this we rely on kthread freezing and its semantics are loose and error prone. The filesystem therefore is in charge of properly dealing with quiescing of the filesystem through its callbacks if it thinks it knows better than how the VFS handles it. The following Coccinelle rule was used as to remove the now superfluous freezer calls: make coccicheck MODE=patch SPFLAGS="--in-place --no-show-diff" COCCI=./fs-freeze-cleanup.cocci M=fs/btrfs virtual patch @ remove_set_freezable @ expression time; statement S, S2; expression task, current; @@ ( - set_freezable(); | - if (try_to_freeze()) - continue; | - try_to_freeze(); | - freezable_schedule(); + schedule(); | - freezable_schedule_timeout(time); + schedule_timeout(time); | - if (freezing(task)) { S } | - if (freezing(task)) { S } - else { S2 } | - freezing(current) ) @ remove_wq_freezable @ expression WQ_E, WQ_ARG1, WQ_ARG2, WQ_ARG3, WQ_ARG4; identifier fs_wq_fn; @@ ( WQ_E = alloc_workqueue(WQ_ARG1, - WQ_ARG2 | WQ_FREEZABLE, + WQ_ARG2, ...); | WQ_E = alloc_workqueue(WQ_ARG1, - WQ_ARG2 | WQ_FREEZABLE | WQ_ARG3, + WQ_ARG2 | WQ_ARG3, ...); | WQ_E = alloc_workqueue(WQ_ARG1, - WQ_ARG2 | WQ_ARG3 | WQ_FREEZABLE, + WQ_ARG2 | WQ_ARG3, ...); | WQ_E = alloc_workqueue(WQ_ARG1, - WQ_ARG2 | WQ_ARG3 | WQ_FREEZABLE | WQ_ARG4, + WQ_ARG2 | WQ_ARG3 | WQ_ARG4, ...); | WQ_E = - WQ_ARG1 | WQ_FREEZABLE + WQ_ARG1 | WQ_E = - WQ_ARG1 | WQ_FREEZABLE | WQ_ARG3 + WQ_ARG1 | WQ_ARG3 | fs_wq_fn( - WQ_FREEZABLE | WQ_ARG2 | WQ_ARG3 + WQ_ARG2 | WQ_ARG3 ) | fs_wq_fn( - WQ_FREEZABLE | WQ_ARG2 + WQ_ARG2 ) | fs_wq_fn( - WQ_FREEZABLE + 0 ) ) @ add_auto_flag @ expression E1; identifier fs_type; @@ struct file_system_type fs_type = { .fs_flags = E1 + | FS_AUTOFREEZE , }; Generated-by: Coccinelle SmPL Signed-off-by: Luis Chamberlain --- fs/btrfs/disk-io.c | 4 ++-- fs/btrfs/scrub.c | 2 +- fs/btrfs/super.c | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c index 3dd555db3d32..03332f914be7 100644 --- a/fs/btrfs/disk-io.c +++ b/fs/btrfs/disk-io.c @@ -1962,8 +1962,8 @@ static void btrfs_init_qgroup(struct btrfs_fs_info *fs_info) static int btrfs_init_workqueues(struct btrfs_fs_info *fs_info) { u32 max_active = fs_info->thread_pool_size; - unsigned int flags = WQ_MEM_RECLAIM | WQ_FREEZABLE | WQ_UNBOUND; - unsigned int ordered_flags = WQ_MEM_RECLAIM | WQ_FREEZABLE; + unsigned int flags = WQ_MEM_RECLAIM | WQ_UNBOUND; + unsigned int ordered_flags = WQ_MEM_RECLAIM; fs_info->workers = btrfs_alloc_workqueue(fs_info, "worker", flags, max_active, 16); diff --git a/fs/btrfs/scrub.c b/fs/btrfs/scrub.c index ae34353a34d9..52ef84923645 100644 --- a/fs/btrfs/scrub.c +++ b/fs/btrfs/scrub.c @@ -2811,7 +2811,7 @@ static void scrub_workers_put(struct btrfs_fs_info *fs_info) static noinline_for_stack int scrub_workers_get(struct btrfs_fs_info *fs_info) { struct workqueue_struct *scrub_workers = NULL; - unsigned int flags = WQ_FREEZABLE | WQ_UNBOUND; + unsigned int flags = WQ_UNBOUND; int max_active = fs_info->thread_pool_size; int ret = -ENOMEM; diff --git a/fs/btrfs/super.c b/fs/btrfs/super.c index 40709e2a44fc..153e8a2d7fbb 100644 --- a/fs/btrfs/super.c +++ b/fs/btrfs/super.c @@ -2178,7 +2178,7 @@ static struct file_system_type btrfs_fs_type = { .parameters = btrfs_fs_parameters, .kill_sb = btrfs_kill_super, .fs_flags = FS_REQUIRES_DEV | FS_BINARY_MOUNTDATA | - FS_ALLOW_IDMAP | FS_MGTIME, + FS_ALLOW_IDMAP | FS_MGTIME | FS_AUTOFREEZE, }; MODULE_ALIAS_FS("btrfs"); From patchwork Wed Mar 26 11:22:20 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Luis Chamberlain X-Patchwork-Id: 14029982 Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (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 97F2BEEC3; Wed, 26 Mar 2025 11:22:27 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=198.137.202.133 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1742988149; cv=none; b=X2EfzP9GyL8c9ZX5oralJjXgHs0pTrkLrLhxGgv/D7hz1sLBT9g9CJBFB6kejosA8dgtPHhjEYF8Z6t0lP70qeKcClPrNvM/g2OuedJLK9VIGOfz6l35nYrvI8HKh0pCYD5xs4l28hffl9GWxm22rayr1/iBxxUOYI38tmc2O38= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1742988149; c=relaxed/simple; bh=GqQAE2gI9jpYg3gMwXkCpEnwEG0pEMzVmX2dEBpK1U8=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=POgYJAvf4GxxnEIJDa9PFOrXMU25BsiOr7lavuDkS8TLAyFPAYTKHkTwUc9h8BNc9XtmbC6MmoMcpiw7yq/m3SqFRjcuPsY+FL4bKDjsOyw4iOiFgeHip93244+wYa4fDyinC1MRCXLRyC3h5j46RSZ26sNKC/HRUDGdxj3/6Mw= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=fail (p=quarantine dis=none) header.from=kernel.org; spf=none smtp.mailfrom=infradead.org; dkim=pass (2048-bit key) header.d=infradead.org header.i=@infradead.org header.b=46lg4Qo4; arc=none smtp.client-ip=198.137.202.133 Authentication-Results: smtp.subspace.kernel.org; dmarc=fail (p=quarantine dis=none) header.from=kernel.org Authentication-Results: smtp.subspace.kernel.org; spf=none smtp.mailfrom=infradead.org Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=infradead.org header.i=@infradead.org header.b="46lg4Qo4" DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=bombadil.20210309; h=Sender:Content-Transfer-Encoding: MIME-Version:References:In-Reply-To:Message-ID:Date:Subject:Cc:To:From: Reply-To:Content-Type:Content-ID:Content-Description; bh=d0u73LY7N6aNB4yHaOSQ3RxfhJSx72C3Op6MMJeJuck=; b=46lg4Qo4UazkYkHkgsh8m6mAjk WRSWIz5C4Rel7jWx3B95q5QuEtiCg9gMLXHdnjX3lk7xbtrd2j8lXZeXJlpynb+5hWRjBmvuNghtA p2BaXSqMYkyBXIfn7rwL3LHtFdsPhsDujTeGXnb3EU7by29LgkPr44fCcd1TXM20bFyaUFQJwJ9my OGMFSCxu1ov1IbzEvxDqB/yZ3vuA016Y7F/5ETa4SFq3oFecg7D/Ctgg/W9slCF7b4B9Uwf7erPPU 6IdZSsnwvCHuXWVVWD50/lVKtYZUP9y2ji3GigrY47BAbJ6wxkYHlwafsva1bZ32FFGklnj4JPKay 4yrqtGhg==; Received: from mcgrof by bombadil.infradead.org with local (Exim 4.98.1 #2 (Red Hat Linux)) id 1txOq0-00000008LMC-3XEq; Wed, 26 Mar 2025 11:22:24 +0000 From: Luis Chamberlain To: jack@suse.cz, hch@infradead.org, James.Bottomley@HansenPartnership.com, david@fromorbit.com, rafael@kernel.org, djwong@kernel.org, pavel@kernel.org, song@kernel.org Cc: linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, gost.dev@samsung.com, Luis Chamberlain Subject: [RFC 6/6] xfs: replace kthread freezing with auto fs freezing Date: Wed, 26 Mar 2025 04:22:20 -0700 Message-ID: <20250326112220.1988619-7-mcgrof@kernel.org> X-Mailer: git-send-email 2.49.0 In-Reply-To: <20250326112220.1988619-1-mcgrof@kernel.org> References: <20250326112220.1988619-1-mcgrof@kernel.org> Precedence: bulk X-Mailing-List: linux-fsdevel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Sender: Luis Chamberlain The kernel power management now supports allowing the VFS to handle filesystem freezing freezes and thawing. Take advantage of that and remove the kthread freezing. This is needed so that we properly really stop IO in flight without races after userspace has been frozen. Without this we rely on kthread freezing and its semantics are loose and error prone. The filesystem therefore is in charge of properly dealing with quiescing of the filesystem through its callbacks if it thinks it knows better than how the VFS handles it. The following Coccinelle rule was used as to remove the now superfluous freezer calls: make coccicheck MODE=patch SPFLAGS="--in-place --no-show-diff" COCCI=./fs-freeze-cleanup.cocci M=fs/xfs virtual patch @ remove_set_freezable @ expression time; statement S, S2; expression task, current; @@ ( - set_freezable(); | - if (try_to_freeze()) - continue; | - try_to_freeze(); | - freezable_schedule(); + schedule(); | - freezable_schedule_timeout(time); + schedule_timeout(time); | - if (freezing(task)) { S } | - if (freezing(task)) { S } - else { S2 } | - freezing(current) ) @ remove_wq_freezable @ expression WQ_E, WQ_ARG1, WQ_ARG2, WQ_ARG3, WQ_ARG4; identifier fs_wq_fn; @@ ( WQ_E = alloc_workqueue(WQ_ARG1, - WQ_ARG2 | WQ_FREEZABLE, + WQ_ARG2, ...); | WQ_E = alloc_workqueue(WQ_ARG1, - WQ_ARG2 | WQ_FREEZABLE | WQ_ARG3, + WQ_ARG2 | WQ_ARG3, ...); | WQ_E = alloc_workqueue(WQ_ARG1, - WQ_ARG2 | WQ_ARG3 | WQ_FREEZABLE, + WQ_ARG2 | WQ_ARG3, ...); | WQ_E = alloc_workqueue(WQ_ARG1, - WQ_ARG2 | WQ_ARG3 | WQ_FREEZABLE | WQ_ARG4, + WQ_ARG2 | WQ_ARG3 | WQ_ARG4, ...); | WQ_E = - WQ_ARG1 | WQ_FREEZABLE + WQ_ARG1 | WQ_E = - WQ_ARG1 | WQ_FREEZABLE | WQ_ARG3 + WQ_ARG1 | WQ_ARG3 | fs_wq_fn( - WQ_FREEZABLE | WQ_ARG2 | WQ_ARG3 + WQ_ARG2 | WQ_ARG3 ) | fs_wq_fn( - WQ_FREEZABLE | WQ_ARG2 + WQ_ARG2 ) | fs_wq_fn( - WQ_FREEZABLE + 0 ) ) @ add_auto_flag @ expression E1; identifier fs_type; @@ struct file_system_type fs_type = { .fs_flags = E1 + | FS_AUTOFREEZE , }; Generated-by: Coccinelle SmPL Signed-off-by: Luis Chamberlain --- fs/xfs/xfs_discard.c | 2 +- fs/xfs/xfs_log.c | 3 +-- fs/xfs/xfs_log_cil.c | 2 +- fs/xfs/xfs_mru_cache.c | 2 +- fs/xfs/xfs_pwork.c | 2 +- fs/xfs/xfs_super.c | 16 ++++++++-------- fs/xfs/xfs_trans_ail.c | 3 --- fs/xfs/xfs_zone_gc.c | 2 -- 8 files changed, 13 insertions(+), 19 deletions(-) diff --git a/fs/xfs/xfs_discard.c b/fs/xfs/xfs_discard.c index c1a306268ae4..1596cf0ecb9b 100644 --- a/fs/xfs/xfs_discard.c +++ b/fs/xfs/xfs_discard.c @@ -333,7 +333,7 @@ xfs_trim_gather_extents( static bool xfs_trim_should_stop(void) { - return fatal_signal_pending(current) || freezing(current); + return fatal_signal_pending(current); } /* diff --git a/fs/xfs/xfs_log.c b/fs/xfs/xfs_log.c index 6493bdb57351..317f6db292fb 100644 --- a/fs/xfs/xfs_log.c +++ b/fs/xfs/xfs_log.c @@ -1489,8 +1489,7 @@ xlog_alloc_log( log->l_iclog->ic_prev = prev_iclog; /* re-write 1st prev ptr */ log->l_ioend_workqueue = alloc_workqueue("xfs-log/%s", - XFS_WQFLAGS(WQ_FREEZABLE | WQ_MEM_RECLAIM | - WQ_HIGHPRI), + XFS_WQFLAGS(WQ_MEM_RECLAIM | WQ_HIGHPRI), 0, mp->m_super->s_id); if (!log->l_ioend_workqueue) goto out_free_iclog; diff --git a/fs/xfs/xfs_log_cil.c b/fs/xfs/xfs_log_cil.c index 1ca406ec1b40..8ff5d68394e6 100644 --- a/fs/xfs/xfs_log_cil.c +++ b/fs/xfs/xfs_log_cil.c @@ -1932,7 +1932,7 @@ xlog_cil_init( * concurrency the log spinlocks will be exposed to. */ cil->xc_push_wq = alloc_workqueue("xfs-cil/%s", - XFS_WQFLAGS(WQ_FREEZABLE | WQ_MEM_RECLAIM | WQ_UNBOUND), + XFS_WQFLAGS(WQ_MEM_RECLAIM | WQ_UNBOUND), 4, log->l_mp->m_super->s_id); if (!cil->xc_push_wq) goto out_destroy_cil; diff --git a/fs/xfs/xfs_mru_cache.c b/fs/xfs/xfs_mru_cache.c index d0f5b403bdbe..c9a49c6f6129 100644 --- a/fs/xfs/xfs_mru_cache.c +++ b/fs/xfs/xfs_mru_cache.c @@ -293,7 +293,7 @@ int xfs_mru_cache_init(void) { xfs_mru_reap_wq = alloc_workqueue("xfs_mru_cache", - XFS_WQFLAGS(WQ_MEM_RECLAIM | WQ_FREEZABLE), 1); + XFS_WQFLAGS(WQ_MEM_RECLAIM), 1); if (!xfs_mru_reap_wq) return -ENOMEM; return 0; diff --git a/fs/xfs/xfs_pwork.c b/fs/xfs/xfs_pwork.c index c283b801cc5d..3f5bf53f8778 100644 --- a/fs/xfs/xfs_pwork.c +++ b/fs/xfs/xfs_pwork.c @@ -72,7 +72,7 @@ xfs_pwork_init( trace_xfs_pwork_init(mp, nr_threads, current->pid); pctl->wq = alloc_workqueue("%s-%d", - WQ_UNBOUND | WQ_SYSFS | WQ_FREEZABLE, nr_threads, tag, + WQ_UNBOUND | WQ_SYSFS, nr_threads, tag, current->pid); if (!pctl->wq) return -ENOMEM; diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c index b2dd0c0bf509..4fae48072ef3 100644 --- a/fs/xfs/xfs_super.c +++ b/fs/xfs/xfs_super.c @@ -565,37 +565,37 @@ xfs_init_mount_workqueues( struct xfs_mount *mp) { mp->m_buf_workqueue = alloc_workqueue("xfs-buf/%s", - XFS_WQFLAGS(WQ_FREEZABLE | WQ_MEM_RECLAIM), + XFS_WQFLAGS(WQ_MEM_RECLAIM), 1, mp->m_super->s_id); if (!mp->m_buf_workqueue) goto out; mp->m_unwritten_workqueue = alloc_workqueue("xfs-conv/%s", - XFS_WQFLAGS(WQ_FREEZABLE | WQ_MEM_RECLAIM), + XFS_WQFLAGS(WQ_MEM_RECLAIM), 0, mp->m_super->s_id); if (!mp->m_unwritten_workqueue) goto out_destroy_buf; mp->m_reclaim_workqueue = alloc_workqueue("xfs-reclaim/%s", - XFS_WQFLAGS(WQ_FREEZABLE | WQ_MEM_RECLAIM), + XFS_WQFLAGS(WQ_MEM_RECLAIM), 0, mp->m_super->s_id); if (!mp->m_reclaim_workqueue) goto out_destroy_unwritten; mp->m_blockgc_wq = alloc_workqueue("xfs-blockgc/%s", - XFS_WQFLAGS(WQ_UNBOUND | WQ_FREEZABLE | WQ_MEM_RECLAIM), + XFS_WQFLAGS(WQ_UNBOUND | WQ_MEM_RECLAIM), 0, mp->m_super->s_id); if (!mp->m_blockgc_wq) goto out_destroy_reclaim; mp->m_inodegc_wq = alloc_workqueue("xfs-inodegc/%s", - XFS_WQFLAGS(WQ_FREEZABLE | WQ_MEM_RECLAIM), + XFS_WQFLAGS(WQ_MEM_RECLAIM), 1, mp->m_super->s_id); if (!mp->m_inodegc_wq) goto out_destroy_blockgc; mp->m_sync_workqueue = alloc_workqueue("xfs-sync/%s", - XFS_WQFLAGS(WQ_FREEZABLE), 0, mp->m_super->s_id); + XFS_WQFLAGS(0), 0, mp->m_super->s_id); if (!mp->m_sync_workqueue) goto out_destroy_inodegc; @@ -2228,7 +2228,7 @@ static struct file_system_type xfs_fs_type = { .parameters = xfs_fs_parameters, .kill_sb = xfs_kill_sb, .fs_flags = FS_REQUIRES_DEV | FS_ALLOW_IDMAP | FS_MGTIME | - FS_LBS, + FS_LBS | FS_AUTOFREEZE, }; MODULE_ALIAS_FS("xfs"); @@ -2500,7 +2500,7 @@ xfs_init_workqueues(void) * max_active value for this workqueue. */ xfs_alloc_wq = alloc_workqueue("xfsalloc", - XFS_WQFLAGS(WQ_MEM_RECLAIM | WQ_FREEZABLE), 0); + XFS_WQFLAGS(WQ_MEM_RECLAIM), 0); if (!xfs_alloc_wq) return -ENOMEM; diff --git a/fs/xfs/xfs_trans_ail.c b/fs/xfs/xfs_trans_ail.c index 0fcb1828e598..ad8183db0780 100644 --- a/fs/xfs/xfs_trans_ail.c +++ b/fs/xfs/xfs_trans_ail.c @@ -636,7 +636,6 @@ xfsaild( unsigned int noreclaim_flag; noreclaim_flag = memalloc_noreclaim_save(); - set_freezable(); while (1) { /* @@ -695,8 +694,6 @@ xfsaild( __set_current_state(TASK_RUNNING); - try_to_freeze(); - tout = xfsaild_push(ailp); } diff --git a/fs/xfs/xfs_zone_gc.c b/fs/xfs/xfs_zone_gc.c index c5136ea9bb1d..1875b6551ab0 100644 --- a/fs/xfs/xfs_zone_gc.c +++ b/fs/xfs/xfs_zone_gc.c @@ -993,7 +993,6 @@ xfs_zone_gc_handle_work( } __set_current_state(TASK_RUNNING); - try_to_freeze(); if (reset_list) xfs_zone_gc_reset_zones(data, reset_list); @@ -1041,7 +1040,6 @@ xfs_zoned_gcd( unsigned int nofs_flag; nofs_flag = memalloc_nofs_save(); - set_freezable(); for (;;) { set_current_state(TASK_INTERRUPTIBLE | TASK_FREEZABLE);