BackMerge v4.19-rc5 into drm-next

[linux-2.6-microblaze.git] / fs / ubifs / lpt_commit.c

diff --git a/fs/ubifs/lpt_commit.c b/fs/ubifs/lpt_commit.c
index 78da65b..7ce3099 100644 (file)
--- a/fs/ubifs/lpt_commit.c
+++ b/fs/ubifs/lpt_commit.c
@@ -34,13 +34,14 @@ static int dbg_populate_lsave(struct ubifs_info *c);
 
 /**
  * first_dirty_cnode - find first dirty cnode.
+ * @c: UBIFS file-system description object
  * @nnode: nnode at which to start
  *
  * This function returns the first dirty cnode or %NULL if there is not one.
  */
-static struct ubifs_cnode *first_dirty_cnode(struct ubifs_nnode *nnode)
+static struct ubifs_cnode *first_dirty_cnode(const struct ubifs_info *c, struct ubifs_nnode *nnode)
 {
-       ubifs_assert(nnode);
+       ubifs_assert(c, nnode);
        while (1) {
                int i, cont = 0;
 
@@ -64,16 +65,17 @@ static struct ubifs_cnode *first_dirty_cnode(struct ubifs_nnode *nnode)
 
 /**
  * next_dirty_cnode - find next dirty cnode.
+ * @c: UBIFS file-system description object
  * @cnode: cnode from which to begin searching
  *
  * This function returns the next dirty cnode or %NULL if there is not one.
  */
-static struct ubifs_cnode *next_dirty_cnode(struct ubifs_cnode *cnode)
+static struct ubifs_cnode *next_dirty_cnode(const struct ubifs_info *c, struct ubifs_cnode *cnode)
 {
        struct ubifs_nnode *nnode;
        int i;
 
-       ubifs_assert(cnode);
+       ubifs_assert(c, cnode);
        nnode = cnode->parent;
        if (!nnode)
                return NULL;
@@ -83,7 +85,7 @@ static struct ubifs_cnode *next_dirty_cnode(struct ubifs_cnode *cnode)
                        if (cnode->level == 0)
                                return cnode; /* cnode is a pnode */
                        /* cnode is a nnode */
-                       return first_dirty_cnode((struct ubifs_nnode *)cnode);
+                       return first_dirty_cnode(c, (struct ubifs_nnode *)cnode);
                }
        }
        return (struct ubifs_cnode *)nnode;
@@ -106,15 +108,15 @@ static int get_cnodes_to_commit(struct ubifs_info *c)
        if (!test_bit(DIRTY_CNODE, &c->nroot->flags))
                return 0;
 
-       c->lpt_cnext = first_dirty_cnode(c->nroot);
+       c->lpt_cnext = first_dirty_cnode(c, c->nroot);
        cnode = c->lpt_cnext;
        if (!cnode)
                return 0;
        cnt += 1;
        while (1) {
-               ubifs_assert(!test_bit(COW_CNODE, &cnode->flags));
+               ubifs_assert(c, !test_bit(COW_CNODE, &cnode->flags));
                __set_bit(COW_CNODE, &cnode->flags);
-               cnext = next_dirty_cnode(cnode);
+               cnext = next_dirty_cnode(c, cnode);
                if (!cnext) {
                        cnode->cnext = c->lpt_cnext;
                        break;
@@ -125,7 +127,7 @@ static int get_cnodes_to_commit(struct ubifs_info *c)
        }
        dbg_cmt("committing %d cnodes", cnt);
        dbg_lp("committing %d cnodes", cnt);
-       ubifs_assert(cnt == c->dirty_nn_cnt + c->dirty_pn_cnt);
+       ubifs_assert(c, cnt == c->dirty_nn_cnt + c->dirty_pn_cnt);
        return cnt;
 }
 
@@ -141,7 +143,7 @@ static void upd_ltab(struct ubifs_info *c, int lnum, int free, int dirty)
        dbg_lp("LEB %d free %d dirty %d to %d +%d",
               lnum, c->ltab[lnum - c->lpt_first].free,
               c->ltab[lnum - c->lpt_first].dirty, free, dirty);
-       ubifs_assert(lnum >= c->lpt_first && lnum <= c->lpt_last);
+       ubifs_assert(c, lnum >= c->lpt_first && lnum <= c->lpt_last);
        c->ltab[lnum - c->lpt_first].free = free;
        c->ltab[lnum - c->lpt_first].dirty += dirty;
 }
@@ -237,7 +239,7 @@ static int layout_cnodes(struct ubifs_info *c)
                        if (err)
                                goto no_space;
                        offs = 0;
