btrfs: move btrfs_abort_transaction to transaction.c

While trying to sync messages.[ch] I ended up with this dependency on
messages.h in the rest of btrfs-progs code base because it's where
btrfs_abort_transaction() was now held.  We want to keep messages.[ch]
limited to the kernel code, and the btrfs_abort_transaction() code
better fits in the transaction code and not in messages.

Reviewed-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
Signed-off-by: Josef Bacik <josef@toxicpanda.com>
Reviewed-by: David Sterba <dsterba@suse.com>
[ move the __cold attributes ]
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/messages.c b/fs/btrfs/messages.c
index 625bbbb..fde5aaa 100644 (file)
--- a/fs/btrfs/messages.c
+++ b/fs/btrfs/messages.c
@@ -293,36 +293,6 @@ void __cold btrfs_err_32bit_limit(struct btrfs_fs_info *fs_info)
 #endif
 
 /*
- * We only mark the transaction aborted and then set the file system read-only.
- * This will prevent new transactions from starting or trying to join this
- * one.
- *
- * This means that error recovery at the call site is limited to freeing
- * any local memory allocations and passing the error code up without
- * further cleanup. The transaction should complete as it normally would
- * in the call path but will return -EIO.
- *
- * We'll complete the cleanup in btrfs_end_transaction and
- * btrfs_commit_transaction.
- */
-__cold
-void __btrfs_abort_transaction(struct btrfs_trans_handle *trans,
-                              const char *function,
-                              unsigned int line, int errno, bool first_hit)
-{
-       struct btrfs_fs_info *fs_info = trans->fs_info;
-
-       WRITE_ONCE(trans->aborted, errno);
-       WRITE_ONCE(trans->transaction->aborted, errno);
-       if (first_hit && errno == -ENOSPC)
-               btrfs_dump_space_info_for_trans_abort(fs_info);
-       /* Wake up anybody who may be waiting on this transaction */
-       wake_up(&fs_info->transaction_wait);
-       wake_up(&fs_info->transaction_blocked_wait);
-       __btrfs_handle_fs_error(fs_info, function, line, errno, NULL);
-}
-
-/*
  * __btrfs_panic decodes unexpected, fatal errors from the caller, issues an
  * alert, and either panics or BUGs, depending on mount options.
  */

diff --git a/fs/btrfs/messages.h b/fs/btrfs/messages.h
index 190af1f..8c516ee 100644 (file)
--- a/fs/btrfs/messages.h
+++ b/fs/btrfs/messages.h
@@ -6,7 +6,6 @@
 #include <linux/types.h>
 
 struct btrfs_fs_info;
-struct btrfs_trans_handle;
 
 static inline __printf(2, 3) __cold
 void btrfs_no_printk(const struct btrfs_fs_info *fs_info, const char *fmt, ...)
