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, 30 insertions, 29 deletions

diff --git a/fs/ubifs/lpt.c b/fs/ubifs/lpt.c
index 421bd0a80424..dc9f27e9d61b 100644
--- a/fs/ubifs/lpt.c
+++ b/fs/ubifs/lpt.c
@@ -145,13 +145,13 @@ int ubifs_calc_lpt_geom(struct ubifs_info *c)
         sz = c->lpt_sz * 2; /* Must have at least 2 times the size */
         lebs_needed = div_u64(sz + c->leb_size - 1, c->leb_size);
         if (lebs_needed > c->lpt_lebs) {
-                ubifs_err("too few LPT LEBs");
+                ubifs_err(c, "too few LPT LEBs");
                 return -EINVAL;
         }
 
         /* Verify that ltab fits in a single LEB (since ltab is a single node */
         if (c->ltab_sz > c->leb_size) {
-                ubifs_err("LPT ltab too big");
+                ubifs_err(c, "LPT ltab too big");
                 return -EINVAL;
         }
 
@@ -213,7 +213,7 @@ static int calc_dflt_lpt_geom(struct ubifs_info *c, int *main_lebs,
                         continue;
                 }
                 if (c->ltab_sz > c->leb_size) {
-                        ubifs_err("LPT ltab too big");
+                        ubifs_err(c, "LPT ltab too big");
                         return -EINVAL;
                 }
                 *main_lebs = c->main_lebs;
