Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 22276c81 authored by Nikhilesh Reddy's avatar Nikhilesh Reddy
Browse files

Merge branch 'ubifs_from_4.2.0-rc5' into 'msm-3.18' 



UBIFS over UBI is the default filesystem used in QCOM chipsets
that use NAND storage.

There were a few changes upstream to UBIFS that fixed some bugs
and added some more asserts. There were also changes to the
debug messages that would allow for much easier debug of filesystem
issues.

Backport and bring in all the changes to ensure stability and
better performance for the NAND based devices.

* The patches included are:

  ubifs: fix to check error code of register_shrinker
  UBIFS: fix output format of INUM_WATERMARK
  UBIFS: extend debug/message capabilities
  UBIFS: simplify returns
  UBIFS: Fix trivial typos in comments
  UBIFS: do not write master node if need recovery
  UBIFS: fix incorrect unlocking handling
  UBIFS: return -EINVAL if log head is empty
  UBIFS: add a couple of extra asserts
  UBIFS: add ubifs_err() to print error reason
  UBIFS: Add security.* XATTR support for the UBIFS
  UBIFS: Add xattr support for symlinks
  UBIFS: fix a couple bugs in UBIFS xattr length calculation
  UBIFS: fix budget leak in error path

Change-Id: I5e76bb39daa85b0d798b030b15d07069144ba82e
Signed-off-by: default avatarNikhilesh Reddy <reddyn@codeaurora.org>
parents 7af2265a f8f4c6a9

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;

}