UBIFS: extend debug/message capabilities

In the case where we have more than one volumes on different UBI
devices, it may be not that easy to tell which volume prints the
messages.  Add ubi number and volume id in ubifs_msg/warn/error
to help debug. These two values are passed by struct ubifs_info.

For those where ubifs_info is not initialized yet, ubifs_* is
replaced by pr_*. For those where ubifs_info is not avaliable,
ubifs_info is passed to the calling function as a const parameter.

The output looks like,

[   95.444879] UBIFS (ubi0:1): background thread "ubifs_bgt0_1" started, PID 696
[   95.484688] UBIFS (ubi0:1): UBIFS: mounted UBI device 0, volume 1, name "test1"
[   95.484694] UBIFS (ubi0:1): LEB size: 126976 bytes (124 KiB), min./max. I/O unit sizes: 2048 bytes/2048 bytes
[   95.484699] UBIFS (ubi0:1): FS size: 30220288 bytes (28 MiB, 238 LEBs), journal size 1523712 bytes (1 MiB, 12 LEBs)
[   95.484703] UBIFS (ubi0:1): reserved for root: 1427378 bytes (1393 KiB)
[   95.484709] UBIFS (ubi0:1): media format: w4/r0 (latest is w4/r0), UUID 40DFFC0E-70BE-4193-8905-F7D6DFE60B17, small LPT model
[   95.489875] UBIFS (ubi1:0): background thread "ubifs_bgt1_0" started, PID 699
[   95.529713] UBIFS (ubi1:0): UBIFS: mounted UBI device 1, volume 0, name "test2"
[   95.529718] UBIFS (ubi1:0): LEB size: 126976 bytes (124 KiB), min./max. I/O unit sizes: 2048 bytes/2048 bytes
[   95.529724] UBIFS (ubi1:0): FS size: 19808256 bytes (18 MiB, 156 LEBs), journal size 1015809 bytes (0 MiB, 8 LEBs)
[   95.529727] UBIFS (ubi1:0): reserved for root: 935592 bytes (913 KiB)
[   95.529733] UBIFS (ubi1:0): media format: w4/r0 (latest is w4/r0), UUID EEB7779D-F419-4CA9-811B-831CAC7233D4, small LPT model

[  954.264767] UBIFS error (ubi1:0 pid 756): ubifs_read_node: bad node type (255 but expected 6)
[  954.367030] UBIFS error (ubi1:0 pid 756): ubifs_read_node: bad node at LEB 0:0, LEB mapping status 1

Signed-off-by: Sheng Yong <shengyong1@huawei.com>
Signed-off-by: Artem Bityutskiy <artem.bityutskiy@linux.intel.com>

1 files changed, 13 insertions, 13 deletions

diff --git a/fs/ubifs/orphan.c b/fs/ubifs/orphan.c
index 4409f486ecef..caf2d123e9ee 100644
--- a/fs/ubifs/orphan.c
+++ b/fs/ubifs/orphan.c
@@ -88,7 +88,7 @@ int ubifs_add_orphan(struct ubifs_info *c, ino_t inum)
                 else if (inum > o->inum)
                         p = &(*p)->rb_right;
                 else {
-                        ubifs_err("orphaned twice");
+                        ubifs_err(c, "orphaned twice");
                         spin_unlock(&c->orphan_lock);
                         kfree(orphan);
                         return 0;
@@ -155,7 +155,7 @@ void ubifs_delete_orphan(struct ubifs_info *c, ino_t inum)
                 }
         }
         spin_unlock(&c->orphan_lock);
-        ubifs_err("missing orphan ino %lu", (unsigned long)inum);
+        ubifs_err(c, "missing orphan ino %lu", (unsigned long)inum);
         dump_stack();
 }
 
@@ -287,7 +287,7 @@ static int write_orph_node(struct ubifs_info *c, int atomic)
                          * We limit the number of orphans so that this should
                          * never happen.
                          */
-                        ubifs_err("out of space in orphan area");
+                        ubifs_err(c, "out of space in orphan area");
                         return -EINVAL;
                 }
         }
