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

diff --git a/fs/ubifs/lprops.c b/fs/ubifs/lprops.c
index 46190a7c42a6..a0011aa3a779 100644
--- a/fs/ubifs/lprops.c
+++ b/fs/ubifs/lprops.c
@@ -682,7 +682,7 @@ int ubifs_change_one_lp(struct ubifs_info *c, int lnum, int free, int dirty,
 out:
         ubifs_release_lprops(c);
         if (err)
-                ubifs_err("cannot change properties of LEB %d, error %d",
+                ubifs_err(c, "cannot change properties of LEB %d, error %d",
                           lnum, err);
         return err;
 }
@@ -721,7 +721,7 @@ int ubifs_update_one_lp(struct ubifs_info *c, int lnum, int free, int dirty,
 out:
         ubifs_release_lprops(c);
         if (err)
-                ubifs_err("cannot update properties of LEB %d, error %d",
+                ubifs_err(c, "cannot update properties of LEB %d, error %d",
                           lnum, err);
         return err;
 }
@@ -746,7 +746,7 @@ int ubifs_read_one_lp(struct ubifs_info *c, int lnum, struct ubifs_lprops *lp)
         lpp = ubifs_lpt_lookup(c, lnum);
         if (IS_ERR(lpp)) {
                 err = PTR_ERR(lpp);
-                ubifs_err("cannot read properties of LEB %d, error %d",
+                ubifs_err(c, "cannot read properties of LEB %d, error %d",
                           lnum, err);
                 goto out;
         }
@@ -873,13 +873,13 @@ int dbg_check_cats(struct ubifs_info *c)
 
         list_for_each_entry(lprops, &c->empty_list, list) {
                 if (lprops->free != c->leb_size) {
-                        ubifs_err("non-empty LEB %d on empty list (free %d dirty %d flags %d)",
+                        ubifs_err(c, "non-empty LEB %d on empty list (free %d dirty %d flags %d)",
                                   lprops->lnum, lprops->free, lprops->dirty,
                                   lprops->flags);
                         return -EINVAL;
                 }
                 if (lprops->flags & LPROPS_TAKEN) {
-                        ubifs_err("taken LEB %d on empty list (free %d dirty %d flags %d)",
+                        ubifs_err(c, "taken LEB %d on empty list (free %d dirty %d flags %d)",
                                   lprops->lnum, lprops->free, lprops->dirty,
                                   lprops->flags);
                         return -EINVAL;
@@ -889,13 +889,13 @@ int dbg_check_cats(struct ubifs_info *c)
         i = 0;
         list_for_each_entry(lprops, &c->freeable_list, list) {
                 if (lprops->free + lprops->dirty != c->leb_size) {
-                        ubifs_err("non-freeable LEB %d on freeable list (free %d dirty %d flags %d)",
+                        ubifs_err(c, "non-freeable LEB %d on freeable list (free %d dirty %d flags %d)",
                                   lprops->lnum, lprops->free, lprops->dirty,
                                   lprops->flags);
                         return -EINVAL;
                 }
                 if (lprops->flags & LPROPS_TAKEN) {
-                        ubifs_err("taken LEB %d on freeable list (free %d dirty %d flags %d)",
+                        ubifs_err(c, "taken LEB %d on freeable list (free %d dirty %d flags %d)",
                                   lprops->lnum, lprops->free, lprops->dirty,
                                   lprops->flags);
                         return -EINVAL;
@@ -903,7 +903,7 @@ int dbg_check_cats(struct ubifs_info *c)
                 i += 1;
         }
         if (i != c->freeable_cnt) {
-                ubifs_err("freeable list count %d expected %d", i,
+                ubifs_err(c, "freeable list count %d expected %d", i,
                           c->freeable_cnt);
                 return -EINVAL;
         }
@@ -912,26 +912,26 @@ int dbg_check_cats(struct ubifs_info *c)
         list_for_each(pos, &c->idx_gc)
                 i += 1;
         if (i != c->idx_gc_cnt) {
-                ubifs_err("idx_gc list count %d expected %d", i,
+                ubifs_err(c, "idx_gc list count %d expected %d", i,
                           c->idx_gc_cnt);
                 return -EINVAL;
         }
 
         list_for_each_entry(lprops, &c->frdi_idx_list, list) {
                 if (lprops->free + lprops->dirty != c->leb_size) {
-                        ubifs_err("non-freeable LEB %d on frdi_idx list (free %d dirty %d flags %d)",
+                        ubifs_err(c, "non-freeable LEB %d on frdi_idx list (free %d dirty %d flags %d)",
                                   lprops->lnum, lprops->free, lprops->dirty,
                                   lprops->flags);
                         return -EINVAL;
                 }
                 if (lprops->flags & LPROPS_TAKEN) {
-                        ubifs_err("taken LEB %d on frdi_idx list (free %d dirty %d flags %d)",
+                        ubifs_err(c, "taken LEB %d on frdi_idx list (free %d dirty %d flags %d)",
                                   lprops->lnum, lprops->free, lprops->dirty,
                                   lprops->flags);
                         return -EINVAL;
                 }
                 if (!(lprops->flags & LPROPS_INDEX)) {
-                        ubifs_err("non-index LEB %d on frdi_idx list (free %d dirty %d flags %d)",
+                        ubifs_err(c, "non-index LEB %d on frdi_idx list (free %d dirty %d flags %d)",
                                   lprops->lnum, lprops->free, lprops->dirty,
                                   lprops->flags);
                         return -EINVAL;
@@ -944,15 +944,15 @@ int dbg_check_cats(struct ubifs_info *c)
                 for (i = 0; i < heap->cnt; i++) {
                         lprops = heap->arr[i];
                         if (!lprops) {
-                                ubifs_err("null ptr in LPT heap cat %d", cat);
+                                ubifs_err(c, "null ptr in LPT heap cat %d", cat);
                                 return -EINVAL;
                         }
                         if (lprops->hpos != i) {
-                                ubifs_err("bad ptr in LPT heap cat %d", cat);
+                                ubifs_err(c, "bad ptr in LPT heap cat %d", cat);
                                 return -EINVAL;
                         }
                         if (lprops->flags & LPROPS_TAKEN) {
-                                ubifs_err("taken LEB in LPT heap cat %d", cat);
+                                ubifs_err(c, "taken LEB in LPT heap cat %d", cat);
                                 return -EINVAL;
                         }
                 }
@@ -988,7 +988,7 @@ void dbg_check_heap(struct ubifs_info *c, struct ubifs_lpt_heap *heap, int cat,
                         goto out;
                 }
                 if (lprops != lp) {
-                        ubifs_err("lprops %zx lp %zx lprops->lnum %d lp->lnum %d",
+                        ubifs_err(c, "lprops %zx lp %zx lprops->lnum %d lp->lnum %d",
                                   (size_t)lprops, (size_t)lp, lprops->lnum,
                                   lp->lnum);
                         err = 4;
@@ -1008,7 +1008,7 @@ void dbg_check_heap(struct ubifs_info *c, struct ubifs_lpt_heap *heap, int cat,
         }
 out:
         if (err) {
-                ubifs_err("failed cat %d hpos %d err %d", cat, i, err);
+                ubifs_err(c, "failed cat %d hpos %d err %d", cat, i, err);
                 dump_stack();
                 ubifs_dump_heap(c, heap, cat);
         }
@@ -1039,7 +1039,7 @@ static int scan_check_cb(struct ubifs_info *c,
         if (cat != LPROPS_UNCAT) {
                 cat = ubifs_categorize_lprops(c, lp);
                 if (cat != (lp->flags & LPROPS_CAT_MASK)) {
-                        ubifs_err("bad LEB category %d expected %d",
+                        ubifs_err(c, "bad LEB category %d expected %d",
                                   (lp->flags & LPROPS_CAT_MASK), cat);
                         return -EINVAL;
                 }
@@ -1074,7 +1074,7 @@ static int scan_check_cb(struct ubifs_info *c,
                                 }
                         }
                         if (!found) {
-                                ubifs_err("bad LPT list (category %d)", cat);
+                                ubifs_err(c, "bad LPT list (category %d)", cat);
                                 return -EINVAL;
                         }
                 }
@@ -1086,7 +1086,7 @@ static int scan_check_cb(struct ubifs_info *c,
 
                 if ((lp->hpos != -1 && heap->arr[lp->hpos]->lnum != lnum) ||
                     lp != heap->arr[lp->hpos]) {
-                        ubifs_err("bad LPT heap (category %d)", cat);
+                        ubifs_err(c, "bad LPT heap (category %d)", cat);
                         return -EINVAL;
                 }
         }
@@ -1133,7 +1133,7 @@ static int scan_check_cb(struct ubifs_info *c,
                         is_idx = (snod->type == UBIFS_IDX_NODE) ? 1 : 0;
 
                 if (is_idx && snod->type != UBIFS_IDX_NODE) {
-                        ubifs_err("indexing node in data LEB %d:%d",
+                        ubifs_err(c, "indexing node in data LEB %d:%d",
                                   lnum, snod->offs);
                         goto out_destroy;
                 }
@@ -1159,7 +1159,7 @@ static int scan_check_cb(struct ubifs_info *c,
 
         if (free > c->leb_size || free < 0 || dirty > c->leb_size ||
             dirty < 0) {
-                ubifs_err("bad calculated accounting for LEB %d: free %d, dirty %d",
+                ubifs_err(c, "bad calculated accounting for LEB %d: free %d, dirty %d",
                           lnum, free, dirty);
                 goto out_destroy;
         }
@@ -1206,13 +1206,13 @@ static int scan_check_cb(struct ubifs_info *c,
                         /* Free but not unmapped LEB, it's fine */
                         is_idx = 0;
                 else {
-                        ubifs_err("indexing node without indexing flag");
+                        ubifs_err(c, "indexing node without indexing flag");
                         goto out_print;
                 }
         }
 
         if (!is_idx && (lp->flags & LPROPS_INDEX)) {
-                ubifs_err("data node with indexing flag");
+                ubifs_err(c, "data node with indexing flag");
                 goto out_print;
         }
 
@@ -1241,7 +1241,7 @@ static int scan_check_cb(struct ubifs_info *c,
         return LPT_SCAN_CONTINUE;
 
 out_print:
-        ubifs_err("bad accounting of LEB %d: free %d, dirty %d flags %#x, should be free %d, dirty %d",
+        ubifs_err(c, "bad accounting of LEB %d: free %d, dirty %d flags %#x, should be free %d, dirty %d",
                   lnum, lp->free, lp->dirty, lp->flags, free, dirty);
         ubifs_dump_leb(c, lnum);
 out_destroy:
@@ -1293,11 +1293,11 @@ int dbg_check_lprops(struct ubifs_info *c)
             lst.total_free != c->lst.total_free ||
             lst.total_dirty != c->lst.total_dirty ||
             lst.total_used != c->lst.total_used) {
-                ubifs_err("bad overall accounting");
-                ubifs_err("calculated: empty_lebs %d, idx_lebs %d, total_free %lld, total_dirty %lld, total_used %lld",
+                ubifs_err(c, "bad overall accounting");
+                ubifs_err(c, "calculated: empty_lebs %d, idx_lebs %d, total_free %lld, total_dirty %lld, total_used %lld",
                           lst.empty_lebs, lst.idx_lebs, lst.total_free,
                           lst.total_dirty, lst.total_used);
-                ubifs_err("read from lprops: empty_lebs %d, idx_lebs %d, total_free %lld, total_dirty %lld, total_used %lld",
+                ubifs_err(c, "read from lprops: empty_lebs %d, idx_lebs %d, total_free %lld, total_dirty %lld, total_used %lld",
                           c->lst.empty_lebs, c->lst.idx_lebs, c->lst.total_free,
                           c->lst.total_dirty, c->lst.total_used);
                 err = -EINVAL;
@@ -1306,10 +1306,10 @@ int dbg_check_lprops(struct ubifs_info *c)
 
         if (lst.total_dead != c->lst.total_dead ||
             lst.total_dark != c->lst.total_dark) {
-                ubifs_err("bad dead/dark space accounting");
-                ubifs_err("calculated: total_dead %lld, total_dark %lld",
+                ubifs_err(c, "bad dead/dark space accounting");
+                ubifs_err(c, "calculated: total_dead %lld, total_dark %lld",
                           lst.total_dead, lst.total_dark);
-                ubifs_err("read from lprops: total_dead %lld, total_dark %lld",
+                ubifs_err(c, "read from lprops: total_dead %lld, total_dark %lld",
                           c->lst.total_dead, c->lst.total_dark);
                 err = -EINVAL;
                 goto out;