hfs/hfsplus: convert dprint to hfs_dbg

Use a more current logging style.

Rename macro and uses.
Add do {} while (0) to macro.
Add DBG_ to macro.
Add and use hfs_dbg_cont variant where appropriate.

Signed-off-by: Joe Perches <joe@perches.com>
Cc: Vyacheslav Dubeyko <slava@dubeyko.com>
Cc: Hin-Tak Leung <htl10@users.sourceforge.net>
Cc: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

9 files changed, 63 insertions, 41 deletions

diff --git a/fs/hfs/bfind.c b/fs/hfs/bfind.c
index 571abe97b42a..e928f6cfb05b 100644
--- a/fs/hfs/bfind.c
+++ b/fs/hfs/bfind.c
@@ -22,7 +22,8 @@ int hfs_find_init(struct hfs_btree *tree, struct hfs_find_data *fd)
                 return -ENOMEM;
         fd->search_key = ptr;
         fd->key = ptr + tree->max_key_len + 2;
-        dprint(DBG_BNODE_REFS, "find_init: %d (%p)\n", tree->cnid, __builtin_return_address(0));
+        hfs_dbg(BNODE_REFS, "find_init: %d (%p)\n",
+                tree->cnid, __builtin_return_address(0));
         mutex_lock(&tree->tree_lock);
         return 0;
 }
@@ -31,7 +32,8 @@ void hfs_find_exit(struct hfs_find_data *fd)
 {
         hfs_bnode_put(fd->bnode);
         kfree(fd->search_key);
-        dprint(DBG_BNODE_REFS, "find_exit: %d (%p)\n", fd->tree->cnid, __builtin_return_address(0));
+        hfs_dbg(BNODE_REFS, "find_exit: %d (%p)\n",
+                fd->tree->cnid, __builtin_return_address(0));
         mutex_unlock(&fd->tree->tree_lock);
         fd->tree = NULL;
 }
diff --git a/fs/hfs/bitmap.c b/fs/hfs/bitmap.c
index c6e97366e8ac..28307bc9ec1e 100644
--- a/fs/hfs/bitmap.c
+++ b/fs/hfs/bitmap.c
@@ -158,7 +158,7 @@ u32 hfs_vbm_search_free(struct super_block *sb, u32 goal, u32 *num_bits)
                 }
         }
 
-        dprint(DBG_BITMAP, "alloc_bits: %u,%u\n", pos, *num_bits);
+        hfs_dbg(BITMAP, "alloc_bits: %u,%u\n", pos, *num_bits);
         HFS_SB(sb)->free_ablocks -= *num_bits;
         hfs_bitmap_dirty(sb);
 out:
@@ -200,7 +200,7 @@ int hfs_clear_vbm_bits(struct super_block *sb, u16 start, u16 count)
         if (!count)
                 return 0;
 
-        dprint(DBG_BITMAP, "clear_bits: %u,%u\n", start, count);
+        hfs_dbg(BITMAP, "clear_bits: %u,%u\n", start, count);
         /* are all of the bits in range? */
         if ((start + count) > HFS_SB(sb)->fs_ablocks)
                 return -2;