-                       ubifs_assert(lnum >= c->lpt_first &&
+                       ubifs_assert(c, lnum >= c->lpt_first &&
                                     lnum <= c->lpt_last);
                        /* Try to place lsave and ltab nicely */
                        if (!done_lsave) {
@@ -280,7 +282,7 @@ static int layout_cnodes(struct ubifs_info *c)
                        if (err)
                                goto no_space;
                        offs = 0;
-                       ubifs_assert(lnum >= c->lpt_first &&
+                       ubifs_assert(c, lnum >= c->lpt_first &&
                                     lnum <= c->lpt_last);
                }
                done_lsave = 1;
@@ -300,7 +302,7 @@ static int layout_cnodes(struct ubifs_info *c)
                        if (err)
                                goto no_space;
                        offs = 0;
-                       ubifs_assert(lnum >= c->lpt_first &&
+                       ubifs_assert(c, lnum >= c->lpt_first &&
                                     lnum <= c->lpt_last);
                }
                c->ltab_lnum = lnum;
@@ -423,7 +425,7 @@ static int write_cnodes(struct ubifs_info *c)
                        if (err)
                                goto no_space;
                        offs = from = 0;
-                       ubifs_assert(lnum >= c->lpt_first &&
+                       ubifs_assert(c, lnum >= c->lpt_first &&
                                     lnum <= c->lpt_last);
                        err = ubifs_leb_unmap(c, lnum);
                        if (err)
@@ -480,7 +482,7 @@ static int write_cnodes(struct ubifs_info *c)
                        if (err)
                                goto no_space;
                        offs = from = 0;
-                       ubifs_assert(lnum >= c->lpt_first &&
+                       ubifs_assert(c, lnum >= c->lpt_first &&
                                     lnum <= c->lpt_last);
                        err = ubifs_leb_unmap(c, lnum);
                        if (err)
@@ -506,7 +508,7 @@ static int write_cnodes(struct ubifs_info *c)
                        if (err)
                                goto no_space;
                        offs = from = 0;
-                       ubifs_assert(lnum >= c->lpt_first &&
+                       ubifs_assert(c, lnum >= c->lpt_first &&
                                     lnum <= c->lpt_last);
                        err = ubifs_leb_unmap(c, lnum);
                        if (err)
@@ -806,7 +808,7 @@ static void populate_lsave(struct ubifs_info *c)
        struct ubifs_lpt_heap *heap;
        int i, cnt = 0;
 
-       ubifs_assert(c->big_lpt);
+       ubifs_assert(c, c->big_lpt);
        if (!(c->lpt_drty_flgs & LSAVE_DIRTY)) {
                c->lpt_drty_flgs |= LSAVE_DIRTY;
                ubifs_add_lpt_dirt(c, c->lsave_lnum, c->lsave_sz);
@@ -1095,8 +1097,8 @@ static int get_lpt_node_type(const struct ubifs_info *c, uint8_t *buf,
        uint8_t *addr = buf + UBIFS_LPT_CRC_BYTES;
        int pos = 0, node_type;
 
-       node_type = ubifs_unpack_bits(&addr, &pos, UBIFS_LPT_TYPE_BITS);
-       *node_num = ubifs_unpack_bits(&addr, &pos, c->pcnt_bits);
+       node_type = ubifs_unpack_bits(c, &addr, &pos, UBIFS_LPT_TYPE_BITS);
+       *node_num = ubifs_unpack_bits(c, &addr, &pos, c->pcnt_bits);
        return node_type;
 }
 
@@ -1116,7 +1118,7 @@ static int is_a_node(const struct ubifs_info *c, uint8_t *buf, int len)
 
        if (len < UBIFS_LPT_CRC_BYTES + (UBIFS_LPT_TYPE_BITS + 7) / 8)
                return 0;
-       node_type = ubifs_unpack_bits(&addr, &pos, UBIFS_LPT_TYPE_BITS);
+       node_type = ubifs_unpack_bits(c, &addr, &pos, UBIFS_LPT_TYPE_BITS);
        if (node_type == UBIFS_LPT_NOT_A_NODE)
                return 0;
        node_len = get_lpt_node_len(c, node_type);
@@ -1124,7 +1126,7 @@ static int is_a_node(const struct ubifs_info *c, uint8_t *buf, int len)
                return 0;
        pos = 0;
        addr = buf;
-       crc = ubifs_unpack_bits(&addr, &pos, UBIFS_LPT_CRC_BITS);
+       crc = ubifs_unpack_bits(c, &addr, &pos, UBIFS_LPT_CRC_BITS);
        calc_crc = crc16(-1, buf + UBIFS_LPT_CRC_BYTES,
                         node_len - UBIFS_LPT_CRC_BYTES);
        if (crc != calc_crc)
@@ -1170,7 +1172,7 @@ static int lpt_gc_lnum(struct ubifs_info *c, int lnum)
                node_type = get_lpt_node_type(c, buf, &node_num);
                node_len = get_lpt_node_len(c, node_type);
                offs = c->leb_size - len;
-               ubifs_assert(node_len != 0);
+               ubifs_assert(c, node_len != 0);
                mutex_lock(&c->lp_mutex);
                err = make_node_dirty(c, node_type, node_num, lnum, offs);
                mutex_unlock(&c->lp_mutex);
@@ -1195,7 +1197,7 @@ static int lpt_gc(struct ubifs_info *c)
 
        mutex_lock(&c->lp_mutex);
        for (i = 0; i < c->lpt_lebs; i++) {
-               ubifs_assert(!c->ltab[i].tgc);
+               ubifs_assert(c, !c->ltab[i].tgc);
                if (i + c->lpt_first == c->nhead_lnum ||
                    c->ltab[i].free + c->ltab[i].dirty == c->leb_size)
                        continue;
@@ -1271,7 +1273,7 @@ int ubifs_lpt_start_commit(struct ubifs_info *c)
                populate_lsave(c);
 
        cnt = get_cnodes_to_commit(c);
-       ubifs_assert(cnt != 0);
+       ubifs_assert(c, cnt != 0);
 
        err = layout_cnodes(c);
        if (err)