UBIFS: switch to ubifs_leb_read

Instead of using 'ubi_read()' function directly, used the 'ubifs_leb_read()'
helper function instead. This allows to get rid of several redundant error
messages and make sure that we always have a stack dump on read errors.

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

diff --git a/fs/ubifs/io.c b/fs/ubifs/io.c
index 239899d7bf3fbc512cdaaecd379831b30893c652..f58f11bed3877ee978e431afcc9bb71b7182b7c6 100644 (file)
--- a/fs/ubifs/io.c
+++ b/fs/ubifs/io.c
@@ -941,13 +941,9 @@ int ubifs_read_node_wbuf(struct ubifs_wbuf *wbuf, void *buf, int type, int len,
 
        if (rlen > 0) {
                /* Read everything that goes before write-buffer */
-               err = ubi_read(c->ubi, lnum, buf, offs, rlen);
-               if (err && err != -EBADMSG) {
-                       ubifs_err("failed to read node %d from LEB %d:%d, "
-                                 "error %d", type, lnum, offs, err);
-                       dbg_dump_stack();
+               err = ubifs_leb_read(c, lnum, buf, offs, rlen, 0);
+               if (err && err != -EBADMSG)
                        return err;
-               }
        }
 
        if (type != ch->node_type) {
@@ -1002,12 +998,9 @@ int ubifs_read_node(const struct ubifs_info *c, void *buf, int type, int len,
        ubifs_assert(!(offs & 7) && offs < c->leb_size);
        ubifs_assert(type >= 0 && type < UBIFS_NODE_TYPES_CNT);
 
-       err = ubi_read(c->ubi, lnum, buf, offs, len);
-       if (err && err != -EBADMSG) {
-               ubifs_err("cannot read node %d from LEB %d:%d, error %d",
-                         type, lnum, offs, err);
+       err = ubifs_leb_read(c, lnum, buf, offs, len, 0);
+       if (err && err != -EBADMSG)
                return err;
-       }
 
        if (type != ch->node_type) {
                ubifs_err("bad node type (%d but expected %d)",

diff --git a/fs/ubifs/lpt.c b/fs/ubifs/lpt.c
index ab91ca6284554d5837795009a7a80167d3d39ba0..8b9ee9fe0a413017a08bfcf0d810fa34f2e3be51 100644 (file)
--- a/fs/ubifs/lpt.c
+++ b/fs/ubifs/lpt.c
@@ -1222,7 +1222,7 @@ int ubifs_read_nnode(struct ubifs_info *c, struct ubifs_nnode *parent, int iip)
                if (c->big_lpt)
                        nnode->num = calc_nnode_num_from_parent(c, parent, iip);
        } else {
-               err = ubi_read(c->ubi, lnum, buf, offs, c->nnode_sz);
+               err = ubifs_leb_read(c, lnum, buf, offs, c->nnode_sz, 1);
                if (err)
                        goto out;
                err = ubifs_unpack_nnode(c, buf, nnode);
@@ -1291,7 +1291,7 @@ static int read_pnode(struct ubifs_info *c, struct ubifs_nnode *parent, int iip)
                        lprops->flags = ubifs_categorize_lprops(c, lprops);
                }
        } else {
-               err = ubi_read(c->ubi, lnum, buf, offs, c->pnode_sz);
+               err = ubifs_leb_read(c, lnum, buf, offs, c->pnode_sz, 1);
                if (err)
                        goto out;
                err = unpack_pnode(c, buf, pnode);
@@ -1333,7 +1333,7 @@ static int read_ltab(struct ubifs_info *c)
        buf = vmalloc(c->ltab_sz);
        if (!buf)
                return -ENOMEM;
-       err = ubi_read(c->ubi, c->ltab_lnum, buf, c->ltab_offs, c->ltab_sz);
+       err = ubifs_leb_read(c, c->ltab_lnum, buf, c->ltab_offs, c->ltab_sz, 1);
        if (err)
                goto out;
        err = unpack_ltab(c, buf);
@@ -1356,7 +1356,8 @@ static int read_lsave(struct ubifs_info *c)
        buf = vmalloc(c->lsave_sz);
        if (!buf)
                return -ENOMEM;
-       err = ubi_read(c->ubi, c->lsave_lnum, buf, c->lsave_offs, c->lsave_sz);
+       err = ubifs_leb_read(c, c->lsave_lnum, buf, c->lsave_offs,
+                            c->lsave_sz, 1);
        if (err)
                goto out;
        err = unpack_lsave(c, buf);
@@ -1816,8 +1817,8 @@ static struct ubifs_nnode *scan_get_nnode(struct ubifs_info *c,
                if (c->big_lpt)
                        nnode->num = calc_nnode_num_from_parent(c, parent, iip);
        } else {
-               err = ubi_read(c->ubi, branch->lnum, buf, branch->offs,
-                              c->nnode_sz);
+               err = ubifs_leb_read(c, branch->lnum, buf, branch->offs,
+                                    c->nnode_sz, 1);
                if (err)
                        return ERR_PTR(err);
                err = ubifs_unpack_nnode(c, buf, nnode);
@@ -1885,8 +1886,8 @@ static struct ubifs_pnode *scan_get_pnode(struct ubifs_info *c,
                ubifs_assert(branch->lnum >= c->lpt_first &&
                             branch->lnum <= c->lpt_last);
                ubifs_assert(branch->offs >= 0 && branch->offs < c->leb_size);
-               err = ubi_read(c->ubi, branch->lnum, buf, branch->offs,
-                              c->pnode_sz);
+               err = ubifs_leb_read(c, branch->lnum, buf, branch->offs,
+                                    c->pnode_sz, 1);
                if (err)
                        return ERR_PTR(err);
                err = unpack_pnode(c, buf, pnode);

diff --git a/fs/ubifs/lpt_commit.c b/fs/ubifs/lpt_commit.c
index f13addf72e895c41e08d530121ffcbe47e543e0b..cddd6bd214f415c6fbe115bf823c69c418408f8b 100644 (file)
--- a/fs/ubifs/lpt_commit.c
+++ b/fs/ubifs/lpt_commit.c
@@ -1161,11 +1161,11 @@ static int lpt_gc_lnum(struct ubifs_info *c, int lnum)
        void *buf = c->lpt_buf;
 
        dbg_lp("LEB %d", lnum);
-       err = ubi_read(c->ubi, lnum, buf, 0, c->leb_size);
-       if (err) {
-               ubifs_err("cannot read LEB %d, error %d", lnum, err);
+
+       err = ubifs_leb_read(c, lnum, buf, 0, c->leb_size, 1);
+       if (err)
                return err;
-       }
+
        while (1) {
                if (!is_a_node(c, buf, len)) {
                        int pad_len;
@@ -1651,11 +1651,11 @@ static int dbg_check_ltab_lnum(struct ubifs_info *c, int lnum)
        }
 
        dbg_lp("LEB %d", lnum);
-       err = ubi_read(c->ubi, lnum, buf, 0, c->leb_size);
-       if (err) {
-               dbg_msg("ubi_read failed, LEB %d, error %d", lnum, err);
+
+       err = ubifs_leb_read(c, lnum, buf, 0, c->leb_size, 1);
+       if (err)
                goto out;
-       }
+
        while (1) {
                if (!is_a_node(c, p, len)) {
                        int i, pad_len;
@@ -1902,11 +1902,10 @@ static void dump_lpt_leb(const struct ubifs_info *c, int lnum)
                return;
        }
 
-       err = ubi_read(c->ubi, lnum, buf, 0, c->leb_size);
-       if (err) {
-               ubifs_err("cannot read LEB %d, error %d", lnum, err);
+       err = ubifs_leb_read(c, lnum, buf, 0, c->leb_size, 1);
+       if (err)
                goto out;
-       }
+
        while (1) {
                offs = c->leb_size - len;
                if (!is_a_node(c, p, len)) {

diff --git a/fs/ubifs/recovery.c b/fs/ubifs/recovery.c
index c591549807198869113c4ede6102c5af19c599e5..f28070cb00c6fe004d9f9ddafd8951803610f05e 100644 (file)
--- a/fs/ubifs/recovery.c
+++ b/fs/ubifs/recovery.c
@@ -117,7 +117,7 @@ static int get_master_node(const struct ubifs_info *c, int lnum, void **pbuf,
        if (!sbuf)
                return -ENOMEM;
 
-       err = ubi_read(c->ubi, lnum, sbuf, 0, c->leb_size);
+       err = ubifs_leb_read(c, lnum, sbuf, 0, c->leb_size, 0);
        if (err && err != -EBADMSG)
                goto out_free;
 
@@ -539,8 +539,8 @@ static int fix_unclean_leb(struct ubifs_info *c, struct ubifs_scan_leb *sleb,
                        int len = ALIGN(endpt, c->min_io_size);
 
                        if (start) {
-                               err = ubi_read(c->ubi, lnum, sleb->buf, 0,
-                                              start);
+                               err = ubifs_leb_read(c, lnum, sleb->buf, 0,
+                                                    start, 1);
                                if (err)
                                        return err;
                        }
@@ -819,7 +819,8 @@ static int get_cs_sqnum(struct ubifs_info *c, int lnum, int offs,
                return -ENOMEM;
        if (c->leb_size - offs < UBIFS_CS_NODE_SZ)
                goto out_err;
-       err = ubi_read(c->ubi, lnum, (void *)cs_node, offs, UBIFS_CS_NODE_SZ);
+       err = ubifs_leb_read(c, lnum, (void *)cs_node, offs,
+                            UBIFS_CS_NODE_SZ, 0);
        if (err && err != -EBADMSG)
                goto out_free;
        ret = ubifs_scan_a_node(c, cs_node, UBIFS_CS_NODE_SZ, lnum, offs, 0);
@@ -930,12 +931,12 @@ static int recover_head(struct ubifs_info *c, int lnum, int offs, void *sbuf)
                return 0;
 
        /* Read at the head location and check it is empty flash */
-       err = ubi_read(c->ubi, lnum, sbuf, offs, len);
+       err = ubifs_leb_read(c, lnum, sbuf, offs, len, 1);
        if (err || !is_empty(sbuf, len)) {
                dbg_rcvry("cleaning head at %d:%d", lnum, offs);
                if (offs == 0)
                        return ubifs_leb_unmap(c, lnum);
-               err = ubi_read(c->ubi, lnum, sbuf, 0, offs);
+               err = ubifs_leb_read(c, lnum, sbuf, 0, offs, 1);
                if (err)
                        return err;
                return ubi_leb_change(c->ubi, lnum, sbuf, offs, UBI_UNKNOWN);
@@ -1008,7 +1009,7 @@ static int clean_an_unclean_leb(struct ubifs_info *c,
                return 0;
        }
 
-       err = ubi_read(c->ubi, lnum, buf, offs, len);
+       err = ubifs_leb_read(c, lnum, buf, offs, len, 0);
        if (err && err != -EBADMSG)
                return err;
 
@@ -1453,7 +1454,7 @@ static int fix_size_in_place(struct ubifs_info *c, struct size_entry *e)
        if (i_size >= e->d_size)
                return 0;
        /* Read the LEB */
-       err = ubi_read(c->ubi, lnum, c->sbuf, 0, c->leb_size);
+       err = ubifs_leb_read(c, lnum, c->sbuf, 0, c->leb_size, 1);
        if (err)
                goto out;
        /* Change the size field and recalculate the CRC */

diff --git a/fs/ubifs/replay.c b/fs/ubifs/replay.c
index 5e97161ce4d35f929a953184098057f37454dde2..ccabaf1164b333a1fd276a2fff5beabdaa0bda1d 100644 (file)
--- a/fs/ubifs/replay.c
+++ b/fs/ubifs/replay.c
@@ -523,8 +523,7 @@ static int is_last_bud(struct ubifs_info *c, struct ubifs_bud *bud)
        if (!list_is_last(&next->list, &jh->buds_list))
                return 0;
 
-       err = ubi_read(c->ubi, next->lnum, (char *)&data,
-                      next->start, 4);
+       err = ubifs_leb_read(c, next->lnum, (char *)&data, next->start, 4, 1);
        if (err)
                return 0;
 

diff --git a/fs/ubifs/sb.c b/fs/ubifs/sb.c
index c606f010e8df072882d23633c9a58831ca805f86..701dccc1d6defbb6b2a76b9bd7c542cfa41e11c7 100644 (file)
--- a/fs/ubifs/sb.c
+++ b/fs/ubifs/sb.c
@@ -678,7 +678,7 @@ static int fixup_leb(struct ubifs_info *c, int lnum, int len)
        }
 
        dbg_mnt("fixup LEB %d, data len %d", lnum, len);
-       err = ubi_read(c->ubi, lnum, c->sbuf, 0, len);
+       err = ubifs_leb_read(c, lnum, c->sbuf, 0, len, 1);
        if (err)
                return err;
 

diff --git a/fs/ubifs/scan.c b/fs/ubifs/scan.c
index c7df916dce975842b560e3bba1320869834e83f9..37383e8011b1caf4342a19b6e471cd92753ed190 100644 (file)
--- a/fs/ubifs/scan.c
+++ b/fs/ubifs/scan.c
@@ -148,7 +148,7 @@ struct ubifs_scan_leb *ubifs_start_scan(const struct ubifs_info *c, int lnum,
        INIT_LIST_HEAD(&sleb->nodes);
        sleb->buf = sbuf;
 
-       err = ubi_read(c->ubi, lnum, sbuf + offs, offs, c->leb_size - offs);
+       err = ubifs_leb_read(c, lnum, sbuf + offs, offs, c->leb_size - offs, 0);
        if (err && err != -EBADMSG) {
                ubifs_err("cannot read %d bytes from LEB %d:%d,"
                          " error %d", c->leb_size - offs, lnum, offs, err);

diff --git a/fs/ubifs/tnc.c b/fs/ubifs/tnc.c
index 526b63cd33331f846c4ad54335c9ed1ab6fdd3c4..066738647685ba8ad2d371060bfd226e12020e3b 100644 (file)
--- a/fs/ubifs/tnc.c
+++ b/fs/ubifs/tnc.c
@@ -462,7 +462,7 @@ static int try_read_node(const struct ubifs_info *c, void *buf, int type,
 
        dbg_io("LEB %d:%d, %s, length %d", lnum, offs, dbg_ntype(type), len);
 
-       err = ubi_read(c->ubi, lnum, buf, offs, len);
+       err = ubifs_leb_read(c, lnum, buf, offs, len, 1);
        if (err) {
                ubifs_err("cannot read node type %d from LEB %d:%d, error %d",
                          type, lnum, offs, err);
@@ -1666,7 +1666,7 @@ static int read_wbuf(struct ubifs_wbuf *wbuf, void *buf, int len, int lnum,
        if (!overlap) {
                /* We may safely unlock the write-buffer and read the data */
                spin_unlock(&wbuf->lock);
-               return ubi_read(c->ubi, lnum, buf, offs, len);
+               return ubifs_leb_read(c, lnum, buf, offs, len, 0);
        }
 
        /* Don't read under wbuf */
@@ -1680,7 +1680,7 @@ static int read_wbuf(struct ubifs_wbuf *wbuf, void *buf, int len, int lnum,
 
        if (rlen > 0)
                /* Read everything that goes before write-buffer */
-               return ubi_read(c->ubi, lnum, buf, offs, rlen);
+               return ubifs_leb_read(c, lnum, buf, offs, rlen, 0);
 
        return 0;
 }
@@ -1767,7 +1767,7 @@ int ubifs_tnc_bulk_read(struct ubifs_info *c, struct bu_info *bu)
        if (wbuf)
                err = read_wbuf(wbuf, bu->buf, len, lnum, offs);
        else
-               err = ubi_read(c->ubi, lnum, bu->buf, offs, len);
+               err = ubifs_leb_read(c, lnum, bu->buf, offs, len, 0);
 
        /* Check for a race with GC */
        if (maybe_leb_gced(c, lnum, bu->gc_seq))