@@ -911,7 +911,7 @@ static void replace_cats(struct ubifs_info *c, struct ubifs_pnode *old_pnode,
  *
  * This function returns %0 on success and a negative error code on failure.
  */
-static int check_lpt_crc(void *buf, int len)
+static int check_lpt_crc(const struct ubifs_info *c, void *buf, int len)
 {
         int pos = 0;
         uint8_t *addr = buf;
@@ -921,8 +921,8 @@ static int check_lpt_crc(void *buf, int len)
         calc_crc = crc16(-1, buf + UBIFS_LPT_CRC_BYTES,
                          len - UBIFS_LPT_CRC_BYTES);
         if (crc != calc_crc) {
-                ubifs_err("invalid crc in LPT node: crc %hx calc %hx", crc,
-                          calc_crc);
+                ubifs_err(c, "invalid crc in LPT node: crc %hx calc %hx",
+                          crc, calc_crc);
                 dump_stack();
                 return -EINVAL;
         }
@@ -938,14 +938,15 @@ static int check_lpt_crc(void *buf, int len)
  *
  * This function returns %0 on success and a negative error code on failure.
  */
-static int check_lpt_type(uint8_t **addr, int *pos, int type)
+static int check_lpt_type(const struct ubifs_info *c, uint8_t **addr,
+                          int *pos, int type)
 {
         int node_type;
 
         node_type = ubifs_unpack_bits(addr, pos, UBIFS_LPT_TYPE_BITS);
         if (node_type != type) {
-                ubifs_err("invalid type (%d) in LPT node type %d", node_type,
-                          type);
+                ubifs_err(c, "invalid type (%d) in LPT node type %d",
+                          node_type, type);
                 dump_stack();
                 return -EINVAL;
         }
@@ -966,7 +967,7 @@ static int unpack_pnode(const struct ubifs_info *c, void *buf,
         uint8_t *addr = buf + UBIFS_LPT_CRC_BYTES;
         int i, pos = 0, err;
 
-        err = check_lpt_type(&addr, &pos, UBIFS_LPT_PNODE);
+        err = check_lpt_type(c, &addr, &pos, UBIFS_LPT_PNODE);
         if (err)
                 return err;
         if (c->big_lpt)
@@ -985,7 +986,7 @@ static int unpack_pnode(const struct ubifs_info *c, void *buf,
                         lprops->flags = 0;
                 lprops->flags |= ubifs_categorize_lprops(c, lprops);
         }
-        err = check_lpt_crc(buf, c->pnode_sz);
+        err = check_lpt_crc(c, buf, c->pnode_sz);
         return err;
 }
 
@@ -1003,7 +1004,7 @@ int ubifs_unpack_nnode(const struct ubifs_info *c, void *buf,
         uint8_t *addr = buf + UBIFS_LPT_CRC_BYTES;
         int i, pos = 0, err;
 
-        err = check_lpt_type(&addr, &pos, UBIFS_LPT_NNODE);
+        err = check_lpt_type(c, &addr, &pos, UBIFS_LPT_NNODE);
         if (err)
                 return err;
         if (c->big_lpt)
@@ -1019,7 +1020,7 @@ int ubifs_unpack_nnode(const struct ubifs_info *c, void *buf,
                 nnode->nbranch[i].offs = ubifs_unpack_bits(&addr, &pos,
                                                      c->lpt_offs_bits);
         }
-        err = check_lpt_crc(buf, c->nnode_sz);
+        err = check_lpt_crc(c, buf, c->nnode_sz);
         return err;
 }
 
@@ -1035,7 +1036,7 @@ static int unpack_ltab(const struct ubifs_info *c, void *buf)
         uint8_t *addr = buf + UBIFS_LPT_CRC_BYTES;
         int i, pos = 0, err;
 
-        err = check_lpt_type(&addr, &pos, UBIFS_LPT_LTAB);
+        err = check_lpt_type(c, &addr, &pos, UBIFS_LPT_LTAB);
         if (err)
                 return err;
         for (i = 0; i < c->lpt_lebs; i++) {
@@ -1051,7 +1052,7 @@ static int unpack_ltab(const struct ubifs_info *c, void *buf)
                 c->ltab[i].tgc = 0;
                 c->ltab[i].cmt = 0;
         }
-        err = check_lpt_crc(buf, c->ltab_sz);
+        err = check_lpt_crc(c, buf, c->ltab_sz);
         return err;
 }
 
@@ -1067,7 +1068,7 @@ static int unpack_lsave(const struct ubifs_info *c, void *buf)
         uint8_t *addr = buf + UBIFS_LPT_CRC_BYTES;
         int i, pos = 0, err;
 
-        err = check_lpt_type(&addr, &pos, UBIFS_LPT_LSAVE);
+        err = check_lpt_type(c, &addr, &pos, UBIFS_LPT_LSAVE);
         if (err)
                 return err;
         for (i = 0; i < c->lsave_cnt; i++) {
@@ -1077,7 +1078,7 @@ static int unpack_lsave(const struct ubifs_info *c, void *buf)
                         return -EINVAL;
                 c->lsave[i] = lnum;
         }
-        err = check_lpt_crc(buf, c->lsave_sz);
+        err = check_lpt_crc(c, buf, c->lsave_sz);
         return err;
 }
 
@@ -1243,7 +1244,7 @@ int ubifs_read_nnode(struct ubifs_info *c, struct ubifs_nnode *parent, int iip)
         return 0;
 
 out:
-        ubifs_err("error %d reading nnode at %d:%d", err, lnum, offs);
+        ubifs_err(c, "error %d reading nnode at %d:%d", err, lnum, offs);
         dump_stack();
         kfree(nnode);
         return err;
@@ -1308,10 +1309,10 @@ static int read_pnode(struct ubifs_info *c, struct ubifs_nnode *parent, int iip)
         return 0;
 
 out:
-        ubifs_err("error %d reading pnode at %d:%d", err, lnum, offs);
+        ubifs_err(c, "error %d reading pnode at %d:%d", err, lnum, offs);
         ubifs_dump_pnode(c, pnode, parent, iip);
         dump_stack();
-        ubifs_err("calc num: %d", calc_pnode_num_from_parent(c, parent, iip));
+        ubifs_err(c, "calc num: %d", calc_pnode_num_from_parent(c, parent, iip));
         kfree(pnode);
         return err;
 }