@@ -397,7 +397,7 @@ static int consolidate(struct ubifs_info *c)
                  * We limit the number of orphans so that this should
                  * never happen.
                  */
-                ubifs_err("out of space in orphan area");
+                ubifs_err(c, "out of space in orphan area");
                 err = -EINVAL;
         }
         spin_unlock(&c->orphan_lock);
@@ -569,7 +569,7 @@ static int do_kill_orphans(struct ubifs_info *c, struct ubifs_scan_leb *sleb,
 
         list_for_each_entry(snod, &sleb->nodes, list) {
                 if (snod->type != UBIFS_ORPH_NODE) {
-                        ubifs_err("invalid node type %d in orphan area at %d:%d",
+                        ubifs_err(c, "invalid node type %d in orphan area at %d:%d",
                                   snod->type, sleb->lnum, snod->offs);
                         ubifs_dump_node(c, snod->node);
                         return -EINVAL;
@@ -596,7 +596,7 @@ static int do_kill_orphans(struct ubifs_info *c, struct ubifs_scan_leb *sleb,
                          * number. That makes this orphan node, out of date.
                          */
                         if (!first) {
-                                ubifs_err("out of order commit number %llu in orphan node at %d:%d",
+                                ubifs_err(c, "out of order commit number %llu in orphan node at %d:%d",
                                           cmt_no, sleb->lnum, snod->offs);
                                 ubifs_dump_node(c, snod->node);
                                 return -EINVAL;
@@ -831,20 +831,20 @@ static int dbg_orphan_check(struct ubifs_info *c, struct ubifs_zbranch *zbr,
         if (inum != ci->last_ino) {
                 /* Lowest node type is the inode node, so it comes first */
                 if (key_type(c, &zbr->key) != UBIFS_INO_KEY)
-                        ubifs_err("found orphan node ino %lu, type %d",
+                        ubifs_err(c, "found orphan node ino %lu, type %d",
                                   (unsigned long)inum, key_type(c, &zbr->key));
                 ci->last_ino = inum;
                 ci->tot_inos += 1;
                 err = ubifs_tnc_read_node(c, zbr, ci->node);
                 if (err) {
-                        ubifs_err("node read failed, error %d", err);
+                        ubifs_err(c, "node read failed, error %d", err);
                         return err;
                 }
                 if (ci->node->nlink == 0)
                         /* Must be recorded as an orphan */
                         if (!dbg_find_check_orphan(&ci->root, inum) &&
                             !dbg_find_orphan(c, inum)) {
-                                ubifs_err("missing orphan, ino %lu",
+                                ubifs_err(c, "missing orphan, ino %lu",
                                           (unsigned long)inum);
                                 ci->missing += 1;
                         }
@@ -887,7 +887,7 @@ static int dbg_scan_orphans(struct ubifs_info *c, struct check_info *ci)
 
         buf = __vmalloc(c->leb_size, GFP_NOFS, PAGE_KERNEL);
         if (!buf) {
-                ubifs_err("cannot allocate memory to check orphans");
+                ubifs_err(c, "cannot allocate memory to check orphans");
                 return 0;
         }
 
@@ -925,7 +925,7 @@ static int dbg_check_orphans(struct ubifs_info *c)
         ci.root = RB_ROOT;
         ci.node = kmalloc(UBIFS_MAX_INO_NODE_SZ, GFP_NOFS);
         if (!ci.node) {
-                ubifs_err("out of memory");
+                ubifs_err(c, "out of memory");
                 return -ENOMEM;
         }
 
@@ -935,12 +935,12 @@ static int dbg_check_orphans(struct ubifs_info *c)
 
         err = dbg_walk_index(c, &dbg_orphan_check, NULL, &ci);
         if (err) {
-                ubifs_err("cannot scan TNC, error %d", err);
+                ubifs_err(c, "cannot scan TNC, error %d", err);
                 goto out;
         }
 
         if (ci.missing) {
-                ubifs_err("%lu missing orphan(s)", ci.missing);
+                ubifs_err(c, "%lu missing orphan(s)", ci.missing);
                 err = -EINVAL;
                 goto out;
         }