btrfs: tag as unlikely if statements that check for fs in error state

Having the filesystem in an error state, meaning we had a transaction
abort, is unexpected. Mark every check for the error state with the
unlikely annotation to convey that and to allow the compiler to generate
better code.

On x86_64, using gcc 14.2.0-19 from Debian, resulted in a slightly
reduced object size and better code.

Before:

  $ size fs/btrfs/btrfs.ko
     text	   data	    bss	    dec	    hex	filename
  2008598	 175912	  15592	2200102	 219226	fs/btrfs/btrfs.ko

After:

  $ size fs/btrfs/btrfs.ko
     text	   data	    bss	    dec	    hex	filename
  2008450	 175912	  15592	2199954	 219192	fs/btrfs/btrfs.ko

Reviewed-by: Anand Jain <asj@kernel.org>
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Reviewed-by: David Sterba <dsterba@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index 14ce9bfc981be0d8cb776324a0305b424f2d37a5..b8ac3275d8f8ab6ca01f96fe86dee4dfb01901bb 100644 (file)
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -1556,7 +1556,7 @@ sleep:
                wake_up_process(fs_info->cleaner_kthread);
                mutex_unlock(&fs_info->transaction_kthread_mutex);
 
-               if (BTRFS_FS_ERROR(fs_info))
+               if (unlikely(BTRFS_FS_ERROR(fs_info)))
                        btrfs_cleanup_transaction(fs_info);
                if (!kthread_should_stop() &&
                                (!btrfs_transaction_blocked(fs_info) ||
@@ -4148,7 +4148,7 @@ void btrfs_drop_and_free_fs_root(struct btrfs_fs_info *fs_info,
                drop_ref = true;
        spin_unlock(&fs_info->fs_roots_radix_lock);
 
-       if (BTRFS_FS_ERROR(fs_info)) {
+       if (unlikely(BTRFS_FS_ERROR(fs_info))) {
                ASSERT(root->log_root == NULL);
                if (root->reloc_root) {
                        btrfs_put_root(root->reloc_root);

diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index 9d7ca80477fda440324cb7854b6bb641000e7210..1ba8a7d3587b1b5eebe20873e8a3879bdad48e80 100644 (file)
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -2400,7 +2400,7 @@ retry:
         * and it only returns 0 or errors.
         */
        ASSERT(ret <= 0);
-       if (!ret && BTRFS_FS_ERROR(fs_info))
+       if (unlikely(!ret && BTRFS_FS_ERROR(fs_info)))
                ret = -EROFS;
 
        if (ctx.zoned_bg)

diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index 06cc6e13cb621f2a6d5b8012ef6ca6d9feb0294f..cf1cb5c4db75796436ea122d4437511695f1ca97 100644 (file)
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -1445,7 +1445,7 @@ ssize_t btrfs_do_write_iter(struct kiocb *iocb, struct iov_iter *from,
         * have opened a file as writable, we have to stop this write operation
         * to ensure consistency.
         */
-       if (BTRFS_FS_ERROR(inode->root->fs_info))
+       if (unlikely(BTRFS_FS_ERROR(inode->root->fs_info)))
                return -EROFS;
 
        if (encoded && (iocb->ki_flags & IOCB_NOWAIT))

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 769e96dbe6391bb843860b33564233acbc4e70f0..808e52aa6ef290dec0d7f41294446e1cd2c33f3a 100644 (file)
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -8972,7 +8972,7 @@ int btrfs_start_delalloc_snapshot(struct btrfs_root *root, bool in_reclaim_conte
 {
        struct btrfs_fs_info *fs_info = root->fs_info;
 
-       if (BTRFS_FS_ERROR(fs_info))
+       if (unlikely(BTRFS_FS_ERROR(fs_info)))
                return -EROFS;
        return start_delalloc_inodes(root, NULL, true, in_reclaim_context);
 }
@@ -8985,7 +8985,7 @@ int btrfs_start_delalloc_roots(struct btrfs_fs_info *fs_info, long nr,
        LIST_HEAD(splice);
        int ret;
 
-       if (BTRFS_FS_ERROR(fs_info))
+       if (unlikely(BTRFS_FS_ERROR(fs_info)))
                return -EROFS;
 
        mutex_lock(&fs_info->delalloc_root_mutex);

diff --git a/fs/btrfs/messages.c b/fs/btrfs/messages.c
index 6190777924bff56b288a29a201e8ff42ad490a59..7c60c14e60fa8c7b429eb6557080e28ac9859f37 100644 (file)
--- a/fs/btrfs/messages.c
+++ b/fs/btrfs/messages.c
@@ -37,7 +37,7 @@ static void btrfs_state_to_string(const struct btrfs_fs_info *info, char *buf)
        memcpy(curr, STATE_STRING_PREFACE, sizeof(STATE_STRING_PREFACE));
        curr += sizeof(STATE_STRING_PREFACE) - 1;
 
-       if (BTRFS_FS_ERROR(info)) {
+       if (unlikely(BTRFS_FS_ERROR(info))) {
                *curr++ = 'E';
                states_printed = true;
        }

diff --git a/fs/btrfs/scrub.c b/fs/btrfs/scrub.c
index 0234971894fa30a0129531c1d758b5b443b0976d..1ac609239cbe371981d25b2e408f6a157fef5acf 100644 (file)
--- a/fs/btrfs/scrub.c
+++ b/fs/btrfs/scrub.c
@@ -2974,7 +2974,7 @@ static noinline_for_stack int scrub_supers(struct scrub_ctx *sctx,
        struct page *page;
        struct btrfs_fs_info *fs_info = sctx->fs_info;
 
-       if (BTRFS_FS_ERROR(fs_info))
+       if (unlikely(BTRFS_FS_ERROR(fs_info)))
                return -EROFS;
 
        page = alloc_page(GFP_KERNEL);

diff --git a/fs/btrfs/super.c b/fs/btrfs/super.c
index 52137366b79becbf8b484759eb70e89d0b662452..b26aa9169e83884984e11d23b0ec55cbf8769977 100644 (file)
--- a/fs/btrfs/super.c
+++ b/fs/btrfs/super.c
@@ -1299,7 +1299,7 @@ static int btrfs_remount_rw(struct btrfs_fs_info *fs_info)
 {
        int ret;
 
-       if (BTRFS_FS_ERROR(fs_info)) {
+       if (unlikely(BTRFS_FS_ERROR(fs_info))) {
                btrfs_err(fs_info,
                          "remounting read-write after error is not allowed");
                return -EINVAL;

diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c
index 4358f4b630572c2d796aa16c05333fe74b4456a3..c9c316ce4bdc79bc896e9a5f3274b24a43048a22 100644 (file)
--- a/fs/btrfs/transaction.c
+++ b/fs/btrfs/transaction.c
@@ -275,7 +275,7 @@ static noinline int join_transaction(struct btrfs_fs_info *fs_info,
        spin_lock(&fs_info->trans_lock);
 loop:
        /* The file system has been taken offline. No new transactions. */
-       if (BTRFS_FS_ERROR(fs_info)) {
+       if (unlikely(BTRFS_FS_ERROR(fs_info))) {
                spin_unlock(&fs_info->trans_lock);
                return -EROFS;
        }
@@ -333,7 +333,7 @@ loop:
                btrfs_lockdep_release(fs_info, btrfs_trans_num_writers);
                kfree(cur_trans);
                goto loop;
-       } else if (BTRFS_FS_ERROR(fs_info)) {
+       } else if (unlikely(BTRFS_FS_ERROR(fs_info))) {
                spin_unlock(&fs_info->trans_lock);
                btrfs_lockdep_release(fs_info, btrfs_trans_num_extwriters);
                btrfs_lockdep_release(fs_info, btrfs_trans_num_writers);
@@ -612,7 +612,7 @@ start_transaction(struct btrfs_root *root, unsigned int num_items,
        bool do_chunk_alloc = false;
        int ret;
 
-       if (BTRFS_FS_ERROR(fs_info))
+       if (unlikely(BTRFS_FS_ERROR(fs_info)))
                return ERR_PTR(-EROFS);
 
        if (current->journal_info) {
@@ -1120,7 +1120,7 @@ static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
        if (throttle)
                btrfs_run_delayed_iputs(info);
 
-       if (TRANS_ABORTED(trans) || BTRFS_FS_ERROR(info)) {
+       if (unlikely(TRANS_ABORTED(trans) || BTRFS_FS_ERROR(info))) {
                wake_up_process(info->transaction_kthread);
                if (TRANS_ABORTED(trans))
                        ret = trans->aborted;
@@ -2351,7 +2351,7 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans)
                 * abort to prevent writing a new superblock that reflects a
                 * corrupt state (pointing to trees with unwritten nodes/leafs).
                 */
-               if (BTRFS_FS_ERROR(fs_info)) {
+               if (unlikely(BTRFS_FS_ERROR(fs_info))) {
                        spin_unlock(&fs_info->trans_lock);
                        ret = -EROFS;
                        goto lockdep_release;

diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
index aa84649f63c29ab8aa51429efbe11acf3e21d196..9123adafa0d198700cb8a62e8f3cf8bdaef4a9bd 100644 (file)
--- a/fs/btrfs/tree-log.c
+++ b/fs/btrfs/tree-log.c
@@ -3566,7 +3566,7 @@ int btrfs_sync_log(struct btrfs_trans_handle *trans,
         * writing the super here would result in transid mismatches.  If there
         * is an error here just bail.
         */
-       if (BTRFS_FS_ERROR(fs_info)) {
+       if (unlikely(BTRFS_FS_ERROR(fs_info))) {
                ret = -EIO;
                btrfs_set_log_full_commit(trans);
                btrfs_abort_transaction(trans, ret);

diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index d8f2722311c88ba8a4ec1d005c8d7ea4549d4fd4..16e9239879580bde72a75234b36fd40fbac2fa85 100644 (file)
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -3602,7 +3602,7 @@ int btrfs_relocate_chunk(struct btrfs_fs_info *fs_info, u64 chunk_offset, bool v
                 * If we had a transaction abort, stop all running scrubs.
                 * See transaction.c:cleanup_transaction() why we do it here.
                 */
-               if (BTRFS_FS_ERROR(fs_info))
+               if (unlikely(BTRFS_FS_ERROR(fs_info)))
                        btrfs_scrub_cancel(fs_info);
                return ret;
        }