@@ -2095,7 +2096,7 @@ static int dbg_chk_pnode(struct ubifs_info *c, struct ubifs_pnode *pnode,
         int i;
 
         if (pnode->num != col) {
-                ubifs_err("pnode num %d expected %d parent num %d iip %d",
+                ubifs_err(c, "pnode num %d expected %d parent num %d iip %d",
                           pnode->num, col, pnode->parent->num, pnode->iip);
                 return -EINVAL;
         }
@@ -2110,13 +2111,13 @@ static int dbg_chk_pnode(struct ubifs_info *c, struct ubifs_pnode *pnode,
                 if (lnum >= c->leb_cnt)
                         continue;
                 if (lprops->lnum != lnum) {
-                        ubifs_err("bad LEB number %d expected %d",
+                        ubifs_err(c, "bad LEB number %d expected %d",
                                   lprops->lnum, lnum);
                         return -EINVAL;
                 }
                 if (lprops->flags & LPROPS_TAKEN) {
                         if (cat != LPROPS_UNCAT) {
-                                ubifs_err("LEB %d taken but not uncat %d",
+                                ubifs_err(c, "LEB %d taken but not uncat %d",
                                           lprops->lnum, cat);
                                 return -EINVAL;
                         }
@@ -2129,7 +2130,7 @@ static int dbg_chk_pnode(struct ubifs_info *c, struct ubifs_pnode *pnode,
                         case LPROPS_FRDI_IDX:
                                 break;
                         default:
-                                ubifs_err("LEB %d index but cat %d",
+                                ubifs_err(c, "LEB %d index but cat %d",
                                           lprops->lnum, cat);
                                 return -EINVAL;
                         }
@@ -2142,7 +2143,7 @@ static int dbg_chk_pnode(struct ubifs_info *c, struct ubifs_pnode *pnode,
                         case LPROPS_FREEABLE:
                                 break;
                         default:
-                                ubifs_err("LEB %d not index but cat %d",
+                                ubifs_err(c, "LEB %d not index but cat %d",
                                           lprops->lnum, cat);
                                 return -EINVAL;
                         }
@@ -2183,14 +2184,14 @@ static int dbg_chk_pnode(struct ubifs_info *c, struct ubifs_pnode *pnode,
                         break;
                 }
                 if (!found) {
-                        ubifs_err("LEB %d cat %d not found in cat heap/list",
+                        ubifs_err(c, "LEB %d cat %d not found in cat heap/list",
                                   lprops->lnum, cat);
                         return -EINVAL;
                 }
                 switch (cat) {
                 case LPROPS_EMPTY:
                         if (lprops->free != c->leb_size) {
-                                ubifs_err("LEB %d cat %d free %d dirty %d",
+                                ubifs_err(c, "LEB %d cat %d free %d dirty %d",
                                           lprops->lnum, cat, lprops->free,
                                           lprops->dirty);
                                 return -EINVAL;
@@ -2199,7 +2200,7 @@ static int dbg_chk_pnode(struct ubifs_info *c, struct ubifs_pnode *pnode,
                 case LPROPS_FREEABLE:
                 case LPROPS_FRDI_IDX:
                         if (lprops->free + lprops->dirty != c->leb_size) {
-                                ubifs_err("LEB %d cat %d free %d dirty %d",
+                                ubifs_err(c, "LEB %d cat %d free %d dirty %d",
                                           lprops->lnum, cat, lprops->free,
                                           lprops->dirty);
                                 return -EINVAL;
@@ -2236,7 +2237,7 @@ int dbg_check_lpt_nodes(struct ubifs_info *c, struct ubifs_cnode *cnode,
                         /* cnode is a nnode */
                         num = calc_nnode_num(row, col);
                         if (cnode->num != num) {
-                                ubifs_err("nnode num %d expected %d parent num %d iip %d",
+                                ubifs_err(c, "nnode num %d expected %d parent num %d iip %d",
                                           cnode->num, num,
                                           (nnode ? nnode->num : 0), cnode->iip);
                                 return -EINVAL;