Merge "Merge branch 'ubifs_from_4.2.0-rc5' into 'msm-3.18'" (5b9a0014) · Commits · e / devices / android_kernel_xiaomi_markw

fs/ubifs/budget.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -509,7 +509,7 @@ again:
		c->bi.nospace_rp = 1;
		smp_wmb();
		} else
		ubifs_err("cannot budget space, error %d", err);
		ubifs_err(c, "cannot budget space, error %d", err);
		return err;
		}

fs/ubifs/commit.c

+6 −6

Original line number	Diff line number	Diff line
		@@ -225,7 +225,7 @@ out_cancel:
		out_up:
		up_write(&c->commit_sem);
		out:
		ubifs_err("commit failed, error %d", err);
		ubifs_err(c, "commit failed, error %d", err);
		spin_lock(&c->cs_lock);
		c->cmt_state = COMMIT_BROKEN;
		wake_up(&c->cmt_wq);
		@@ -289,7 +289,7 @@ int ubifs_bg_thread(void *info)
		int err;
		struct ubifs_info *c = info;

		ubifs_msg("background thread \"%s\" started, PID %d",
		ubifs_msg(c, "background thread \"%s\" started, PID %d",
		c->bgt_name, current->pid);
		set_freezable();

		@@ -324,7 +324,7 @@ int ubifs_bg_thread(void *info)
		cond_resched();
		}

		ubifs_msg("background thread \"%s\" stops", c->bgt_name);
		ubifs_msg(c, "background thread \"%s\" stops", c->bgt_name);
		return 0;
		}

		@@ -712,13 +712,13 @@ out:
		return 0;

		out_dump:
		ubifs_err("dumping index node (iip=%d)", i->iip);
		ubifs_err(c, "dumping index node (iip=%d)", i->iip);
		ubifs_dump_node(c, idx);
		list_del(&i->list);
		kfree(i);
		if (!list_empty(&list)) {
		i = list_entry(list.prev, struct idx_node, list);
		ubifs_err("dumping parent index node");
		ubifs_err(c, "dumping parent index node");
		ubifs_dump_node(c, &i->idx);
		}
		out_free:
		@@ -727,7 +727,7 @@ out_free:
		list_del(&i->list);
		kfree(i);
		}
		ubifs_err("failed, error %d", err);
		ubifs_err(c, "failed, error %d", err);
		if (err > 0)
		err = -EINVAL;
		return err;

fs/ubifs/compress.c

+11 −11

