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, 12 insertions, 12 deletions

diff --git a/fs/ubifs/tnc_misc.c b/fs/ubifs/tnc_misc.c
index f6bf8995c7b1..93f5b7859e6f 100644
--- a/fs/ubifs/tnc_misc.c
+++ b/fs/ubifs/tnc_misc.c
@@ -293,9 +293,9 @@ static int read_znode(struct ubifs_info *c, int lnum, int offs, int len,
                 lnum, offs, znode->level, znode->child_cnt);
 
         if (znode->child_cnt > c->fanout || znode->level > UBIFS_MAX_LEVELS) {
-                ubifs_err("current fanout %d, branch count %d",
+                ubifs_err(c, "current fanout %d, branch count %d",
                           c->fanout, znode->child_cnt);
-                ubifs_err("max levels %d, znode level %d",
+                ubifs_err(c, "max levels %d, znode level %d",
                           UBIFS_MAX_LEVELS, znode->level);
                 err = 1;
                 goto out_dump;
@@ -316,7 +316,7 @@ static int read_znode(struct ubifs_info *c, int lnum, int offs, int len,
                 if (zbr->lnum < c->main_first ||
                     zbr->lnum >= c->leb_cnt || zbr->offs < 0 ||
                     zbr->offs + zbr->len > c->leb_size || zbr->offs & 7) {
-                        ubifs_err("bad branch %d", i);
+                        ubifs_err(c, "bad branch %d", i);
                         err = 2;
                         goto out_dump;
                 }
@@ -328,7 +328,7 @@ static int read_znode(struct ubifs_info *c, int lnum, int offs, int len,
                 case UBIFS_XENT_KEY:
                         break;
                 default:
-                        ubifs_err("bad key type at slot %d: %d",
+                        ubifs_err(c, "bad key type at slot %d: %d",
                                   i, key_type(c, &zbr->key));
                         err = 3;
                         goto out_dump;
@@ -340,17 +340,17 @@ static int read_znode(struct ubifs_info *c, int lnum, int offs, int len,
                 type = key_type(c, &zbr->key);
                 if (c->ranges[type].max_len == 0) {
                         if (zbr->len != c->ranges[type].len) {
-                                ubifs_err("bad target node (type %d) length (%d)",
+                                ubifs_err(c, "bad target node (type %d) length (%d)",
                                           type, zbr->len);
-                                ubifs_err("have to be %d", c->ranges[type].len);
+                                ubifs_err(c, "have to be %d", c->ranges[type].len);
                                 err = 4;
                                 goto out_dump;
                         }
                 } else if (zbr->len < c->ranges[type].min_len ||
                            zbr->len > c->ranges[type].max_len) {
-                        ubifs_err("bad target node (type %d) length (%d)",
+                        ubifs_err(c, "bad target node (type %d) length (%d)",
                                   type, zbr->len);
-                        ubifs_err("have to be in range of %d-%d",
+                        ubifs_err(c, "have to be in range of %d-%d",
                                   c->ranges[type].min_len,
                                   c->ranges[type].max_len);
                         err = 5;
@@ -370,12 +370,12 @@ static int read_znode(struct ubifs_info *c, int lnum, int offs, int len,
 
                 cmp = keys_cmp(c, key1, key2);
                 if (cmp > 0) {
-                        ubifs_err("bad key order (keys %d and %d)", i, i + 1);
+                        ubifs_err(c, "bad key order (keys %d and %d)", i, i + 1);
                         err = 6;
                         goto out_dump;
                 } else if (cmp == 0 && !is_hash_key(c, key1)) {
                         /* These can only be keys with colliding hash */
-                        ubifs_err("keys %d and %d are not hashed but equivalent",
+                        ubifs_err(c, "keys %d and %d are not hashed but equivalent",
                                   i, i + 1);
                         err = 7;
                         goto out_dump;
@@ -386,7 +386,7 @@ static int read_znode(struct ubifs_info *c, int lnum, int offs, int len,
         return 0;
 
 out_dump:
-        ubifs_err("bad indexing node at LEB %d:%d, error %d", lnum, offs, err);
+        ubifs_err(c, "bad indexing node at LEB %d:%d, error %d", lnum, offs, err);
         ubifs_dump_node(c, idx);
         kfree(idx);
         return -EINVAL;
@@ -482,7 +482,7 @@ int ubifs_tnc_read_node(struct ubifs_info *c, struct ubifs_zbranch *zbr,
         /* Make sure the key of the read node is correct */
         key_read(c, node + UBIFS_KEY_OFFSET, &key1);
         if (!keys_eq(c, key, &key1)) {
-                ubifs_err("bad key in node at LEB %d:%d",
+                ubifs_err(c, "bad key in node at LEB %d:%d",
                           zbr->lnum, zbr->offs);
                 dbg_tnck(key, "looked for key ");
                 dbg_tnck(&key1, "but found node's key ");