UBIFS: do not print scary error messages needlessly

At the moment UBIFS print large and scary error messages and
flash dumps in case of nearly any corruption, even if it is
a recoverable corruption. For example, if the master node is
corrupted, ubifs_scan() prints error dumps, then UBIFS recovers
just fine and goes on.

This patch makes UBIFS print scary error messages only in
real cases, which are not recoverable. It adds 'quiet' argument
to the 'ubifs_scan()' function, so the caller may ask 'ubi_scan()'
not to print error messages if the caller is able to do recovery.

Signed-off-by: Artem Bityutskiy <Artem.Bityutskiy@nokia.com>
Reviewed-by: Adrian Hunter <Adrian.Hunter@nokia.com>

diff --git a/fs/ubifs/debug.c b/fs/ubifs/debug.c
index ce2cd834361805448b4102ebea0b67473127260d..8183ee0d4f9dbc5053f78c39d326e5cb4f8168eb 100644 (file)
--- a/fs/ubifs/debug.c
+++ b/fs/ubifs/debug.c
@@ -724,7 +724,7 @@ void dbg_dump_leb(const struct ubifs_info *c, int lnum)
 
        printk(KERN_DEBUG "(pid %d) start dumping LEB %d\n",
               current->pid, lnum);
-       sleb = ubifs_scan(c, lnum, 0, c->dbg->buf);
+       sleb = ubifs_scan(c, lnum, 0, c->dbg->buf, 0);
        if (IS_ERR(sleb)) {
                ubifs_err("scan error %d", (int)PTR_ERR(sleb));
                return;

diff --git a/fs/ubifs/gc.c b/fs/ubifs/gc.c
index f0f5f15d384ea311e730ae73f3fe3900b0a0eca9..618c2701d3a788ff821f35148d230090209b1eb6 100644 (file)
--- a/fs/ubifs/gc.c
+++ b/fs/ubifs/gc.c
@@ -529,7 +529,7 @@ int ubifs_garbage_collect_leb(struct ubifs_info *c, struct ubifs_lprops *lp)
         * We scan the entire LEB even though we only really need to scan up to
         * (c->leb_size - lp->free).
         */
-       sleb = ubifs_scan(c, lnum, 0, c->sbuf);
+       sleb = ubifs_scan(c, lnum, 0, c->sbuf, 0);
        if (IS_ERR(sleb))
                return PTR_ERR(sleb);
 

diff --git a/fs/ubifs/log.c b/fs/ubifs/log.c
index 56e33772a1ee1a12c3e3abb08e3b2aaa14fe42ee..60dcf6cbd61baedebf85def285a2c135e733a4eb 100644 (file)
--- a/fs/ubifs/log.c
+++ b/fs/ubifs/log.c
@@ -695,7 +695,7 @@ int ubifs_consolidate_log(struct ubifs_info *c)
        lnum = c->ltail_lnum;
        write_lnum = lnum;
        while (1) {
-               sleb = ubifs_scan(c, lnum, 0, c->sbuf);
+               sleb = ubifs_scan(c, lnum, 0, c->sbuf, 0);
                if (IS_ERR(sleb)) {
                        err = PTR_ERR(sleb);
                        goto out_free;

diff --git a/fs/ubifs/lprops.c b/fs/ubifs/lprops.c
index 4cdd284dea5688eddf40d21eeb5f70a83e2724b9..00f19b445aabf9c8769dd8af70dc62bb52969220 100644 (file)
--- a/fs/ubifs/lprops.c
+++ b/fs/ubifs/lprops.c
@@ -1096,7 +1096,7 @@ static int scan_check_cb(struct ubifs_info *c,
                }
        }
 
-       sleb = ubifs_scan(c, lnum, 0, c->dbg->buf);
+       sleb = ubifs_scan(c, lnum, 0, c->dbg->buf, 0);
        if (IS_ERR(sleb)) {
                /*
                 * After an unclean unmount, empty and freeable LEBs

diff --git a/fs/ubifs/master.c b/fs/ubifs/master.c
index a88f33801b989aa7316e6ab99e7629cddd9dfb67..6f95a168a56fee347c5b074bfd09dad46954651e 100644 (file)
--- a/fs/ubifs/master.c
+++ b/fs/ubifs/master.c
@@ -40,7 +40,7 @@ static int scan_for_master(struct ubifs_info *c)
 
        lnum = UBIFS_MST_LNUM;
 
-       sleb = ubifs_scan(c, lnum, 0, c->sbuf);
+       sleb = ubifs_scan(c, lnum, 0, c->sbuf, 1);
        if (IS_ERR(sleb))
                return PTR_ERR(sleb);
        nodes_cnt = sleb->nodes_cnt;
@@ -56,7 +56,7 @@ static int scan_for_master(struct ubifs_info *c)
 
        lnum += 1;
 
-       sleb = ubifs_scan(c, lnum, 0, c->sbuf);
+       sleb = ubifs_scan(c, lnum, 0, c->sbuf, 1);
        if (IS_ERR(sleb))
                return PTR_ERR(sleb);
        if (sleb->nodes_cnt != nodes_cnt)

diff --git a/fs/ubifs/orphan.c b/fs/ubifs/orphan.c
index 152a7b34a1414658d217f3604e61e10ea9e2c799..3119af3cdc510e0c2550724da97c702a1fd2c97d 100644 (file)
--- a/fs/ubifs/orphan.c
+++ b/fs/ubifs/orphan.c
@@ -670,7 +670,7 @@ static int kill_orphans(struct ubifs_info *c)
                struct ubifs_scan_leb *sleb;
 
                dbg_rcvry("LEB %d", lnum);
-               sleb = ubifs_scan(c, lnum, 0, c->sbuf);
+               sleb = ubifs_scan(c, lnum, 0, c->sbuf, 1);
                if (IS_ERR(sleb)) {
                        sleb = ubifs_recover_leb(c, lnum, 0, c->sbuf, 0);
                        if (IS_ERR(sleb)) {
@@ -899,7 +899,7 @@ static int dbg_scan_orphans(struct ubifs_info *c, struct check_info *ci)
        for (lnum = c->orph_first; lnum <= c->orph_last; lnum++) {
                struct ubifs_scan_leb *sleb;
 
-               sleb = ubifs_scan(c, lnum, 0, c->dbg->buf);
+               sleb = ubifs_scan(c, lnum, 0, c->dbg->buf, 0);
                if (IS_ERR(sleb)) {
                        err = PTR_ERR(sleb);
                        break;

diff --git a/fs/ubifs/recovery.c b/fs/ubifs/recovery.c
index e5f6cf8a115535e469a646e4806d9dcdbf19a490..f94ddf7efba01917ea5f92c1f2cb7bf2b5972633 100644 (file)
--- a/fs/ubifs/recovery.c
+++ b/fs/ubifs/recovery.c
@@ -286,7 +286,7 @@ int ubifs_recover_master_node(struct ubifs_info *c)
                mst = mst2;
        }
 
-       dbg_rcvry("recovered master node from LEB %d",
+       ubifs_msg("recovered master node from LEB %d",
                  (mst == mst1 ? UBIFS_MST_LNUM : UBIFS_MST_LNUM + 1));
 
        memcpy(c->mst_node, mst, UBIFS_MST_NODE_SZ);
@@ -790,7 +790,7 @@ struct ubifs_scan_leb *ubifs_recover_log_leb(struct ubifs_info *c, int lnum,
                 * We can only recover at the end of the log, so check that the
                 * next log LEB is empty or out of date.
                 */
-               sleb = ubifs_scan(c, next_lnum, 0, sbuf);
+               sleb = ubifs_scan(c, next_lnum, 0, sbuf, 0);
                if (IS_ERR(sleb))
                        return sleb;
                if (sleb->nodes_cnt) {

diff --git a/fs/ubifs/replay.c b/fs/ubifs/replay.c
index 2970500f32dfbb76ca9b8d6ff39fd8ee08fada4a..5c2d6d759a3e76fa87bfc9bd29e10bd10eff0c6d 100644 (file)
--- a/fs/ubifs/replay.c
+++ b/fs/ubifs/replay.c
@@ -506,7 +506,7 @@ static int replay_bud(struct ubifs_info *c, int lnum, int offs, int jhead,
        if (c->need_recovery)
                sleb = ubifs_recover_leb(c, lnum, offs, c->sbuf, jhead != GCHD);
        else
-               sleb = ubifs_scan(c, lnum, offs, c->sbuf);
+               sleb = ubifs_scan(c, lnum, offs, c->sbuf, 0);
        if (IS_ERR(sleb))
                return PTR_ERR(sleb);
 
@@ -836,8 +836,8 @@ static int replay_log_leb(struct ubifs_info *c, int lnum, int offs, void *sbuf)
        const struct ubifs_cs_node *node;
 
        dbg_mnt("replay log LEB %d:%d", lnum, offs);
-       sleb = ubifs_scan(c, lnum, offs, sbuf);
-       if (IS_ERR(sleb) ) {
+       sleb = ubifs_scan(c, lnum, offs, sbuf, c->need_recovery);
+       if (IS_ERR(sleb)) {
                if (PTR_ERR(sleb) != -EUCLEAN || !c->need_recovery)
                        return PTR_ERR(sleb);
                sleb = ubifs_recover_log_leb(c, lnum, offs, sbuf);

diff --git a/fs/ubifs/scan.c b/fs/ubifs/scan.c
index 892ebfee4fe538fe033596c5d42d13860d5fe82a..96c525384191d91af6ce99c700295dc78cb744cf 100644 (file)
--- a/fs/ubifs/scan.c
+++ b/fs/ubifs/scan.c
@@ -108,10 +108,9 @@ int ubifs_scan_a_node(const struct ubifs_info *c, void *buf, int len, int lnum,
 
                /* Make the node pads to 8-byte boundary */
                if ((node_len + pad_len) & 7) {
-                       if (!quiet) {
+                       if (!quiet)
                                dbg_err("bad padding length %d - %d",
                                        offs, offs + node_len + pad_len);
-                       }
                        return SCANNED_A_BAD_PAD_NODE;
                }
 
@@ -253,15 +252,19 @@ void ubifs_scanned_corruption(const struct ubifs_info *c, int lnum, int offs,
  * @c: UBIFS file-system description object
  * @lnum: logical eraseblock number
  * @offs: offset to start at (usually zero)
- * @sbuf: scan buffer (must be c->leb_size)
+ * @sbuf: scan buffer (must be of @c->leb_size bytes in size)
+ * @quiet: print no messages
  *
  * This function scans LEB number @lnum and returns complete information about
  * its contents. Returns the scaned information in case of success and,
  * %-EUCLEAN if the LEB neads recovery, and other negative error codes in case
  * of failure.
+ *
+ * If @quiet is non-zero, this function does not print large and scary
+ * error messages and flash dumps in case of errors.
  */
 struct ubifs_scan_leb *ubifs_scan(const struct ubifs_info *c, int lnum,
-                                 int offs, void *sbuf)
+                                 int offs, void *sbuf, int quiet)
 {
        void *buf = sbuf + offs;
        int err, len = c->leb_size - offs;
@@ -280,7 +283,7 @@ struct ubifs_scan_leb *ubifs_scan(const struct ubifs_info *c, int lnum,
 
                cond_resched();
 
-               ret = ubifs_scan_a_node(c, buf, len, lnum, offs, 0);
+               ret = ubifs_scan_a_node(c, buf, len, lnum, offs, quiet);
                if (ret > 0) {
                        /* Padding bytes or a valid padding node */
                        offs += ret;
@@ -320,7 +323,9 @@ struct ubifs_scan_leb *ubifs_scan(const struct ubifs_info *c, int lnum,
        }
 
        if (offs % c->min_io_size) {
-               ubifs_err("empty space starts at non-aligned offset %d", offs);
+               if (!quiet)
+                       ubifs_err("empty space starts at non-aligned offset %d",
+                                 offs);
                goto corrupted;;
        }
 
@@ -331,18 +336,25 @@ struct ubifs_scan_leb *ubifs_scan(const struct ubifs_info *c, int lnum,
                        break;
        for (; len; offs++, buf++, len--)
                if (*(uint8_t *)buf != 0xff) {
-                       ubifs_err("corrupt empty space at LEB %d:%d",
-                                 lnum, offs);
+                       if (!quiet)
+                               ubifs_err("corrupt empty space at LEB %d:%d",
+                                         lnum, offs);
                        goto corrupted;
                }
 
        return sleb;
 
 corrupted:
-       ubifs_scanned_corruption(c, lnum, offs, buf);
+       if (!quiet) {
+               ubifs_scanned_corruption(c, lnum, offs, buf);
+               ubifs_err("LEB %d scanning failed", lnum);
+       }
        err = -EUCLEAN;
+       ubifs_scan_destroy(sleb);
+       return ERR_PTR(err);
+
 error:
-       ubifs_err("LEB %d scanning failed", lnum);
+       ubifs_err("LEB %d scanning failed, error %d", lnum, err);
        ubifs_scan_destroy(sleb);
        return ERR_PTR(err);
 }

diff --git a/fs/ubifs/tnc_commit.c b/fs/ubifs/tnc_commit.c
index fde8d127c768d11c6b16087f4a2a6437b729c1d1..53288e5d604e92bd5584b1a3595565261a1c2c81 100644 (file)
--- a/fs/ubifs/tnc_commit.c
+++ b/fs/ubifs/tnc_commit.c
@@ -245,7 +245,7 @@ static int layout_leb_in_gaps(struct ubifs_info *c, int *p)
         * it is more comprehensive and less efficient than is needed for this
         * purpose.
         */
-       sleb = ubifs_scan(c, lnum, 0, c->ileb_buf);
+       sleb = ubifs_scan(c, lnum, 0, c->ileb_buf, 0);
        c->ileb_len = 0;
        if (IS_ERR(sleb))
                return PTR_ERR(sleb);

diff --git a/fs/ubifs/ubifs.h b/fs/ubifs/ubifs.h
index a29349094422731766fa82a95201e0f14ad3c7fb..9782e7cf8f2b2a132a9f027f3f3592f4a6d9e344 100644 (file)
--- a/fs/ubifs/ubifs.h
+++ b/fs/ubifs/ubifs.h
@@ -1451,7 +1451,7 @@ int ubifs_sync_wbufs_by_inode(struct ubifs_info *c, struct inode *inode);
 
 /* scan.c */
 struct ubifs_scan_leb *ubifs_scan(const struct ubifs_info *c, int lnum,
-                                 int offs, void *sbuf);
+                                 int offs, void *sbuf, int quiet);
 void ubifs_scan_destroy(struct ubifs_scan_leb *sleb);
 int ubifs_scan_a_node(const struct ubifs_info *c, void *buf, int len, int lnum,
                      int offs, int quiet);