ubifs: Pass struct ubifs_info to ubifs_assert()

This allows us to have more context in ubifs_assert()
and take different actions depending on the configuration.

Signed-off-by: Richard Weinberger <richard@nod.at>

1 files changed, 26 insertions, 24 deletions

diff --git a/fs/ubifs/lpt_commit.c b/fs/ubifs/lpt_commit.c
index 78da65b2fb85..7ce30994bbba 100644
--- 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)