Commit 6eb61d58 authored by Richard Weinberger's avatar Richard Weinberger
Browse files

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: default avatarRichard Weinberger <richard@nod.at>
parent 54169ddd

fs/ubifs/budget.c

+34 −34
Original line number Diff line number Diff line
@@ -439,16 +439,16 @@ int ubifs_budget_space(struct ubifs_info *c, struct ubifs_budget_req *req) 
{

	int err, idx_growth, data_growth, dd_growth, retried = 0;



	ubifs_assert(req->new_page <= 1);

	ubifs_assert(req->dirtied_page <= 1);

	ubifs_assert(req->new_dent <= 1);

	ubifs_assert(req->mod_dent <= 1);

	ubifs_assert(req->new_ino <= 1);

	ubifs_assert(req->new_ino_d <= UBIFS_MAX_INO_DATA);

	ubifs_assert(req->dirtied_ino <= 4);

	ubifs_assert(req->dirtied_ino_d <= UBIFS_MAX_INO_DATA * 4);

	ubifs_assert(!(req->new_ino_d & 7));

	ubifs_assert(!(req->dirtied_ino_d & 7));

	ubifs_assert(c, req->new_page <= 1);

	ubifs_assert(c, req->dirtied_page <= 1);

	ubifs_assert(c, req->new_dent <= 1);

	ubifs_assert(c, req->mod_dent <= 1);

	ubifs_assert(c, req->new_ino <= 1);

	ubifs_assert(c, req->new_ino_d <= UBIFS_MAX_INO_DATA);

	ubifs_assert(c, req->dirtied_ino <= 4);

	ubifs_assert(c, req->dirtied_ino_d <= UBIFS_MAX_INO_DATA * 4);

	ubifs_assert(c, !(req->new_ino_d & 7));

	ubifs_assert(c, !(req->dirtied_ino_d & 7));



	data_growth = calc_data_growth(c, req);

	dd_growth = calc_dd_growth(c, req);
@@ -458,9 +458,9 @@ int ubifs_budget_space(struct ubifs_info *c, struct ubifs_budget_req *req) 


again:

	spin_lock(&c->space_lock);

	ubifs_assert(c->bi.idx_growth >= 0);

	ubifs_assert(c->bi.data_growth >= 0);

	ubifs_assert(c->bi.dd_growth >= 0);

	ubifs_assert(c, c->bi.idx_growth >= 0);

	ubifs_assert(c, c->bi.data_growth >= 0);

	ubifs_assert(c, c->bi.dd_growth >= 0);



	if (unlikely(c->bi.nospace) && (c->bi.nospace_rp || !can_use_rp(c))) {

		dbg_budg("no space");
@@ -526,20 +526,20 @@ int ubifs_budget_space(struct ubifs_info *c, struct ubifs_budget_req *req) 
 */

void ubifs_release_budget(struct ubifs_info *c, struct ubifs_budget_req *req)

{

	ubifs_assert(req->new_page <= 1);

	ubifs_assert(req->dirtied_page <= 1);

	ubifs_assert(req->new_dent <= 1);

	ubifs_assert(req->mod_dent <= 1);

	ubifs_assert(req->new_ino <= 1);

	ubifs_assert(req->new_ino_d <= UBIFS_MAX_INO_DATA);

	ubifs_assert(req->dirtied_ino <= 4);

	ubifs_assert(req->dirtied_ino_d <= UBIFS_MAX_INO_DATA * 4);

	ubifs_assert(!(req->new_ino_d & 7));

	ubifs_assert(!(req->dirtied_ino_d & 7));

	ubifs_assert(c, req->new_page <= 1);

	ubifs_assert(c, req->dirtied_page <= 1);

	ubifs_assert(c, req->new_dent <= 1);

	ubifs_assert(c, req->mod_dent <= 1);

	ubifs_assert(c, req->new_ino <= 1);

	ubifs_assert(c, req->new_ino_d <= UBIFS_MAX_INO_DATA);

	ubifs_assert(c, req->dirtied_ino <= 4);

	ubifs_assert(c, req->dirtied_ino_d <= UBIFS_MAX_INO_DATA * 4);

	ubifs_assert(c, !(req->new_ino_d & 7));

	ubifs_assert(c, !(req->dirtied_ino_d & 7));

	if (!req->recalculate) {

		ubifs_assert(req->idx_growth >= 0);

		ubifs_assert(req->data_growth >= 0);

		ubifs_assert(req->dd_growth >= 0);

		ubifs_assert(c, req->idx_growth >= 0);

		ubifs_assert(c, req->data_growth >= 0);

		ubifs_assert(c, req->dd_growth >= 0);

	}



	if (req->recalculate) {
@@ -561,13 +561,13 @@ void ubifs_release_budget(struct ubifs_info *c, struct ubifs_budget_req *req) 
	c->bi.dd_growth -= req->dd_growth;

	c->bi.min_idx_lebs = ubifs_calc_min_idx_lebs(c);



	ubifs_assert(c->bi.idx_growth >= 0);

	ubifs_assert(c->bi.data_growth >= 0);

	ubifs_assert(c->bi.dd_growth >= 0);

	ubifs_assert(c->bi.min_idx_lebs < c->main_lebs);

	ubifs_assert(!(c->bi.idx_growth & 7));

	ubifs_assert(!(c->bi.data_growth & 7));

	ubifs_assert(!(c->bi.dd_growth & 7));

	ubifs_assert(c, c->bi.idx_growth >= 0);

	ubifs_assert(c, c->bi.data_growth >= 0);

	ubifs_assert(c, c->bi.dd_growth >= 0);

	ubifs_assert(c, c->bi.min_idx_lebs < c->main_lebs);

	ubifs_assert(c, !(c->bi.idx_growth & 7));

	ubifs_assert(c, !(c->bi.data_growth & 7));

	ubifs_assert(c, !(c->bi.dd_growth & 7));

	spin_unlock(&c->space_lock);

}
@@ -680,7 +680,7 @@ long long ubifs_get_free_space_nolock(struct ubifs_info *c) 
	int rsvd_idx_lebs, lebs;

	long long available, outstanding, free;



	ubifs_assert(c->bi.min_idx_lebs == ubifs_calc_min_idx_lebs(c));

	ubifs_assert(c, c->bi.min_idx_lebs == ubifs_calc_min_idx_lebs(c));

	outstanding = c->bi.data_growth + c->bi.dd_growth;

	available = ubifs_calc_available(c, c->bi.min_idx_lebs);

fs/ubifs/commit.c

+4 −4
Original line number Diff line number Diff line
@@ -91,9 +91,9 @@ static int nothing_to_commit(struct ubifs_info *c) 
	if (c->nroot && test_bit(DIRTY_CNODE, &c->nroot->flags))

		return 0;



	ubifs_assert(atomic_long_read(&c->dirty_zn_cnt) == 0);

	ubifs_assert(c->dirty_pn_cnt == 0);

	ubifs_assert(c->dirty_nn_cnt == 0);

	ubifs_assert(c, atomic_long_read(&c->dirty_zn_cnt) == 0);

	ubifs_assert(c, c->dirty_pn_cnt == 0);

	ubifs_assert(c, c->dirty_nn_cnt == 0);



	return 1;

}
@@ -113,7 +113,7 @@ static int do_commit(struct ubifs_info *c) 
	struct ubifs_lp_stats lst;



	dbg_cmt("start");

	ubifs_assert(!c->ro_media && !c->ro_mount);

	ubifs_assert(c, !c->ro_media && !c->ro_mount);



	if (c->ro_error) {

		err = -EROFS;

fs/ubifs/crypto.c

+2 −2
Original line number Diff line number Diff line
@@ -32,7 +32,7 @@ int ubifs_encrypt(const struct inode *inode, struct ubifs_data_node *dn, 
	struct page *ret;

	unsigned int pad_len = round_up(in_len, UBIFS_CIPHER_BLOCK_SIZE);



	ubifs_assert(pad_len <= *out_len);

	ubifs_assert(c, pad_len <= *out_len);

	dn->compr_size = cpu_to_le16(in_len);



	/* pad to full block cipher length */
@@ -63,7 +63,7 @@ int ubifs_decrypt(const struct inode *inode, struct ubifs_data_node *dn, 
		return -EINVAL;

	}



	ubifs_assert(dlen <= UBIFS_BLOCK_SIZE);

	ubifs_assert(c, dlen <= UBIFS_BLOCK_SIZE);

	err = fscrypt_decrypt_page(inode, virt_to_page(&dn->data), dlen,

			offset_in_page(&dn->data), block);

	if (err) {

fs/ubifs/debug.c

+10 −10
Original line number Diff line number Diff line
@@ -134,7 +134,7 @@ const char *dbg_snprintf_key(const struct ubifs_info *c, 
		}

	} else

		len -= snprintf(p, len, "bad key format %d", c->key_fmt);

	ubifs_assert(len > 0);

	ubifs_assert(c, len > 0);

	return p;

}
@@ -276,7 +276,7 @@ void ubifs_dump_inode(struct ubifs_info *c, const struct inode *inode) 
		return;



	pr_err("List of directory entries:\n");

	ubifs_assert(!mutex_is_locked(&c->tnc_mutex));

	ubifs_assert(c, !mutex_is_locked(&c->tnc_mutex));



	lowest_dent_key(c, &key, inode->i_ino);

	while (1) {
@@ -931,7 +931,7 @@ void ubifs_dump_tnc(struct ubifs_info *c) 


	pr_err("\n");

	pr_err("(pid %d) start dumping TNC tree\n", current->pid);

	znode = ubifs_tnc_levelorder_next(c->zroot.znode, NULL);

	znode = ubifs_tnc_levelorder_next(c, c->zroot.znode, NULL);

	level = znode->level;

	pr_err("== Level %d ==\n", level);

	while (znode) {
@@ -940,7 +940,7 @@ void ubifs_dump_tnc(struct ubifs_info *c) 
			pr_err("== Level %d ==\n", level);

		}

		ubifs_dump_znode(c, znode);

		znode = ubifs_tnc_levelorder_next(c->zroot.znode, znode);

		znode = ubifs_tnc_levelorder_next(c, c->zroot.znode, znode);

	}

	pr_err("(pid %d) finish dumping TNC tree\n", current->pid);

}
@@ -1183,7 +1183,7 @@ static int dbg_check_key_order(struct ubifs_info *c, struct ubifs_zbranch *zbr1, 
	union ubifs_key key;

	char key_buf[DBG_KEY_BUF_LEN];



	ubifs_assert(!keys_cmp(c, &zbr1->key, &zbr2->key));

	ubifs_assert(c, !keys_cmp(c, &zbr1->key, &zbr2->key));

	dent1 = kmalloc(UBIFS_MAX_DENT_NODE_SZ, GFP_NOFS);

	if (!dent1)

		return -ENOMEM;
@@ -1479,7 +1479,7 @@ int dbg_check_tnc(struct ubifs_info *c, int extra) 
	if (!dbg_is_chk_index(c))

		return 0;



	ubifs_assert(mutex_is_locked(&c->tnc_mutex));

	ubifs_assert(c, mutex_is_locked(&c->tnc_mutex));

	if (!c->zroot.znode)

		return 0;
@@ -1505,7 +1505,7 @@ int dbg_check_tnc(struct ubifs_info *c, int extra) 
		}



		prev = znode;

		znode = ubifs_tnc_postorder_next(znode);

		znode = ubifs_tnc_postorder_next(c, znode);

		if (!znode)

			break;
@@ -2036,7 +2036,7 @@ static int check_leaf(struct ubifs_info *c, struct ubifs_zbranch *zbr, 
		long long blk_offs;

		struct ubifs_data_node *dn = node;



		ubifs_assert(zbr->len >= UBIFS_DATA_NODE_SZ);

		ubifs_assert(c, zbr->len >= UBIFS_DATA_NODE_SZ);



		/*

		 * Search the inode node this data node belongs to and insert
@@ -2066,7 +2066,7 @@ static int check_leaf(struct ubifs_info *c, struct ubifs_zbranch *zbr, 
		struct ubifs_dent_node *dent = node;

		struct fsck_inode *fscki1;



		ubifs_assert(zbr->len >= UBIFS_DENT_NODE_SZ);

		ubifs_assert(c, zbr->len >= UBIFS_DENT_NODE_SZ);



		err = ubifs_validate_entry(c, dent);

		if (err)
@@ -2461,7 +2461,7 @@ static int power_cut_emulated(struct ubifs_info *c, int lnum, int write) 
{

	struct ubifs_debug_info *d = c->dbg;



	ubifs_assert(dbg_is_tst_rcvry(c));

	ubifs_assert(c, dbg_is_tst_rcvry(c));



	if (!d->pc_cnt) {

		/* First call - decide delay to the power cut */

fs/ubifs/debug.h

+2 −2
Original line number Diff line number Diff line
@@ -148,7 +148,7 @@ struct ubifs_global_debug_info { 
	unsigned int tst_rcvry:1;

};



#define ubifs_assert(expr) do {                                                \

#define ubifs_assert(c, expr) do {                                             \

	if (unlikely(!(expr))) {                                               \

		pr_crit("UBIFS assert failed in %s at %u (pid %d)\n",          \

		       __func__, __LINE__, current->pid);                      \
@@ -160,7 +160,7 @@ struct ubifs_global_debug_info { 
	if (unlikely(down_write_trylock(&(c)->commit_sem))) {                  \

		up_write(&(c)->commit_sem);                                    \

		pr_crit("commit lock is not locked!\n");                       \

		ubifs_assert(0);                                               \

		ubifs_assert(c, 0);                                            \

	}                                                                      \

} while (0)