diff --git a/fs/hfs/bnode.c b/fs/hfs/bnode.c
index cdb41a1f6a64..869391902575 100644
--- a/fs/hfs/bnode.c
+++ b/fs/hfs/bnode.c
@@ -100,7 +100,7 @@ void hfs_bnode_copy(struct hfs_bnode *dst_node, int dst,
         struct hfs_btree *tree;
         struct page *src_page, *dst_page;
 
-        dprint(DBG_BNODE_MOD, "copybytes: %u,%u,%u\n", dst, src, len);
+        hfs_dbg(BNODE_MOD, "copybytes: %u,%u,%u\n", dst, src, len);
         if (!len)
                 return;
         tree = src_node->tree;
@@ -120,7 +120,7 @@ void hfs_bnode_move(struct hfs_bnode *node, int dst, int src, int len)
         struct page *page;
         void *ptr;
 
-        dprint(DBG_BNODE_MOD, "movebytes: %u,%u,%u\n", dst, src, len);
+        hfs_dbg(BNODE_MOD, "movebytes: %u,%u,%u\n", dst, src, len);
         if (!len)
                 return;
         src += node->page_offset;
@@ -138,16 +138,16 @@ void hfs_bnode_dump(struct hfs_bnode *node)
         __be32 cnid;
         int i, off, key_off;
 
-        dprint(DBG_BNODE_MOD, "bnode: %d\n", node->this);
+        hfs_dbg(BNODE_MOD, "bnode: %d\n", node->this);
         hfs_bnode_read(node, &desc, 0, sizeof(desc));
-        dprint(DBG_BNODE_MOD, "%d, %d, %d, %d, %d\n",
+        hfs_dbg(BNODE_MOD, "%d, %d, %d, %d, %d\n",
                 be32_to_cpu(desc.next), be32_to_cpu(desc.prev),
                 desc.type, desc.height, be16_to_cpu(desc.num_recs));
 
         off = node->tree->node_size - 2;
         for (i = be16_to_cpu(desc.num_recs); i >= 0; off -= 2, i--) {
                 key_off = hfs_bnode_read_u16(node, off);
-                dprint(DBG_BNODE_MOD, " %d", key_off);
+                hfs_dbg_cont(BNODE_MOD, " %d", key_off);
                 if (i && node->type == HFS_NODE_INDEX) {
                         int tmp;
 
@@ -155,17 +155,18 @@ void hfs_bnode_dump(struct hfs_bnode *node)
                                 tmp = (hfs_bnode_read_u8(node, key_off) | 1) + 1;
                         else
                                 tmp = node->tree->max_key_len + 1;
-                        dprint(DBG_BNODE_MOD, " (%d,%d", tmp, hfs_bnode_read_u8(node, key_off));
+                        hfs_dbg_cont(BNODE_MOD, " (%d,%d",
+                                     tmp, hfs_bnode_read_u8(node, key_off));
                         hfs_bnode_read(node, &cnid, key_off + tmp, 4);
-                        dprint(DBG_BNODE_MOD, ",%d)", be32_to_cpu(cnid));
+                        hfs_dbg_cont(BNODE_MOD, ",%d)", be32_to_cpu(cnid));
                 } else if (i && node->type == HFS_NODE_LEAF) {
                         int tmp;
 
                         tmp = hfs_bnode_read_u8(node, key_off);
-                        dprint(DBG_BNODE_MOD, " (%d)", tmp);
+                        hfs_dbg_cont(BNODE_MOD, " (%d)", tmp);
                 }
         }
-        dprint(DBG_BNODE_MOD, "\n");
+        hfs_dbg_cont(BNODE_MOD, "\n");
 }
 
 void hfs_bnode_unlink(struct hfs_bnode *node)
@@ -257,8 +258,8 @@ static struct hfs_bnode *__hfs_bnode_create(struct hfs_btree *tree, u32 cnid)
         node->this = cnid;
         set_bit(HFS_BNODE_NEW, &node->flags);
         atomic_set(&node->refcnt, 1);
-        dprint(DBG_BNODE_REFS, "new_node(%d:%d): 1\n",
-               node->tree->cnid, node->this);
+        hfs_dbg(BNODE_REFS, "new_node(%d:%d): 1\n",
+                node->tree->cnid, node->this);
         init_waitqueue_head(&node->lock_wq);
         spin_lock(&tree->hash_lock);
         node2 = hfs_bnode_findhash(tree, cnid);
@@ -301,7 +302,7 @@ void hfs_bnode_unhash(struct hfs_bnode *node)
 {
         struct hfs_bnode **p;
 
-        dprint(DBG_BNODE_REFS, "remove_node(%d:%d): %d\n",
+        hfs_dbg(BNODE_REFS, "remove_node(%d:%d): %d\n",
                 node->tree->cnid, node->this, atomic_read(&node->refcnt));
         for (p = &node->tree->node_hash[hfs_bnode_hash(node->this)];
              *p && *p != node; p = &(*p)->next_hash)
@@ -443,8 +444,9 @@ void hfs_bnode_get(struct hfs_bnode *node)
 {
         if (node) {
                 atomic_inc(&node->refcnt);
-                dprint(DBG_BNODE_REFS, "get_node(%d:%d): %d\n",
-                       node->tree->cnid, node->this, atomic_read(&node->refcnt));
+                hfs_dbg(BNODE_REFS, "get_node(%d:%d): %d\n",
+                        node->tree->cnid, node->this,
+                        atomic_read(&node->refcnt));
         }
 }
 
@@ -455,8 +457,9 @@ void hfs_bnode_put(struct hfs_bnode *node)
                 struct hfs_btree *tree = node->tree;
                 int i;
 
-                dprint(DBG_BNODE_REFS, "put_node(%d:%d): %d\n",
-                       node->tree->cnid, node->this, atomic_read(&node->refcnt));
+                hfs_dbg(BNODE_REFS, "put_node(%d:%d): %d\n",
+                        node->tree->cnid, node->this,
+                        atomic_read(&node->refcnt));
                 BUG_ON(!atomic_read(&node->refcnt));
                 if (!atomic_dec_and_lock(&node->refcnt, &tree->hash_lock))
                         return;
diff --git a/fs/hfs/brec.c b/fs/hfs/brec.c
index 92fb358ce824..57642570c6d8 100644
--- a/fs/hfs/brec.c
+++ b/fs/hfs/brec.c
@@ -94,7 +94,8 @@ again:
         end_rec_off = tree->node_size - (node->num_recs + 1) * 2;
         end_off = hfs_bnode_read_u16(node, end_rec_off);
         end_rec_off -= 2;
-        dprint(DBG_BNODE_MOD, "insert_rec: %d, %d, %d, %d\n", rec, size, end_off, end_rec_off);
+        hfs_dbg(BNODE_MOD, "insert_rec: %d, %d, %d, %d\n",
+                rec, size, end_off, end_rec_off);
         if (size > end_rec_off - end_off) {
                 if (new_node)
                         panic("not enough room!\n");
@@ -190,7 +191,8 @@ again:
                 mark_inode_dirty(tree->inode);
         }
         hfs_bnode_dump(node);
-        dprint(DBG_BNODE_MOD, "remove_rec: %d, %d\n", fd->record, fd->keylength + fd->entrylength);
+        hfs_dbg(BNODE_MOD, "remove_rec: %d, %d\n",
+                fd->record, fd->keylength + fd->entrylength);
         if (!--node->num_recs) {
                 hfs_bnode_unlink(node);
                 if (!node->parent)
@@ -240,7 +242,7 @@ static struct hfs_bnode *hfs_bnode_split(struct hfs_find_data *fd)
         if (IS_ERR(new_node))
                 return new_node;
         hfs_bnode_get(node);
-        dprint(DBG_BNODE_MOD, "split_nodes: %d - %d - %d\n",
+        hfs_dbg(BNODE_MOD, "split_nodes: %d - %d - %d\n",
                 node->this, new_node->this, node->next);
         new_node->next = node->next;
         new_node->prev = node->this;
@@ -374,7 +376,8 @@ again:
                 newkeylen = (hfs_bnode_read_u8(node, 14) | 1) + 1;
         else
                 fd->keylength = newkeylen = tree->max_key_len + 1;
-        dprint(DBG_BNODE_MOD, "update_rec: %d, %d, %d\n", rec, fd->keylength, newkeylen);
+        hfs_dbg(BNODE_MOD, "update_rec: %d, %d, %d\n",
+                rec, fd->keylength, newkeylen);
 
         rec_off = tree->node_size - (rec + 2) * 2;
         end_rec_off = tree->node_size - (parent->num_recs + 1) * 2;
diff --git a/fs/hfs/btree.c b/fs/hfs/btree.c
index 1cbdeea1db44..07d94ce1d278 100644
--- a/fs/hfs/btree.c
+++ b/fs/hfs/btree.c
@@ -316,7 +316,7 @@ void hfs_bmap_free(struct hfs_bnode *node)
         u32 nidx;
         u8 *data, byte, m;
 
-        dprint(DBG_BNODE_MOD, "btree_free_node: %u\n", node->this);
+        hfs_dbg(BNODE_MOD, "btree_free_node: %u\n", node->this);
         tree = node->tree;
         nidx = node->this;
         node = hfs_bnode_find(tree, 0);
diff --git a/fs/hfs/catalog.c b/fs/hfs/catalog.c
index 9569b39257ec..6ecb3d7efb78 100644
--- a/fs/hfs/catalog.c
+++ b/fs/hfs/catalog.c
@@ -87,7 +87,8 @@ int hfs_cat_create(u32 cnid, struct inode *dir, struct qstr *str, struct inode *
         int entry_size;
         int err;
 
-        dprint(DBG_CAT_MOD, "create_cat: %s,%u(%d)\n", str->name, cnid, inode->i_nlink);
+        hfs_dbg(CAT_MOD, "create_cat: %s,%u(%d)\n",
+                str->name, cnid, inode->i_nlink);
         if (dir->i_size >= HFS_MAX_VALENCE)
                 return -ENOSPC;
 
@@ -214,7 +215,7 @@ int hfs_cat_delete(u32 cnid, struct inode *dir, struct qstr *str)
         struct list_head *pos;
         int res, type;
 
-        dprint(DBG_CAT_MOD, "delete_cat: %s,%u\n", str ? str->name : NULL, cnid);
+        hfs_dbg(CAT_MOD, "delete_cat: %s,%u\n", str ? str->name : NULL, cnid);
         sb = dir->i_sb;
         res = hfs_find_init(HFS_SB(sb)->cat_tree, &fd);
         if (res)
@@ -282,7 +283,8 @@ int hfs_cat_move(u32 cnid, struct inode *src_dir, struct qstr *src_name,
         int entry_size, type;
         int err;
 
-        dprint(DBG_CAT_MOD, "rename_cat: %u - %lu,%s - %lu,%s\n", cnid, src_dir->i_ino, src_name->name,
+        hfs_dbg(CAT_MOD, "rename_cat: %u - %lu,%s - %lu,%s\n",
+                cnid, src_dir->i_ino, src_name->name,
                 dst_dir->i_ino, dst_name->name);
         sb = src_dir->i_sb;
         err = hfs_find_init(HFS_SB(sb)->cat_tree, &src_fd);
diff --git a/fs/hfs/extent.c b/fs/hfs/extent.c
index 813447b5b052..e33a0d36a93e 100644
--- a/fs/hfs/extent.c
+++ b/fs/hfs/extent.c
@@ -205,11 +205,12 @@ static void hfs_dump_extent(struct hfs_extent *extent)
 {
         int i;
 
-        dprint(DBG_EXTENT, "   ");
+        hfs_dbg(EXTENT, "   ");
         for (i = 0; i < 3; i++)
-                dprint(DBG_EXTENT, " %u:%u", be16_to_cpu(extent[i].block),
-                                 be16_to_cpu(extent[i].count));
-        dprint(DBG_EXTENT, "\n");
+                hfs_dbg_cont(EXTENT, " %u:%u",
+                             be16_to_cpu(extent[i].block),
+                             be16_to_cpu(extent[i].count));
+        hfs_dbg_cont(EXTENT, "\n");
 }
 
 static int hfs_add_extent(struct hfs_extent *extent, u16 offset,
@@ -404,10 +405,10 @@ int hfs_extend_file(struct inode *inode)
                 goto out;
         }
 
-        dprint(DBG_EXTENT, "extend %lu: %u,%u\n", inode->i_ino, start, len);
+        hfs_dbg(EXTENT, "extend %lu: %u,%u\n", inode->i_ino, start, len);
         if (HFS_I(inode)->alloc_blocks == HFS_I(inode)->first_blocks) {
                 if (!HFS_I(inode)->first_blocks) {
-                        dprint(DBG_EXTENT, "first extents\n");
+                        hfs_dbg(EXTENT, "first extents\n");
                         /* no extents yet */
                         HFS_I(inode)->first_extents[0].block = cpu_to_be16(start);
                         HFS_I(inode)->first_extents[0].count = cpu_to_be16(len);
@@ -449,7 +450,7 @@ out:
         return res;
 
 insert_extent:
-        dprint(DBG_EXTENT, "insert new extent\n");
+        hfs_dbg(EXTENT, "insert new extent\n");
         res = hfs_ext_write_extent(inode);
         if (res)
                 goto out;
@@ -474,8 +475,9 @@ void hfs_file_truncate(struct inode *inode)
         u32 size;
         int res;
 
-        dprint(DBG_INODE, "truncate: %lu, %Lu -> %Lu\n", inode->i_ino,
-               (long long)HFS_I(inode)->phys_size, inode->i_size);
+        hfs_dbg(INODE, "truncate: %lu, %Lu -> %Lu\n",
+                inode->i_ino, (long long)HFS_I(inode)->phys_size,
+                inode->i_size);
         if (inode->i_size > HFS_I(inode)->phys_size) {
                 struct address_space *mapping = inode->i_mapping;
                 void *fsdata;
diff --git a/fs/hfs/hfs_fs.h b/fs/hfs/hfs_fs.h
index 67817af96f82..d363b1e81ae9 100644
--- a/fs/hfs/hfs_fs.h
+++ b/fs/hfs/hfs_fs.h
@@ -34,8 +34,18 @@
 //#define DBG_MASK      (DBG_CAT_MOD|DBG_BNODE_REFS|DBG_INODE|DBG_EXTENT)
 #define DBG_MASK        (0)
 
-#define dprint(flg, fmt, args...) \
-        if (flg & DBG_MASK) printk(fmt , ## args)
+#define hfs_dbg(flg, fmt, ...)                          \
+do {                                                    \
+        if (DBG_##flg & DBG_MASK)                       \
+                printk(KERN_DEBUG fmt, ##__VA_ARGS__);  \
+} while (0)
+
+#define hfs_dbg_cont(flg, fmt, ...)                     \
+do {                                                    \
+        if (DBG_##flg & DBG_MASK)                       \
+                printk(KERN_CONT fmt, ##__VA_ARGS__);   \
+} while (0)
+
 
 /*
  * struct hfs_inode_info
diff --git a/fs/hfs/inode.c b/fs/hfs/inode.c
index 0847471ff04f..716e1aafb2e2 100644
--- a/fs/hfs/inode.c
+++ b/fs/hfs/inode.c
@@ -237,7 +237,7 @@ void hfs_delete_inode(struct inode *inode)
 {
         struct super_block *sb = inode->i_sb;
 
-        dprint(DBG_INODE, "delete_inode: %lu\n", inode->i_ino);
+        hfs_dbg(INODE, "delete_inode: %lu\n", inode->i_ino);
         if (S_ISDIR(inode->i_mode)) {
                 HFS_SB(sb)->folder_count--;
                 if (HFS_I(inode)->cat_key.ParID == cpu_to_be32(HFS_ROOT_CNID))
@@ -418,7 +418,7 @@ int hfs_write_inode(struct inode *inode, struct writeback_control *wbc)
         hfs_cat_rec rec;
         int res;
 
-        dprint(DBG_INODE, "hfs_write_inode: %lu\n", inode->i_ino);
+        hfs_dbg(INODE, "hfs_write_inode: %lu\n", inode->i_ino);
         res = hfs_ext_write_extent(inode);
         if (res)
                 return res;