@@ -178,39 +177,6 @@ void __btrfs_handle_fs_error(struct btrfs_fs_info *fs_info, const char *function
 
 const char * __attribute_const__ btrfs_decode_error(int errno);
 
-__cold
-void __btrfs_abort_transaction(struct btrfs_trans_handle *trans,
-                              const char *function,
-                              unsigned int line, int errno, bool first_hit);
-
-bool __cold abort_should_print_stack(int errno);
-
-/*
- * Call btrfs_abort_transaction as early as possible when an error condition is
- * detected, that way the exact stack trace is reported for some errors.
- */
-#define btrfs_abort_transaction(trans, errno)                  \
-do {                                                           \
-       bool first = false;                                     \
-       /* Report first abort since mount */                    \
-       if (!test_and_set_bit(BTRFS_FS_STATE_TRANS_ABORTED,     \
-                             &((trans)->fs_info->fs_state))) { \
-               first = true;                                   \
-               if (WARN(abort_should_print_stack(errno),       \
-                       KERN_ERR                                \
-                       "BTRFS: Transaction aborted (error %d)\n",      \
-                       (errno))) {                                     \
-                       /* Stack trace printed. */                      \
-               } else {                                                \
-                       btrfs_err((trans)->fs_info,                     \
-                                 "Transaction aborted (error %d)",     \
-                                 (errno));                     \
-               }                                               \
-       }                                                       \
-       __btrfs_abort_transaction((trans), __func__,            \
-                                 __LINE__, (errno), first);    \
-} while (0)
-
 #define btrfs_handle_fs_error(fs_info, errno, fmt, args...)            \
        __btrfs_handle_fs_error((fs_info), __func__, __LINE__,          \
                                (errno), fmt, ##args)

diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c
index b8c52e8..528efe5 100644 (file)
--- a/fs/btrfs/transaction.c
+++ b/fs/btrfs/transaction.c
@@ -2604,6 +2604,35 @@ int btrfs_clean_one_deleted_snapshot(struct btrfs_fs_info *fs_info)
        return (ret < 0) ? 0 : 1;
 }
 
+/*
+ * We only mark the transaction aborted and then set the file system read-only.
+ * This will prevent new transactions from starting or trying to join this
+ * one.
+ *
+ * This means that error recovery at the call site is limited to freeing
+ * any local memory allocations and passing the error code up without
+ * further cleanup. The transaction should complete as it normally would
+ * in the call path but will return -EIO.
+ *
+ * We'll complete the cleanup in btrfs_end_transaction and
+ * btrfs_commit_transaction.
+ */
+void __cold __btrfs_abort_transaction(struct btrfs_trans_handle *trans,
+                                     const char *function,
+                                     unsigned int line, int errno, bool first_hit)
+{
+       struct btrfs_fs_info *fs_info = trans->fs_info;
+
+       WRITE_ONCE(trans->aborted, errno);
+       WRITE_ONCE(trans->transaction->aborted, errno);
+       if (first_hit && errno == -ENOSPC)
+               btrfs_dump_space_info_for_trans_abort(fs_info);
+       /* Wake up anybody who may be waiting on this transaction */
+       wake_up(&fs_info->transaction_wait);
+       wake_up(&fs_info->transaction_blocked_wait);
+       __btrfs_handle_fs_error(fs_info, function, line, errno, NULL);
+}
+
 int __init btrfs_transaction_init(void)
 {
        btrfs_trans_handle_cachep = kmem_cache_create("btrfs_trans_handle",

diff --git a/fs/btrfs/transaction.h b/fs/btrfs/transaction.h
index 97f6c39..fa728ab 100644 (file)
--- a/fs/btrfs/transaction.h
+++ b/fs/btrfs/transaction.h
@@ -202,6 +202,34 @@ static inline void btrfs_clear_skip_qgroup(struct btrfs_trans_handle *trans)
        delayed_refs->qgroup_to_skip = 0;
 }
 
+bool __cold abort_should_print_stack(int errno);
+
+/*
+ * Call btrfs_abort_transaction as early as possible when an error condition is
+ * detected, that way the exact stack trace is reported for some errors.
+ */
+#define btrfs_abort_transaction(trans, errno)          \
+do {                                                           \
+       bool first = false;                                     \
+       /* Report first abort since mount */                    \
+       if (!test_and_set_bit(BTRFS_FS_STATE_TRANS_ABORTED,     \
+                       &((trans)->fs_info->fs_state))) {       \
+               first = true;                                   \
+               if (WARN(abort_should_print_stack(errno),       \
+                       KERN_ERR                                \
+                       "BTRFS: Transaction aborted (error %d)\n",      \
+                       (errno))) {                                     \
+                       /* Stack trace printed. */                      \
+               } else {                                                \
+                       btrfs_debug((trans)->fs_info,                   \
+                                   "Transaction aborted (error %d)", \
+                                 (errno));                     \
+               }                                               \
+       }                                                       \
+       __btrfs_abort_transaction((trans), __func__,            \
+                                 __LINE__, (errno), first);    \
+} while (0)
+
 int btrfs_end_transaction(struct btrfs_trans_handle *trans);
 struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root,
                                                   unsigned int num_items);
@@ -236,6 +264,9 @@ void btrfs_put_transaction(struct btrfs_transaction *transaction);
 void btrfs_add_dropped_root(struct btrfs_trans_handle *trans,
                            struct btrfs_root *root);
 void btrfs_trans_release_chunk_metadata(struct btrfs_trans_handle *trans);
+void __cold __btrfs_abort_transaction(struct btrfs_trans_handle *trans,
+                                     const char *function,
+                                     unsigned int line, int errno, bool first_hit);
 
 int __init btrfs_transaction_init(void);
 void __cold btrfs_transaction_exit(void);