Original line number	Diff line number	Diff line
		@@ -92,8 +92,8 @@ struct ubifs_compressor *ubifs_compressors[UBIFS_COMPR_TYPES_CNT];
		* Note, if the input buffer was not compressed, it is copied to the output
		* buffer and %UBIFS_COMPR_NONE is returned in @compr_type.
		*/
		void ubifs_compress(const void in_buf, int in_len, void out_buf, int *out_len,
		int *compr_type)
		void ubifs_compress(const struct ubifs_info c, const void in_buf,
		int in_len, void out_buf, int out_len, int *compr_type)
		{
		int err;
		struct ubifs_compressor compr = ubifs_compressors[compr_type];
		@@ -112,7 +112,7 @@ void ubifs_compress(const void in_buf, int in_len, void out_buf, int *out_len,
		if (compr->comp_mutex)
		mutex_unlock(compr->comp_mutex);
		if (unlikely(err)) {
		ubifs_warn("cannot compress %d bytes, compressor %s, error %d, leave data uncompressed",
		ubifs_warn(c, "cannot compress %d bytes, compressor %s, error %d, leave data uncompressed",
		in_len, compr->name, err);
		goto no_compr;
		}
		@@ -144,21 +144,21 @@ no_compr:
		* The length of the uncompressed data is returned in @out_len. This functions
		* returns %0 on success or a negative error code on failure.
		*/
		int ubifs_decompress(const void in_buf, int in_len, void out_buf,
		int *out_len, int compr_type)
		int ubifs_decompress(const struct ubifs_info c, const void in_buf,
		int in_len, void out_buf, int out_len, int compr_type)
		{
		int err;
		struct ubifs_compressor *compr;

		if (unlikely(compr_type < 0 \|\| compr_type >= UBIFS_COMPR_TYPES_CNT)) {
		ubifs_err("invalid compression type %d", compr_type);
		ubifs_err(c, "invalid compression type %d", compr_type);
		return -EINVAL;
		}

		compr = ubifs_compressors[compr_type];

		if (unlikely(!compr->capi_name)) {
		ubifs_err("%s compression is not compiled in", compr->name);
		ubifs_err(c, "%s compression is not compiled in", compr->name);
		return -EINVAL;
		}

		@@ -175,7 +175,7 @@ int ubifs_decompress(const void in_buf, int in_len, void out_buf,
		if (compr->decomp_mutex)
		mutex_unlock(compr->decomp_mutex);
		if (err)
		ubifs_err("cannot decompress %d bytes, compressor %s, error %d",
		ubifs_err(c, "cannot decompress %d bytes, compressor %s, error %d",
		in_len, compr->name, err);

		return err;
		@@ -193,8 +193,8 @@ static int __init compr_init(struct ubifs_compressor *compr)
		if (compr->capi_name) {
		compr->cc = crypto_alloc_comp(compr->capi_name, 0, 0);
		if (IS_ERR(compr->cc)) {
		ubifs_err("cannot initialize compressor %s, error %ld",
		compr->name, PTR_ERR(compr->cc));
		pr_err("UBIFS error (pid %d): cannot initialize compressor %s, error %ld",
		current->pid, compr->name, PTR_ERR(compr->cc));
		return PTR_ERR(compr->cc);
		}
		}

fs/ubifs/debug.c

+97 −93

Original line number	Diff line number	Diff line
		@@ -746,7 +746,7 @@ void ubifs_dump_lprops(struct ubifs_info *c)
		for (lnum = c->main_first; lnum < c->leb_cnt; lnum++) {
		err = ubifs_read_one_lp(c, lnum, &lp);
		if (err) {
		ubifs_err("cannot read lprops for LEB %d", lnum);
		ubifs_err(c, "cannot read lprops for LEB %d", lnum);
		continue;
		}

		@@ -819,13 +819,13 @@ void ubifs_dump_leb(const struct ubifs_info *c, int lnum)

		buf = __vmalloc(c->leb_size, GFP_NOFS, PAGE_KERNEL);
		if (!buf) {
		ubifs_err("cannot allocate memory for dumping LEB %d", lnum);
		ubifs_err(c, "cannot allocate memory for dumping LEB %d", lnum);
		return;
		}

		sleb = ubifs_scan(c, lnum, 0, buf, 0);
		if (IS_ERR(sleb)) {
		ubifs_err("scan error %d", (int)PTR_ERR(sleb));
		ubifs_err(c, "scan error %d", (int)PTR_ERR(sleb));
		goto out;
		}

		@@ -1032,7 +1032,7 @@ int dbg_check_space_info(struct ubifs_info *c)
		spin_unlock(&c->space_lock);

		if (free != d->saved_free) {
		ubifs_err("free space changed from %lld to %lld",
		ubifs_err(c, "free space changed from %lld to %lld",
		d->saved_free, free);
		goto out;
		}
		@@ -1040,15 +1040,15 @@ int dbg_check_space_info(struct ubifs_info *c)
		return 0;

		out:
		ubifs_msg("saved lprops statistics dump");
		ubifs_msg(c, "saved lprops statistics dump");
		ubifs_dump_lstats(&d->saved_lst);
		ubifs_msg("saved budgeting info dump");
		ubifs_msg(c, "saved budgeting info dump");
		ubifs_dump_budg(c, &d->saved_bi);
		ubifs_msg("saved idx_gc_cnt %d", d->saved_idx_gc_cnt);
		ubifs_msg("current lprops statistics dump");
		ubifs_msg(c, "saved idx_gc_cnt %d", d->saved_idx_gc_cnt);
		ubifs_msg(c, "current lprops statistics dump");
		ubifs_get_lp_stats(c, &lst);
		ubifs_dump_lstats(&lst);
		ubifs_msg("current budgeting info dump");
		ubifs_msg(c, "current budgeting info dump");
		ubifs_dump_budg(c, &c->bi);
		dump_stack();
		return -EINVAL;
		@@ -1077,9 +1077,9 @@ int dbg_check_synced_i_size(const struct ubifs_info c, struct inode inode)
		mutex_lock(&ui->ui_mutex);
		spin_lock(&ui->ui_lock);
		if (ui->ui_size != ui->synced_i_size && !ui->dirty) {
		ubifs_err("ui_size is %lld, synced_i_size is %lld, but inode is clean",
		ubifs_err(c, "ui_size is %lld, synced_i_size is %lld, but inode is clean",
		ui->ui_size, ui->synced_i_size);
		ubifs_err("i_ino %lu, i_mode %#x, i_size %lld", inode->i_ino,
		ubifs_err(c, "i_ino %lu, i_mode %#x, i_size %lld", inode->i_ino,
		inode->i_mode, i_size_read(inode));
		dump_stack();
		err = -EINVAL;
		@@ -1140,7 +1140,7 @@ int dbg_check_dir(struct ubifs_info c, const struct inode dir)
		kfree(pdent);

		if (i_size_read(dir) != size) {
		ubifs_err("directory inode %lu has size %llu, but calculated size is %llu",
		ubifs_err(c, "directory inode %lu has size %llu, but calculated size is %llu",
		dir->i_ino, (unsigned long long)i_size_read(dir),
		(unsigned long long)size);
		ubifs_dump_inode(c, dir);
		@@ -1148,7 +1148,7 @@ int dbg_check_dir(struct ubifs_info c, const struct inode dir)
		return -EINVAL;
		}
		if (dir->i_nlink != nlink) {
		ubifs_err("directory inode %lu has nlink %u, but calculated nlink is %u",
		ubifs_err(c, "directory inode %lu has nlink %u, but calculated nlink is %u",
		dir->i_ino, dir->i_nlink, nlink);
		ubifs_dump_inode(c, dir);
		dump_stack();
		@@ -1207,10 +1207,10 @@ static int dbg_check_key_order(struct ubifs_info c, struct ubifs_zbranch zbr1,
		err = 1;
		key_read(c, &dent1->key, &key);
		if (keys_cmp(c, &zbr1->key, &key)) {
		ubifs_err("1st entry at %d:%d has key %s", zbr1->lnum,
		ubifs_err(c, "1st entry at %d:%d has key %s", zbr1->lnum,
		zbr1->offs, dbg_snprintf_key(c, &key, key_buf,
		DBG_KEY_BUF_LEN));
		ubifs_err("but it should have key %s according to tnc",
		ubifs_err(c, "but it should have key %s according to tnc",
		dbg_snprintf_key(c, &zbr1->key, key_buf,
		DBG_KEY_BUF_LEN));
		ubifs_dump_node(c, dent1);
		@@ -1219,10 +1219,10 @@ static int dbg_check_key_order(struct ubifs_info c, struct ubifs_zbranch zbr1,

		key_read(c, &dent2->key, &key);
		if (keys_cmp(c, &zbr2->key, &key)) {
		ubifs_err("2nd entry at %d:%d has key %s", zbr1->lnum,
		ubifs_err(c, "2nd entry at %d:%d has key %s", zbr1->lnum,
		zbr1->offs, dbg_snprintf_key(c, &key, key_buf,
		DBG_KEY_BUF_LEN));
		ubifs_err("but it should have key %s according to tnc",
		ubifs_err(c, "but it should have key %s according to tnc",
		dbg_snprintf_key(c, &zbr2->key, key_buf,
		DBG_KEY_BUF_LEN));
		ubifs_dump_node(c, dent2);
		@@ -1238,14 +1238,14 @@ static int dbg_check_key_order(struct ubifs_info c, struct ubifs_zbranch zbr1,
		goto out_free;
		}
		if (cmp == 0 && nlen1 == nlen2)
		ubifs_err("2 xent/dent nodes with the same name");
		ubifs_err(c, "2 xent/dent nodes with the same name");
		else
		ubifs_err("bad order of colliding key %s",
		ubifs_err(c, "bad order of colliding key %s",
		dbg_snprintf_key(c, &key, key_buf, DBG_KEY_BUF_LEN));

		ubifs_msg("first node at %d:%d\n", zbr1->lnum, zbr1->offs);
		ubifs_msg(c, "first node at %d:%d\n", zbr1->lnum, zbr1->offs);
		ubifs_dump_node(c, dent1);
		ubifs_msg("second node at %d:%d\n", zbr2->lnum, zbr2->offs);
		ubifs_msg(c, "second node at %d:%d\n", zbr2->lnum, zbr2->offs);
		ubifs_dump_node(c, dent2);

		out_free:
		@@ -1447,11 +1447,11 @@ static int dbg_check_znode(struct ubifs_info c, struct ubifs_zbranch zbr)
		return 0;

		out:
		ubifs_err("failed, error %d", err);
		ubifs_msg("dump of the znode");
		ubifs_err(c, "failed, error %d", err);
		ubifs_msg(c, "dump of the znode");
		ubifs_dump_znode(c, znode);
		if (zp) {
		ubifs_msg("dump of the parent znode");
		ubifs_msg(c, "dump of the parent znode");
		ubifs_dump_znode(c, zp);
		}
		dump_stack();
		@@ -1518,9 +1518,9 @@ int dbg_check_tnc(struct ubifs_info *c, int extra)
		if (err < 0)
		return err;
		if (err) {
		ubifs_msg("first znode");
		ubifs_msg(c, "first znode");
		ubifs_dump_znode(c, prev);
		ubifs_msg("second znode");
		ubifs_msg(c, "second znode");
		ubifs_dump_znode(c, znode);
		return -EINVAL;
		}
		@@ -1529,13 +1529,13 @@ int dbg_check_tnc(struct ubifs_info *c, int extra)

		if (extra) {
		if (clean_cnt != atomic_long_read(&c->clean_zn_cnt)) {
		ubifs_err("incorrect clean_zn_cnt %ld, calculated %ld",
		ubifs_err(c, "incorrect clean_zn_cnt %ld, calculated %ld",
		atomic_long_read(&c->clean_zn_cnt),
		clean_cnt);
		return -EINVAL;
		}
		if (dirty_cnt != atomic_long_read(&c->dirty_zn_cnt)) {
		ubifs_err("incorrect dirty_zn_cnt %ld, calculated %ld",
		ubifs_err(c, "incorrect dirty_zn_cnt %ld, calculated %ld",
		atomic_long_read(&c->dirty_zn_cnt),
		dirty_cnt);
		return -EINVAL;
		@@ -1608,7 +1608,7 @@ int dbg_walk_index(struct ubifs_info *c, dbg_leaf_callback leaf_cb,
		if (znode_cb) {
		err = znode_cb(c, znode, priv);
		if (err) {
		ubifs_err("znode checking function returned error %d",
		ubifs_err(c, "znode checking function returned error %d",
		err);
		ubifs_dump_znode(c, znode);
		goto out_dump;
		@@ -1619,7 +1619,7 @@ int dbg_walk_index(struct ubifs_info *c, dbg_leaf_callback leaf_cb,
		zbr = &znode->zbranch[idx];
		err = leaf_cb(c, zbr, priv);
		if (err) {
		ubifs_err("leaf checking function returned error %d, for leaf at LEB %d:%d",
		ubifs_err(c, "leaf checking function returned error %d, for leaf at LEB %d:%d",
		err, zbr->lnum, zbr->offs);
		goto out_dump;
		}
		@@ -1675,7 +1675,7 @@ out_dump:
		zbr = &znode->parent->zbranch[znode->iip];
		else
		zbr = &c->zroot;
		ubifs_msg("dump of znode at LEB %d:%d", zbr->lnum, zbr->offs);
		ubifs_msg(c, "dump of znode at LEB %d:%d", zbr->lnum, zbr->offs);
		ubifs_dump_znode(c, znode);
		out_unlock:
		mutex_unlock(&c->tnc_mutex);
		@@ -1722,12 +1722,12 @@ int dbg_check_idx_size(struct ubifs_info *c, long long idx_size)

		err = dbg_walk_index(c, NULL, add_size, &calc);
		if (err) {
		ubifs_err("error %d while walking the index", err);
		ubifs_err(c, "error %d while walking the index", err);
		return err;
		}

		if (calc != idx_size) {
		ubifs_err("index size check failed: calculated size is %lld, should be %lld",
		ubifs_err(c, "index size check failed: calculated size is %lld, should be %lld",
		calc, idx_size);
		dump_stack();
		return -EINVAL;
		@@ -1814,7 +1814,7 @@ static struct fsck_inode add_inode(struct ubifs_info c,
		}

		if (inum > c->highest_inum) {
		ubifs_err("too high inode number, max. is %lu",
		ubifs_err(c, "too high inode number, max. is %lu",
		(unsigned long)c->highest_inum);
		return ERR_PTR(-EINVAL);
		}
		@@ -1921,17 +1921,17 @@ static struct fsck_inode read_add_inode(struct ubifs_info c,
		ino_key_init(c, &key, inum);
		err = ubifs_lookup_level0(c, &key, &znode, &n);
		if (!err) {
		ubifs_err("inode %lu not found in index", (unsigned long)inum);
		ubifs_err(c, "inode %lu not found in index", (unsigned long)inum);
		return ERR_PTR(-ENOENT);
		} else if (err < 0) {
		ubifs_err("error %d while looking up inode %lu",
		ubifs_err(c, "error %d while looking up inode %lu",
		err, (unsigned long)inum);
		return ERR_PTR(err);
		}

		zbr = &znode->zbranch[n];
		if (zbr->len < UBIFS_INO_NODE_SZ) {
		ubifs_err("bad node %lu node length %d",
		ubifs_err(c, "bad node %lu node length %d",
		(unsigned long)inum, zbr->len);
		return ERR_PTR(-EINVAL);
		}
		@@ -1942,7 +1942,7 @@ static struct fsck_inode read_add_inode(struct ubifs_info c,

		err = ubifs_tnc_read_node(c, zbr, ino);
		if (err) {
		ubifs_err("cannot read inode node at LEB %d:%d, error %d",
		ubifs_err(c, "cannot read inode node at LEB %d:%d, error %d",
		zbr->lnum, zbr->offs, err);
		kfree(ino);
		return ERR_PTR(err);
		@@ -1951,7 +1951,7 @@ static struct fsck_inode read_add_inode(struct ubifs_info c,
		fscki = add_inode(c, fsckd, ino);
		kfree(ino);
		if (IS_ERR(fscki)) {
		ubifs_err("error %ld while adding inode %lu node",
		ubifs_err(c, "error %ld while adding inode %lu node",
		PTR_ERR(fscki), (unsigned long)inum);
		return fscki;
		}
		@@ -1985,7 +1985,7 @@ static int check_leaf(struct ubifs_info c, struct ubifs_zbranch zbr,
		struct fsck_inode *fscki;

		if (zbr->len < UBIFS_CH_SZ) {
		ubifs_err("bad leaf length %d (LEB %d:%d)",
		ubifs_err(c, "bad leaf length %d (LEB %d:%d)",
		zbr->len, zbr->lnum, zbr->offs);
		return -EINVAL;
		}
		@@ -1996,7 +1996,7 @@ static int check_leaf(struct ubifs_info c, struct ubifs_zbranch zbr,

		err = ubifs_tnc_read_node(c, zbr, node);
		if (err) {
		ubifs_err("cannot read leaf node at LEB %d:%d, error %d",
		ubifs_err(c, "cannot read leaf node at LEB %d:%d, error %d",
		zbr->lnum, zbr->offs, err);
		goto out_free;
		}
		@@ -2006,7 +2006,7 @@ static int check_leaf(struct ubifs_info c, struct ubifs_zbranch zbr,
		fscki = add_inode(c, priv, node);
		if (IS_ERR(fscki)) {
		err = PTR_ERR(fscki);
		ubifs_err("error %d while adding inode node", err);
		ubifs_err(c, "error %d while adding inode node", err);
		goto out_dump;
		}
		goto out;
		@@ -2014,7 +2014,7 @@ static int check_leaf(struct ubifs_info c, struct ubifs_zbranch zbr,

		if (type != UBIFS_DENT_KEY && type != UBIFS_XENT_KEY &&
		type != UBIFS_DATA_KEY) {
		ubifs_err("unexpected node type %d at LEB %d:%d",
		ubifs_err(c, "unexpected node type %d at LEB %d:%d",
		type, zbr->lnum, zbr->offs);
		err = -EINVAL;
		goto out_free;
		@@ -2022,7 +2022,7 @@ static int check_leaf(struct ubifs_info c, struct ubifs_zbranch zbr,

		ch = node;
		if (le64_to_cpu(ch->sqnum) > c->max_sqnum) {
		ubifs_err("too high sequence number, max. is %llu",
		ubifs_err(c, "too high sequence number, max. is %llu",
		c->max_sqnum);
		err = -EINVAL;
		goto out_dump;
		@@ -2032,6 +2032,8 @@ 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);

		/*
		* Search the inode node this data node belongs to and insert
		* it to the RB-tree of inodes.
		@@ -2040,7 +2042,7 @@ static int check_leaf(struct ubifs_info c, struct ubifs_zbranch zbr,
		fscki = read_add_inode(c, priv, inum);
		if (IS_ERR(fscki)) {
		err = PTR_ERR(fscki);
		ubifs_err("error %d while processing data node and trying to find inode node %lu",
		ubifs_err(c, "error %d while processing data node and trying to find inode node %lu",
		err, (unsigned long)inum);
		goto out_dump;
		}
		@@ -2050,7 +2052,7 @@ static int check_leaf(struct ubifs_info c, struct ubifs_zbranch zbr,
		blk_offs <<= UBIFS_BLOCK_SHIFT;
		blk_offs += le32_to_cpu(dn->size);
		if (blk_offs > fscki->size) {
		ubifs_err("data node at LEB %d:%d is not within inode size %lld",
		ubifs_err(c, "data node at LEB %d:%d is not within inode size %lld",
		zbr->lnum, zbr->offs, fscki->size);
		err = -EINVAL;
		goto out_dump;
		@@ -2060,6 +2062,8 @@ 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);

		err = ubifs_validate_entry(c, dent);
		if (err)
		goto out_dump;
		@@ -2072,7 +2076,7 @@ static int check_leaf(struct ubifs_info c, struct ubifs_zbranch zbr,
		fscki = read_add_inode(c, priv, inum);
		if (IS_ERR(fscki)) {
		err = PTR_ERR(fscki);
		ubifs_err("error %d while processing entry node and trying to find inode node %lu",
		ubifs_err(c, "error %d while processing entry node and trying to find inode node %lu",
		err, (unsigned long)inum);
		goto out_dump;
		}
		@@ -2084,7 +2088,7 @@ static int check_leaf(struct ubifs_info c, struct ubifs_zbranch zbr,
		fscki1 = read_add_inode(c, priv, inum);
		if (IS_ERR(fscki1)) {
		err = PTR_ERR(fscki1);
		ubifs_err("error %d while processing entry node and trying to find parent inode node %lu",
		ubifs_err(c, "error %d while processing entry node and trying to find parent inode node %lu",
		err, (unsigned long)inum);
		goto out_dump;
		}
		@@ -2107,7 +2111,7 @@ out:
		return 0;

		out_dump:
		ubifs_msg("dump of node at LEB %d:%d", zbr->lnum, zbr->offs);
		ubifs_msg(c, "dump of node at LEB %d:%d", zbr->lnum, zbr->offs);
		ubifs_dump_node(c, node);
		out_free:
		kfree(node);
		@@ -2158,52 +2162,52 @@ static int check_inodes(struct ubifs_info c, struct fsck_data fsckd)
		*/
		if (fscki->inum != UBIFS_ROOT_INO &&
		fscki->references != 1) {
		ubifs_err("directory inode %lu has %d direntries which refer it, but should be 1",
		ubifs_err(c, "directory inode %lu has %d direntries which refer it, but should be 1",
		(unsigned long)fscki->inum,
		fscki->references);
		goto out_dump;
		}
		if (fscki->inum == UBIFS_ROOT_INO &&
		fscki->references != 0) {
		ubifs_err("root inode %lu has non-zero (%d) direntries which refer it",
		ubifs_err(c, "root inode %lu has non-zero (%d) direntries which refer it",
		(unsigned long)fscki->inum,
		fscki->references);
		goto out_dump;
		}
		if (fscki->calc_sz != fscki->size) {
		ubifs_err("directory inode %lu size is %lld, but calculated size is %lld",
		ubifs_err(c, "directory inode %lu size is %lld, but calculated size is %lld",
		(unsigned long)fscki->inum,
		fscki->size, fscki->calc_sz);
		goto out_dump;
		}
		if (fscki->calc_cnt != fscki->nlink) {
		ubifs_err("directory inode %lu nlink is %d, but calculated nlink is %d",
		ubifs_err(c, "directory inode %lu nlink is %d, but calculated nlink is %d",
		(unsigned long)fscki->inum,
		fscki->nlink, fscki->calc_cnt);
		goto out_dump;
		}
		} else {
		if (fscki->references != fscki->nlink) {
		ubifs_err("inode %lu nlink is %d, but calculated nlink is %d",
		ubifs_err(c, "inode %lu nlink is %d, but calculated nlink is %d",
		(unsigned long)fscki->inum,
		fscki->nlink, fscki->references);
		goto out_dump;
		}
		}
		if (fscki->xattr_sz != fscki->calc_xsz) {
		ubifs_err("inode %lu has xattr size %u, but calculated size is %lld",
		ubifs_err(c, "inode %lu has xattr size %u, but calculated size is %lld",
		(unsigned long)fscki->inum, fscki->xattr_sz,
		fscki->calc_xsz);
		goto out_dump;
		}
		if (fscki->xattr_cnt != fscki->calc_xcnt) {
		ubifs_err("inode %lu has %u xattrs, but calculated count is %lld",
		ubifs_err(c, "inode %lu has %u xattrs, but calculated count is %lld",
		(unsigned long)fscki->inum,
		fscki->xattr_cnt, fscki->calc_xcnt);
		goto out_dump;
		}
		if (fscki->xattr_nms != fscki->calc_xnms) {
		ubifs_err("inode %lu has xattr names' size %u, but calculated names' size is %lld",
		ubifs_err(c, "inode %lu has xattr names' size %u, but calculated names' size is %lld",
		(unsigned long)fscki->inum, fscki->xattr_nms,
		fscki->calc_xnms);
		goto out_dump;
		@@ -2217,11 +2221,11 @@ out_dump:
		ino_key_init(c, &key, fscki->inum);
		err = ubifs_lookup_level0(c, &key, &znode, &n);
		if (!err) {
		ubifs_err("inode %lu not found in index",
		ubifs_err(c, "inode %lu not found in index",
		(unsigned long)fscki->inum);
		return -ENOENT;
		} else if (err < 0) {
		ubifs_err("error %d while looking up inode %lu",
		ubifs_err(c, "error %d while looking up inode %lu",
		err, (unsigned long)fscki->inum);
		return err;
		}
		@@ -2233,13 +2237,13 @@ out_dump:

		err = ubifs_tnc_read_node(c, zbr, ino);
		if (err) {
		ubifs_err("cannot read inode node at LEB %d:%d, error %d",
		ubifs_err(c, "cannot read inode node at LEB %d:%d, error %d",
		zbr->lnum, zbr->offs, err);
		kfree(ino);
		return err;
		}

		ubifs_msg("dump of the inode %lu sitting in LEB %d:%d",
		ubifs_msg(c, "dump of the inode %lu sitting in LEB %d:%d",
		(unsigned long)fscki->inum, zbr->lnum, zbr->offs);
		ubifs_dump_node(c, ino);
		kfree(ino);
		@@ -2280,7 +2284,7 @@ int dbg_check_filesystem(struct ubifs_info *c)
		return 0;

		out_free:
		ubifs_err("file-system check failed with error %d", err);
		ubifs_err(c, "file-system check failed with error %d", err);
		dump_stack();
		free_inodes(&fsckd);
		return err;
		@@ -2311,12 +2315,12 @@ int dbg_check_data_nodes_order(struct ubifs_info c, struct list_head head)
		sb = container_of(cur->next, struct ubifs_scan_node, list);

		if (sa->type != UBIFS_DATA_NODE) {
		ubifs_err("bad node type %d", sa->type);
		ubifs_err(c, "bad node type %d", sa->type);
		ubifs_dump_node(c, sa->node);
		return -EINVAL;
		}
		if (sb->type != UBIFS_DATA_NODE) {
		ubifs_err("bad node type %d", sb->type);
		ubifs_err(c, "bad node type %d", sb->type);
		ubifs_dump_node(c, sb->node);
		return -EINVAL;
		}
		@@ -2327,7 +2331,7 @@ int dbg_check_data_nodes_order(struct ubifs_info c, struct list_head head)
		if (inuma < inumb)
		continue;
		if (inuma > inumb) {
		ubifs_err("larger inum %lu goes before inum %lu",
		ubifs_err(c, "larger inum %lu goes before inum %lu",
		(unsigned long)inuma, (unsigned long)inumb);
		goto error_dump;
		}
		@@ -2336,11 +2340,11 @@ int dbg_check_data_nodes_order(struct ubifs_info c, struct list_head head)
		blkb = key_block(c, &sb->key);

		if (blka > blkb) {
		ubifs_err("larger block %u goes before %u", blka, blkb);
		ubifs_err(c, "larger block %u goes before %u", blka, blkb);
		goto error_dump;
		}
		if (blka == blkb) {
		ubifs_err("two data nodes for the same block");
		ubifs_err(c, "two data nodes for the same block");
		goto error_dump;
		}
		}
		@@ -2379,19 +2383,19 @@ int dbg_check_nondata_nodes_order(struct ubifs_info c, struct list_head head)

		if (sa->type != UBIFS_INO_NODE && sa->type != UBIFS_DENT_NODE &&
		sa->type != UBIFS_XENT_NODE) {
		ubifs_err("bad node type %d", sa->type);
		ubifs_err(c, "bad node type %d", sa->type);
		ubifs_dump_node(c, sa->node);
		return -EINVAL;
		}
		if (sa->type != UBIFS_INO_NODE && sa->type != UBIFS_DENT_NODE &&
		sa->type != UBIFS_XENT_NODE) {
		ubifs_err("bad node type %d", sb->type);
		ubifs_err(c, "bad node type %d", sb->type);
		ubifs_dump_node(c, sb->node);
		return -EINVAL;
		}

		if (sa->type != UBIFS_INO_NODE && sb->type == UBIFS_INO_NODE) {
		ubifs_err("non-inode node goes before inode node");
		ubifs_err(c, "non-inode node goes before inode node");
		goto error_dump;
		}

		@@ -2401,7 +2405,7 @@ int dbg_check_nondata_nodes_order(struct ubifs_info c, struct list_head head)
		if (sa->type == UBIFS_INO_NODE && sb->type == UBIFS_INO_NODE) {
		/* Inode nodes are sorted in descending size order */
		if (sa->len < sb->len) {
		ubifs_err("smaller inode node goes first");
		ubifs_err(c, "smaller inode node goes first");
		goto error_dump;
		}
		continue;
		@@ -2417,7 +2421,7 @@ int dbg_check_nondata_nodes_order(struct ubifs_info c, struct list_head head)
		if (inuma < inumb)
		continue;
		if (inuma > inumb) {
		ubifs_err("larger inum %lu goes before inum %lu",
		ubifs_err(c, "larger inum %lu goes before inum %lu",
		(unsigned long)inuma, (unsigned long)inumb);
		goto error_dump;
		}
		@@ -2426,7 +2430,7 @@ int dbg_check_nondata_nodes_order(struct ubifs_info c, struct list_head head)
		hashb = key_block(c, &sb->key);

		if (hasha > hashb) {
		ubifs_err("larger hash %u goes before %u",
		ubifs_err(c, "larger hash %u goes before %u",
		hasha, hashb);
		goto error_dump;
		}
		@@ -2435,9 +2439,9 @@ int dbg_check_nondata_nodes_order(struct ubifs_info c, struct list_head head)
		return 0;

		error_dump:
		ubifs_msg("dumping first node");
		ubifs_msg(c, "dumping first node");
		ubifs_dump_node(c, sa->node);
		ubifs_msg("dumping second node");
		ubifs_msg(c, "dumping second node");
		ubifs_dump_node(c, sb->node);
		return -EINVAL;
		return 0;
		@@ -2466,13 +2470,13 @@ static int power_cut_emulated(struct ubifs_info *c, int lnum, int write)
		delay = prandom_u32() % 60000;
		d->pc_timeout = jiffies;
		d->pc_timeout += msecs_to_jiffies(delay);
		ubifs_warn("failing after %lums", delay);
		ubifs_warn(c, "failing after %lums", delay);
		} else {
		d->pc_delay = 2;
		delay = prandom_u32() % 10000;
		/* Fail within 10000 operations */
		d->pc_cnt_max = delay;
		ubifs_warn("failing after %lu calls", delay);
		ubifs_warn(c, "failing after %lu calls", delay);
		}
		}

		@@ -2490,55 +2494,55 @@ static int power_cut_emulated(struct ubifs_info *c, int lnum, int write)
		return 0;
		if (chance(19, 20))
		return 0;
		ubifs_warn("failing in super block LEB %d", lnum);
		ubifs_warn(c, "failing in super block LEB %d", lnum);
		} else if (lnum == UBIFS_MST_LNUM \|\| lnum == UBIFS_MST_LNUM + 1) {
		if (chance(19, 20))
		return 0;
		ubifs_warn("failing in master LEB %d", lnum);
		ubifs_warn(c, "failing in master LEB %d", lnum);
		} else if (lnum >= UBIFS_LOG_LNUM && lnum <= c->log_last) {
		if (write && chance(99, 100))
		return 0;
		if (chance(399, 400))
		return 0;
		ubifs_warn("failing in log LEB %d", lnum);
		ubifs_warn(c, "failing in log LEB %d", lnum);
		} else if (lnum >= c->lpt_first && lnum <= c->lpt_last) {
		if (write && chance(7, 8))
		return 0;
		if (chance(19, 20))
		return 0;
		ubifs_warn("failing in LPT LEB %d", lnum);
		ubifs_warn(c, "failing in LPT LEB %d", lnum);
		} else if (lnum >= c->orph_first && lnum <= c->orph_last) {
		if (write && chance(1, 2))
		return 0;
		if (chance(9, 10))
		return 0;
		ubifs_warn("failing in orphan LEB %d", lnum);
		ubifs_warn(c, "failing in orphan LEB %d", lnum);
		} else if (lnum == c->ihead_lnum) {
		if (chance(99, 100))
		return 0;
		ubifs_warn("failing in index head LEB %d", lnum);
		ubifs_warn(c, "failing in index head LEB %d", lnum);
		} else if (c->jheads && lnum == c->jheads[GCHD].wbuf.lnum) {
		if (chance(9, 10))
		return 0;
		ubifs_warn("failing in GC head LEB %d", lnum);
		ubifs_warn(c, "failing in GC head LEB %d", lnum);
		} else if (write && !RB_EMPTY_ROOT(&c->buds) &&
		!ubifs_search_bud(c, lnum)) {
		if (chance(19, 20))
		return 0;
		ubifs_warn("failing in non-bud LEB %d", lnum);
		ubifs_warn(c, "failing in non-bud LEB %d", lnum);
		} else if (c->cmt_state == COMMIT_RUNNING_BACKGROUND \|\|
		c->cmt_state == COMMIT_RUNNING_REQUIRED) {
		if (chance(999, 1000))
		return 0;
		ubifs_warn("failing in bud LEB %d commit running", lnum);
		ubifs_warn(c, "failing in bud LEB %d commit running", lnum);
		} else {
		if (chance(9999, 10000))
		return 0;
		ubifs_warn("failing in bud LEB %d commit not running", lnum);
		ubifs_warn(c, "failing in bud LEB %d commit not running", lnum);
		}

		d->pc_happened = 1;
		ubifs_warn("========== Power cut emulated ==========");
		ubifs_warn(c, "========== Power cut emulated ==========");
		dump_stack();
		return 1;
		}
		@@ -2553,7 +2557,7 @@ static int corrupt_data(const struct ubifs_info c, const void buf,
		/* Corruption span max to end of write unit */
		to = min(len, ALIGN(from + 1, c->max_write_size));

		ubifs_warn("filled bytes %u-%u with %s", from, to - 1,
		ubifs_warn(c, "filled bytes %u-%u with %s", from, to - 1,
		ffs ? "0xFFs" : "random data");

		if (ffs)
		@@ -2575,7 +2579,7 @@ int dbg_leb_write(struct ubifs_info c, int lnum, const void buf,
		failing = power_cut_emulated(c, lnum, 1);
		if (failing) {
		len = corrupt_data(c, buf, len);
		ubifs_warn("actually write %d bytes to LEB %d:%d (the buffer was corrupted)",
		ubifs_warn(c, "actually write %d bytes to LEB %d:%d (the buffer was corrupted)",
		len, lnum, offs);
		}
		err = ubi_leb_write(c->ubi, lnum, buf, offs, len);
		@@ -2905,7 +2909,7 @@ out_remove:
		debugfs_remove_recursive(d->dfs_dir);
		out:
		err = dent ? PTR_ERR(dent) : -ENODEV;
		ubifs_err("cannot create \"%s\" debugfs file or directory, error %d\n",
		ubifs_err(c, "cannot create \"%s\" debugfs file or directory, error %d\n",
		fname, err);
		return err;
		}
		@@ -3059,8 +3063,8 @@ out_remove:
		debugfs_remove_recursive(dfs_rootdir);
		out:
		err = dent ? PTR_ERR(dent) : -ENODEV;
		ubifs_err("cannot create \"%s\" debugfs file or directory, error %d\n",
		fname, err);
		pr_err("UBIFS error (pid %d): cannot create \"%s\" debugfs file or directory, error %d\n",
		current->pid, fname, err);
		return err;
		}