Btrfs: convert printk to btrfs_ and fix BTRFS prefix

Convert all applicable cases of printk and pr_* to the btrfs_* macros.

Fix all uses of the BTRFS prefix.

Signed-off-by: Frank Holton <fholton@gmail.com>
Signed-off-by: Josef Bacik <jbacik@fb.com>
Signed-off-by: Chris Mason <clm@fb.com>

1 files changed, 44 insertions, 45 deletions

diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index 92303f42baaa..b68afe32419f 100644
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -125,7 +125,7 @@ static void btrfs_kobject_uevent(struct block_device *bdev,
 
         ret = kobject_uevent(&disk_to_dev(bdev->bd_disk)->kobj, action);
         if (ret)
-                pr_warn("Sending event '%d' to kobject: '%s' (%p): failed\n",
+                pr_warn("BTRFS: Sending event '%d' to kobject: '%s' (%p): failed\n",
                         action,
                         kobject_name(&disk_to_dev(bdev->bd_disk)->kobj),
                         &disk_to_dev(bdev->bd_disk)->kobj);
@@ -200,7 +200,7 @@ btrfs_get_bdev_and_sb(const char *device_path, fmode_t flags, void *holder,
 
         if (IS_ERR(*bdev)) {
                 ret = PTR_ERR(*bdev);
-                printk(KERN_INFO "btrfs: open %s failed\n", device_path);
+                printk(KERN_INFO "BTRFS: open %s failed\n", device_path);
                 goto error;
         }
 
@@ -912,9 +912,9 @@ int btrfs_scan_one_device(const char *path, fmode_t flags, void *holder,
         if (disk_super->label[0]) {
                 if (disk_super->label[BTRFS_LABEL_SIZE - 1])
                         disk_super->label[BTRFS_LABEL_SIZE - 1] = '\0';
-                printk(KERN_INFO "btrfs: device label %s ", disk_super->label);
+                printk(KERN_INFO "BTRFS: device label %s ", disk_super->label);
         } else {
-                printk(KERN_INFO "btrfs: device fsid %pU ", disk_super->fsid);
+                printk(KERN_INFO "BTRFS: device fsid %pU ", disk_super->fsid);
         }
 
         printk(KERN_CONT "devid %llu transid %llu %s\n", devid, transid, path);
@@ -1813,7 +1813,7 @@ int btrfs_find_device_missing_or_by_path(struct btrfs_root *root,
                 }
 
                 if (!*device) {
-                        pr_err("btrfs: no missing device found\n");
+                        btrfs_err(root->fs_info, "no missing device found");
                         return -ENOENT;
                 }
 
@@ -3052,7 +3052,7 @@ loop:
 error:
         btrfs_free_path(path);
         if (enospc_errors) {
-                printk(KERN_INFO "btrfs: %d enospc errors during balance\n",
+                btrfs_info(fs_info, "%d enospc errors during balance",
                        enospc_errors);
                 if (!ret)
                         ret = -ENOSPC;
@@ -3138,8 +3138,8 @@ int btrfs_balance(struct btrfs_balance_control *bctl,
                 if (!(bctl->flags & BTRFS_BALANCE_DATA) ||
                     !(bctl->flags & BTRFS_BALANCE_METADATA) ||
                     memcmp(&bctl->data, &bctl->meta, sizeof(bctl->data))) {
-                        printk(KERN_ERR "btrfs: with mixed groups data and "
-                               "metadata balance options must be the same\n");
+                        btrfs_err(fs_info, "with mixed groups data and "
+                                   "metadata balance options must be the same");
                         ret = -EINVAL;
                         goto out;
                 }
@@ -3165,8 +3165,8 @@ int btrfs_balance(struct btrfs_balance_control *bctl,
         if ((bctl->data.flags & BTRFS_BALANCE_ARGS_CONVERT) &&
             (!alloc_profile_is_valid(bctl->data.target, 1) ||
              (bctl->data.target & ~allowed))) {
-                printk(KERN_ERR "btrfs: unable to start balance with target "
-                       "data profile %llu\n",
+                btrfs_err(fs_info, "unable to start balance with target "
+                           "data profile %llu",
                        bctl->data.target);
                 ret = -EINVAL;
                 goto out;
@@ -3174,8 +3174,8 @@ int btrfs_balance(struct btrfs_balance_control *bctl,
         if ((bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT) &&
             (!alloc_profile_is_valid(bctl->meta.target, 1) ||
              (bctl->meta.target & ~allowed))) {
-                printk(KERN_ERR "btrfs: unable to start balance with target "
-                       "metadata profile %llu\n",
+                btrfs_err(fs_info,
+                           "unable to start balance with target metadata profile %llu",
                        bctl->meta.target);
                 ret = -EINVAL;
                 goto out;
@@ -3183,8 +3183,8 @@ int btrfs_balance(struct btrfs_balance_control *bctl,
         if ((bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT) &&
             (!alloc_profile_is_valid(bctl->sys.target, 1) ||
              (bctl->sys.target & ~allowed))) {
-                printk(KERN_ERR "btrfs: unable to start balance with target "
-                       "system profile %llu\n",
+                btrfs_err(fs_info,
+                           "unable to start balance with target system profile %llu",
                        bctl->sys.target);
                 ret = -EINVAL;
                 goto out;
@@ -3193,7 +3193,7 @@ int btrfs_balance(struct btrfs_balance_control *bctl,
         /* allow dup'ed data chunks only in mixed mode */
         if (!mixed && (bctl->data.flags & BTRFS_BALANCE_ARGS_CONVERT) &&
             (bctl->data.target & BTRFS_BLOCK_GROUP_DUP)) {
-                printk(KERN_ERR "btrfs: dup for data is not allowed\n");
+                btrfs_err(fs_info, "dup for data is not allowed");
                 ret = -EINVAL;
                 goto out;
         }
@@ -3213,11 +3213,10 @@ int btrfs_balance(struct btrfs_balance_control *bctl,
                      (fs_info->avail_metadata_alloc_bits & allowed) &&
                      !(bctl->meta.target & allowed))) {
                         if (bctl->flags & BTRFS_BALANCE_FORCE) {
-                                printk(KERN_INFO "btrfs: force reducing metadata "
-                                       "integrity\n");
+                                btrfs_info(fs_info, "force reducing metadata integrity");
                         } else {
-                                printk(KERN_ERR "btrfs: balance will reduce metadata "
-                                       "integrity, use force if you want this\n");
+                                btrfs_err(fs_info, "balance will reduce metadata "
+                                           "integrity, use force if you want this");
                                 ret = -EINVAL;
                                 goto out;
                         }
@@ -3303,7 +3302,7 @@ static int balance_kthread(void *data)
         mutex_lock(&fs_info->balance_mutex);
 
         if (fs_info->balance_ctl) {
-                printk(KERN_INFO "btrfs: continuing balance\n");
+                btrfs_info(fs_info, "continuing balance");
                 ret = btrfs_balance(fs_info->balance_ctl, NULL);
         }
 
@@ -3325,7 +3324,7 @@ int btrfs_resume_balance_async(struct btrfs_fs_info *fs_info)
         spin_unlock(&fs_info->balance_lock);
 
         if (btrfs_test_opt(fs_info->tree_root, SKIP_BALANCE)) {
-                printk(KERN_INFO "btrfs: force skipping balance\n");
+                btrfs_info(fs_info, "force skipping balance");
                 return 0;
         }
 
@@ -3543,7 +3542,7 @@ update_tree:
                                                   BTRFS_UUID_KEY_SUBVOL,
                                                   key.objectid);
                         if (ret < 0) {
-                                pr_warn("btrfs: uuid_tree_add failed %d\n",
+                                btrfs_warn(fs_info, "uuid_tree_add failed %d",
                                         ret);
                                 break;
                         }
@@ -3555,7 +3554,7 @@ update_tree:
                                                  BTRFS_UUID_KEY_RECEIVED_SUBVOL,
                                                   key.objectid);
                         if (ret < 0) {
-                                pr_warn("btrfs: uuid_tree_add failed %d\n",
+                                btrfs_warn(fs_info, "uuid_tree_add failed %d",
                                         ret);
                                 break;
                         }
@@ -3590,7 +3589,7 @@ out:
         if (trans && !IS_ERR(trans))
                 btrfs_end_transaction(trans, fs_info->uuid_root);
         if (ret)
-                pr_warn("btrfs: btrfs_uuid_scan_kthread failed %d\n", ret);
+                btrfs_warn(fs_info, "btrfs_uuid_scan_kthread failed %d", ret);
         else
                 fs_info->update_uuid_tree_gen = 1;
         up(&fs_info->uuid_tree_rescan_sem);
@@ -3654,7 +3653,7 @@ static int btrfs_uuid_rescan_kthread(void *data)
          */
         ret = btrfs_uuid_tree_iterate(fs_info, btrfs_check_uuid_tree_entry);
         if (ret < 0) {
-                pr_warn("btrfs: iterating uuid_tree failed %d\n", ret);
+                btrfs_warn(fs_info, "iterating uuid_tree failed %d", ret);
                 up(&fs_info->uuid_tree_rescan_sem);
                 return ret;
         }
@@ -3695,7 +3694,7 @@ int btrfs_create_uuid_tree(struct btrfs_fs_info *fs_info)
         task = kthread_run(btrfs_uuid_scan_kthread, fs_info, "btrfs-uuid");
         if (IS_ERR(task)) {
                 /* fs_info->update_uuid_tree_gen remains 0 in all error case */
-                pr_warn("btrfs: failed to start uuid_scan task\n");
+                btrfs_warn(fs_info, "failed to start uuid_scan task");
                 up(&fs_info->uuid_tree_rescan_sem);
                 return PTR_ERR(task);
         }
@@ -3711,7 +3710,7 @@ int btrfs_check_uuid_tree(struct btrfs_fs_info *fs_info)
         task = kthread_run(btrfs_uuid_rescan_kthread, fs_info, "btrfs-uuid");
         if (IS_ERR(task)) {
                 /* fs_info->update_uuid_tree_gen remains 0 in all error case */
-                pr_warn("btrfs: failed to start uuid_rescan task\n");
+                btrfs_warn(fs_info, "failed to start uuid_rescan task");
                 up(&fs_info->uuid_tree_rescan_sem);
                 return PTR_ERR(task);
         }
@@ -4033,7 +4032,7 @@ static int __btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
                 max_stripe_size = 32 * 1024 * 1024;
                 max_chunk_size = 2 * max_stripe_size;
         } else {
-                printk(KERN_ERR "btrfs: invalid chunk type 0x%llx requested\n",
+                btrfs_err(info, "invalid chunk type 0x%llx requested\n",
                        type);
                 BUG_ON(1);
         }
@@ -4065,7 +4064,7 @@ static int __btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
 
                 if (!device->writeable) {
                         WARN(1, KERN_ERR
-                               "btrfs: read-only device in alloc_list\n");
+                               "BTRFS: read-only device in alloc_list\n");
                         continue;
                 }
 
@@ -5193,13 +5192,13 @@ int btrfs_rmap_block(struct btrfs_mapping_tree *map_tree,
         read_unlock(&em_tree->lock);
 
         if (!em) {
-                printk(KERN_ERR "btrfs: couldn't find em for chunk %Lu\n",
+                printk(KERN_ERR "BTRFS: couldn't find em for chunk %Lu\n",
                        chunk_start);
                 return -EIO;
         }
 
         if (em->start != chunk_start) {
-                printk(KERN_ERR "btrfs: bad chunk start, em=%Lu, wanted=%Lu\n",
+                printk(KERN_ERR "BTRFS: bad chunk start, em=%Lu, wanted=%Lu\n",
                        em->start, chunk_start);
                 free_extent_map(em);
                 return -EIO;
@@ -6123,7 +6122,8 @@ static int update_dev_stat_item(struct btrfs_trans_handle *trans,
         BUG_ON(!path);
         ret = btrfs_search_slot(trans, dev_root, &key, path, -1, 1);
         if (ret < 0) {
-                printk_in_rcu(KERN_WARNING "btrfs: error %d while searching for dev_stats item for device %s!\n",
+                printk_in_rcu(KERN_WARNING "BTRFS: "
+                        "error %d while searching for dev_stats item for device %s!\n",
                               ret, rcu_str_deref(device->name));
                 goto out;
         }
@@ -6133,7 +6133,8 @@ static int update_dev_stat_item(struct btrfs_trans_handle *trans,
                 /* need to delete old one and insert a new one */
                 ret = btrfs_del_item(trans, dev_root, path);
                 if (ret != 0) {
-                        printk_in_rcu(KERN_WARNING "btrfs: delete too small dev_stats item for device %s failed %d!\n",
+                        printk_in_rcu(KERN_WARNING "BTRFS: "
+                                "delete too small dev_stats item for device %s failed %d!\n",
                                       rcu_str_deref(device->name), ret);
                         goto out;
                 }
@@ -6146,7 +6147,8 @@ static int update_dev_stat_item(struct btrfs_trans_handle *trans,
                 ret = btrfs_insert_empty_item(trans, dev_root, path,
                                               &key, sizeof(*ptr));
                 if (ret < 0) {
-                        printk_in_rcu(KERN_WARNING "btrfs: insert dev_stats item for device %s failed %d!\n",
+                        printk_in_rcu(KERN_WARNING "BTRFS: "
+                                          "insert dev_stats item for device %s failed %d!\n",
                                       rcu_str_deref(device->name), ret);
                         goto out;
                 }
@@ -6199,16 +6201,14 @@ static void btrfs_dev_stat_print_on_error(struct btrfs_device *dev)
 {
         if (!dev->dev_stats_valid)
                 return;
-        printk_ratelimited_in_rcu(KERN_ERR
-                           "btrfs: bdev %s errs: wr %u, rd %u, flush %u, corrupt %u, gen %u\n",
+        printk_ratelimited_in_rcu(KERN_ERR "BTRFS: "
+                           "bdev %s errs: wr %u, rd %u, flush %u, corrupt %u, gen %u\n",
                            rcu_str_deref(dev->name),
                            btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_WRITE_ERRS),
                            btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_READ_ERRS),
                            btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_FLUSH_ERRS),
-                           btrfs_dev_stat_read(dev,
-                                               BTRFS_DEV_STAT_CORRUPTION_ERRS),
-                           btrfs_dev_stat_read(dev,
-                                               BTRFS_DEV_STAT_GENERATION_ERRS));
+                           btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_CORRUPTION_ERRS),
+                           btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_GENERATION_ERRS));
 }
 
 static void btrfs_dev_stat_print_on_load(struct btrfs_device *dev)
@@ -6221,7 +6221,8 @@ static void btrfs_dev_stat_print_on_load(struct btrfs_device *dev)
         if (i == BTRFS_DEV_STAT_VALUES_MAX)
                 return; /* all values == 0, suppress message */
 
-        printk_in_rcu(KERN_INFO "btrfs: bdev %s errs: wr %u, rd %u, flush %u, corrupt %u, gen %u\n",
+        printk_in_rcu(KERN_INFO "BTRFS: "
+                   "bdev %s errs: wr %u, rd %u, flush %u, corrupt %u, gen %u\n",
                rcu_str_deref(dev->name),
                btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_WRITE_ERRS),
                btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_READ_ERRS),
@@ -6242,12 +6243,10 @@ int btrfs_get_dev_stats(struct btrfs_root *root,
         mutex_unlock(&fs_devices->device_list_mutex);
 
         if (!dev) {
-                printk(KERN_WARNING
-                       "btrfs: get dev_stats failed, device not found\n");
+                btrfs_warn(root->fs_info, "get dev_stats failed, device not found");
                 return -ENODEV;
         } else if (!dev->dev_stats_valid) {
-                printk(KERN_WARNING
-                       "btrfs: get dev_stats failed, not yet valid\n");
+                btrfs_warn(root->fs_info, "get dev_stats failed, not yet valid");
                 return -ENODEV;
         } else if (stats->flags & BTRFS_DEV_STATS_RESET) {
                 for (i = 0; i < BTRFS_DEV_STAT_VALUES_MAX; i++) {