Commit 515315a1 authored by Artem Bityutskiy's avatar Artem Bityutskiy
Browse files

UBIFS: fix key printing 



Before commit 56e46742 we have had locking
around all printing macros and we could use static buffers for creating
key strings and printing them. However, now we do not have that locking and
we cannot use static buffers. This commit removes the old DBGKEY() macros
and introduces few new helper macros for printing debugging messages plus
a key at the end. Thankfully, all the messages are already structures in
a way that the key is printed in the end.

Signed-off-by: default avatarArtem Bityutskiy <artem.bityutskiy@linux.intel.com>
parent beba0060

fs/ubifs/debug.c

+30 −30
Original line number Diff line number Diff line
@@ -38,9 +38,6 @@ 


DEFINE_SPINLOCK(dbg_lock);



static char dbg_key_buf0[128];

static char dbg_key_buf1[128];



static const char *get_key_fmt(int fmt)

{

	switch (fmt) {
@@ -103,8 +100,8 @@ static const char *get_dent_type(int type) 
	}

}



static void snprintf_key(const struct ubifs_info *c, const union ubifs_key *key,

			 char *buffer, int len)

const char *dbg_snprintf_key(const struct ubifs_info *c,

			     const union ubifs_key *key, char *buffer, int len)

{

	char *p = buffer;

	int type = key_type(c, key);
@@ -139,20 +136,7 @@ static void snprintf_key(const struct ubifs_info *c, const union ubifs_key *key, 
	} else

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

	ubifs_assert(len > 0);

}



const char *dbg_key_str0(const struct ubifs_info *c, const union ubifs_key *key)

{

	/* dbg_lock must be held */

	snprintf_key(c, key, dbg_key_buf0, sizeof(dbg_key_buf0) - 1);

	return dbg_key_buf0;

}



const char *dbg_key_str1(const struct ubifs_info *c, const union ubifs_key *key)

{

	/* dbg_lock must be held */

	snprintf_key(c, key, dbg_key_buf1, sizeof(dbg_key_buf1) - 1);

	return dbg_key_buf1;

	return p;

}



const char *dbg_ntype(int type)
@@ -321,6 +305,7 @@ void dbg_dump_node(const struct ubifs_info *c, const void *node) 
	int i, n;

	union ubifs_key key;

	const struct ubifs_ch *ch = node;

	char key_buf[DBG_KEY_BUF_LEN];



	if (dbg_is_tst_rcvry(c))

		return;
@@ -476,7 +461,8 @@ void dbg_dump_node(const struct ubifs_info *c, const void *node) 
		const struct ubifs_ino_node *ino = node;



		key_read(c, &ino->key, &key);

		printk(KERN_DEBUG "\tkey            %s\n", DBGKEY(&key));

		printk(KERN_DEBUG "\tkey            %s\n",

		       dbg_snprintf_key(c, &key, key_buf, DBG_KEY_BUF_LEN));

		printk(KERN_DEBUG "\tcreat_sqnum    %llu\n",

		       (unsigned long long)le64_to_cpu(ino->creat_sqnum));

		printk(KERN_DEBUG "\tsize           %llu\n",
@@ -519,7 +505,8 @@ void dbg_dump_node(const struct ubifs_info *c, const void *node) 
		int nlen = le16_to_cpu(dent->nlen);



		key_read(c, &dent->key, &key);

		printk(KERN_DEBUG "\tkey            %s\n", DBGKEY(&key));

		printk(KERN_DEBUG "\tkey            %s\n",

		       dbg_snprintf_key(c, &key, key_buf, DBG_KEY_BUF_LEN));

		printk(KERN_DEBUG "\tinum           %llu\n",

		       (unsigned long long)le64_to_cpu(dent->inum));

		printk(KERN_DEBUG "\ttype           %d\n", (int)dent->type);
@@ -543,7 +530,8 @@ void dbg_dump_node(const struct ubifs_info *c, const void *node) 
		int dlen = le32_to_cpu(ch->len) - UBIFS_DATA_NODE_SZ;



		key_read(c, &dn->key, &key);

		printk(KERN_DEBUG "\tkey            %s\n", DBGKEY(&key));

		printk(KERN_DEBUG "\tkey            %s\n",

		       dbg_snprintf_key(c, &key, key_buf, DBG_KEY_BUF_LEN));

		printk(KERN_DEBUG "\tsize           %u\n",

		       le32_to_cpu(dn->size));

		printk(KERN_DEBUG "\tcompr_typ      %d\n",
@@ -584,7 +572,9 @@ void dbg_dump_node(const struct ubifs_info *c, const void *node) 
			key_read(c, &br->key, &key);

			printk(KERN_DEBUG "\t%d: LEB %d:%d len %d key %s\n",

			       i, le32_to_cpu(br->lnum), le32_to_cpu(br->offs),

			       le32_to_cpu(br->len), DBGKEY(&key));

			       le32_to_cpu(br->len),

			       dbg_snprintf_key(c, &key, key_buf,

						DBG_KEY_BUF_LEN));

		}

		break;

	}
@@ -936,6 +926,7 @@ void dbg_dump_znode(const struct ubifs_info *c, 
{

	int n;

	const struct ubifs_zbranch *zbr;

	char key_buf[DBG_KEY_BUF_LEN];



	spin_lock(&dbg_lock);

	if (znode->parent)
@@ -960,12 +951,16 @@ void dbg_dump_znode(const struct ubifs_info *c, 
			printk(KERN_DEBUG "\t%d: znode %p LEB %d:%d len %d key "

					  "%s\n", n, zbr->znode, zbr->lnum,

					  zbr->offs, zbr->len,

					  DBGKEY(&zbr->key));

					  dbg_snprintf_key(c, &zbr->key,

							   key_buf,

							   DBG_KEY_BUF_LEN));

		else

			printk(KERN_DEBUG "\t%d: LNC %p LEB %d:%d len %d key "

					  "%s\n", n, zbr->znode, zbr->lnum,

					  zbr->offs, zbr->len,

					  DBGKEY(&zbr->key));

					  dbg_snprintf_key(c, &zbr->key,

							   key_buf,

							   DBG_KEY_BUF_LEN));

	}

	spin_unlock(&dbg_lock);

}
@@ -1262,6 +1257,7 @@ static int dbg_check_key_order(struct ubifs_info *c, struct ubifs_zbranch *zbr1, 
	int err, nlen1, nlen2, cmp;

	struct ubifs_dent_node *dent1, *dent2;

	union ubifs_key key;

	char key_buf[DBG_KEY_BUF_LEN];



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

	dent1 = kmalloc(UBIFS_MAX_DENT_NODE_SZ, GFP_NOFS);
@@ -1292,9 +1288,11 @@ static int dbg_check_key_order(struct ubifs_info *c, struct ubifs_zbranch *zbr1, 
	key_read(c, &dent1->key, &key);

	if (keys_cmp(c, &zbr1->key, &key)) {

		dbg_err("1st entry at %d:%d has key %s", zbr1->lnum,

			zbr1->offs, DBGKEY(&key));

			zbr1->offs, dbg_snprintf_key(c, &key, key_buf,

						     DBG_KEY_BUF_LEN));

		dbg_err("but it should have key %s according to tnc",

			DBGKEY(&zbr1->key));

			dbg_snprintf_key(c, &zbr1->key, key_buf,

					 DBG_KEY_BUF_LEN));

		dbg_dump_node(c, dent1);

		goto out_free;

	}
@@ -1302,9 +1300,11 @@ 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)) {

		dbg_err("2nd entry at %d:%d has key %s", zbr1->lnum,

			zbr1->offs, DBGKEY(&key));

			zbr1->offs, dbg_snprintf_key(c, &key, key_buf,

						     DBG_KEY_BUF_LEN));

		dbg_err("but it should have key %s according to tnc",

			DBGKEY(&zbr2->key));

			dbg_snprintf_key(c, &zbr2->key, key_buf,

					 DBG_KEY_BUF_LEN));

		dbg_dump_node(c, dent2);

		goto out_free;

	}
@@ -1321,7 +1321,7 @@ static int dbg_check_key_order(struct ubifs_info *c, struct ubifs_zbranch *zbr1, 
		dbg_err("2 xent/dent nodes with the same name");

	else

		dbg_err("bad order of colliding key %s",

			DBGKEY(&key));

			dbg_snprintf_key(c, &key, key_buf, DBG_KEY_BUF_LEN));



	ubifs_msg("first node at %d:%d\n", zbr1->lnum, zbr1->offs);

	dbg_dump_node(c, dent1);

fs/ubifs/debug.h

+22 −17
Original line number Diff line number Diff line
@@ -169,24 +169,16 @@ struct ubifs_global_debug_info { 
	spin_unlock(&dbg_lock);                                                \

} while (0)



const char *dbg_key_str0(const struct ubifs_info *c,

			 const union ubifs_key *key);

const char *dbg_key_str1(const struct ubifs_info *c,

			 const union ubifs_key *key);



/*

 * TODO: these macros are now broken because there is no locking around them

 * and we use a global buffer for the key string. This means that in case of

 * concurrent execution we will end up with incorrect and messy key strings.

 */

#define DBGKEY(key) dbg_key_str0(c, (key))

#define DBGKEY1(key) dbg_key_str1(c, (key))



extern spinlock_t dbg_lock;



#define ubifs_dbg_msg(type, fmt, ...) \

	pr_debug("UBIFS DBG " type ": " fmt "\n", ##__VA_ARGS__)



#define DBG_KEY_BUF_LEN 32

#define ubifs_dbg_msg_key(type, key, fmt, ...) do {                            \

	char __tmp_key_buf[DBG_KEY_BUF_LEN];                                   \

	pr_debug("UBIFS DBG " type ": " fmt "%s\n", ##__VA_ARGS__,             \

		 dbg_snprintf_key(c, key, __tmp_key_buf, DBG_KEY_BUF_LEN));    \

} while (0)



/* Just a debugging messages not related to any specific UBIFS subsystem */

#define dbg_msg(fmt, ...)                                                      \

	printk(KERN_DEBUG "UBIFS DBG (pid %d): %s: " fmt "\n", current->pid,   \
@@ -196,14 +188,20 @@ extern spinlock_t dbg_lock; 
#define dbg_gen(fmt, ...)   ubifs_dbg_msg("gen", fmt, ##__VA_ARGS__)

/* Additional journal messages */

#define dbg_jnl(fmt, ...)   ubifs_dbg_msg("jnl", fmt, ##__VA_ARGS__)

#define dbg_jnlk(key, fmt, ...) \

	ubifs_dbg_msg_key("jnl", key, fmt, ##__VA_ARGS__)

/* Additional TNC messages */

#define dbg_tnc(fmt, ...)   ubifs_dbg_msg("tnc", fmt, ##__VA_ARGS__)

#define dbg_tnck(key, fmt, ...) \

	ubifs_dbg_msg_key("tnc", key, fmt, ##__VA_ARGS__)

/* Additional lprops messages */

#define dbg_lp(fmt, ...)    ubifs_dbg_msg("lp", fmt, ##__VA_ARGS__)

/* Additional LEB find messages */

#define dbg_find(fmt, ...)  ubifs_dbg_msg("find", fmt, ##__VA_ARGS__)

/* Additional mount messages */

#define dbg_mnt(fmt, ...)   ubifs_dbg_msg("mnt", fmt, ##__VA_ARGS__)

#define dbg_mntk(key, fmt, ...) \

	ubifs_dbg_msg_key("mnt", key, fmt, ##__VA_ARGS__)

/* Additional I/O messages */

#define dbg_io(fmt, ...)    ubifs_dbg_msg("io", fmt, ##__VA_ARGS__)

/* Additional commit messages */
@@ -219,6 +217,7 @@ extern spinlock_t dbg_lock; 
/* Additional recovery messages */

#define dbg_rcvry(fmt, ...) ubifs_dbg_msg("rcvry", fmt, ##__VA_ARGS__)



extern spinlock_t dbg_lock;

extern struct ubifs_global_debug_info ubifs_dbg;



static inline int dbg_is_chk_gen(const struct ubifs_info *c)
@@ -259,6 +258,8 @@ const char *dbg_cstate(int cmt_state); 
const char *dbg_jhead(int jhead);

const char *dbg_get_key_dump(const struct ubifs_info *c,

			     const union ubifs_key *key);

const char *dbg_snprintf_key(const struct ubifs_info *c,

			     const union ubifs_key *key, char *buffer, int len);

void dbg_dump_inode(struct ubifs_info *c, const struct inode *inode);

void dbg_dump_node(const struct ubifs_info *c, const void *node);

void dbg_dump_lpt_node(const struct ubifs_info *c, void *node, int lnum,
@@ -369,6 +370,10 @@ static inline const char *dbg_jhead(int jhead) { return ""; } 
static inline const char *

dbg_get_key_dump(const struct ubifs_info *c,

		 const union ubifs_key *key)                      { return ""; }

static inline const char *

dbg_snprintf_key(const struct ubifs_info *c,

		 const union ubifs_key *key, char *buffer,

		 int len)                                         { return ""; }

static inline void dbg_dump_inode(struct ubifs_info *c,

				  const struct inode *inode)      { return; }

static inline void dbg_dump_node(const struct ubifs_info *c,

fs/ubifs/journal.c

+3 −4
Original line number Diff line number Diff line
@@ -697,9 +697,8 @@ int ubifs_jnl_write_data(struct ubifs_info *c, const struct inode *inode, 
	int dlen = COMPRESSED_DATA_NODE_BUF_SZ, allocated = 1;

	struct ubifs_inode *ui = ubifs_inode(inode);



	dbg_jnl("ino %lu, blk %u, len %d, key %s",

		(unsigned long)key_inum(c, key), key_block(c, key), len,

		DBGKEY(key));

	dbg_jnlk(key, "ino %lu, blk %u, len %d, key ",

		(unsigned long)key_inum(c, key), key_block(c, key), len);

	ubifs_assert(len <= UBIFS_BLOCK_SIZE);



	data = kmalloc(dlen, GFP_NOFS | __GFP_NOWARN);
@@ -1177,7 +1176,7 @@ int ubifs_jnl_truncate(struct ubifs_info *c, const struct inode *inode, 
		dn = (void *)trun + UBIFS_TRUN_NODE_SZ;

		blk = new_size >> UBIFS_BLOCK_SHIFT;

		data_key_init(c, &key, inum, blk);

		dbg_jnl("last block key %s", DBGKEY(&key));

		dbg_jnlk(&key, "last block key ");

		err = ubifs_tnc_lookup(c, &key, dn);

		if (err == -ENOENT)

			dlen = 0; /* Not found (so it is a hole) */

fs/ubifs/replay.c

+4 −4
Original line number Diff line number Diff line
@@ -221,8 +221,8 @@ static int apply_replay_entry(struct ubifs_info *c, struct replay_entry *r) 
{

	int err;



	dbg_mnt("LEB %d:%d len %d deletion %d sqnum %llu %s", r->lnum,

		r->offs, r->len, r->deletion, r->sqnum, DBGKEY(&r->key));

	dbg_mntk(&r->key, "LEB %d:%d len %d deletion %d sqnum %llu key ",

		 r->lnum, r->offs, r->len, r->deletion, r->sqnum);



	/* Set c->replay_sqnum to help deal with dangling branches. */

	c->replay_sqnum = r->sqnum;
@@ -361,7 +361,7 @@ static int insert_node(struct ubifs_info *c, int lnum, int offs, int len, 
{

	struct replay_entry *r;



	dbg_mnt("add LEB %d:%d, key %s", lnum, offs, DBGKEY(key));

	dbg_mntk(key, "add LEB %d:%d, key ", lnum, offs);



	if (key_inum(c, key) >= c->highest_inum)

		c->highest_inum = key_inum(c, key);
@@ -409,7 +409,7 @@ static int insert_dent(struct ubifs_info *c, int lnum, int offs, int len, 
	struct replay_entry *r;

	char *nbuf;



	dbg_mnt("add LEB %d:%d, key %s", lnum, offs, DBGKEY(key));

	dbg_mntk(key, "add LEB %d:%d, key ", lnum, offs);

	if (key_inum(c, key) >= c->highest_inum)

		c->highest_inum = key_inum(c, key);

fs/ubifs/tnc.c

+27 −28
Original line number Diff line number Diff line
@@ -506,7 +506,7 @@ static int fallible_read_node(struct ubifs_info *c, const union ubifs_key *key, 
{

	int ret;



	dbg_tnc("LEB %d:%d, key %s", zbr->lnum, zbr->offs, DBGKEY(key));

	dbg_tnck(key, "LEB %d:%d, key ", zbr->lnum, zbr->offs);



	ret = try_read_node(c, node, key_type(c, key), zbr->len, zbr->lnum,

			    zbr->offs);
@@ -520,8 +520,8 @@ static int fallible_read_node(struct ubifs_info *c, const union ubifs_key *key, 
			ret = 0;

	}

	if (ret == 0 && c->replaying)

		dbg_mnt("dangling branch LEB %d:%d len %d, key %s",

			zbr->lnum, zbr->offs, zbr->len, DBGKEY(key));

		dbg_mntk(key, "dangling branch LEB %d:%d len %d, key ",

			zbr->lnum, zbr->offs, zbr->len);

	return ret;

}
@@ -996,9 +996,9 @@ static int fallible_resolve_collision(struct ubifs_info *c, 
	if (adding || !o_znode)

		return 0;



	dbg_mnt("dangling match LEB %d:%d len %d %s",

	dbg_mntk(key, "dangling match LEB %d:%d len %d key ",

		o_znode->zbranch[o_n].lnum, o_znode->zbranch[o_n].offs,

		o_znode->zbranch[o_n].len, DBGKEY(key));

		o_znode->zbranch[o_n].len);

	*zn = o_znode;

	*n = o_n;

	return 1;
@@ -1180,7 +1180,7 @@ int ubifs_lookup_level0(struct ubifs_info *c, const union ubifs_key *key, 
	struct ubifs_znode *znode;

	unsigned long time = get_seconds();



	dbg_tnc("search key %s", DBGKEY(key));

	dbg_tnck(key, "search key ");

	ubifs_assert(key_type(c, key) < UBIFS_INVALID_KEY);



	znode = c->zroot.znode;
@@ -1316,7 +1316,7 @@ static int lookup_level0_dirty(struct ubifs_info *c, const union ubifs_key *key, 
	struct ubifs_znode *znode;

	unsigned long time = get_seconds();



	dbg_tnc("search and dirty key %s", DBGKEY(key));

	dbg_tnck(key, "search and dirty key ");



	znode = c->zroot.znode;

	if (unlikely(!znode)) {
@@ -1723,8 +1723,8 @@ static int validate_data_node(struct ubifs_info *c, void *buf, 
	if (!keys_eq(c, &zbr->key, &key1)) {

		ubifs_err("bad key in node at LEB %d:%d",

			  zbr->lnum, zbr->offs);

		dbg_tnc("looked for key %s found node's key %s",

			DBGKEY(&zbr->key), DBGKEY1(&key1));

		dbg_tnck(&zbr->key, "looked for key ");

		dbg_tnck(&key1, "found node's key ");

		goto out_err;

	}
@@ -1777,7 +1777,7 @@ int ubifs_tnc_bulk_read(struct ubifs_info *c, struct bu_info *bu) 
		ubifs_err("failed to read from LEB %d:%d, error %d",

			  lnum, offs, err);

		dbg_dump_stack();

		dbg_tnc("key %s", DBGKEY(&bu->key));

		dbg_tnck(&bu->key, "key ");

		return err;

	}
@@ -1812,7 +1812,7 @@ static int do_lookup_nm(struct ubifs_info *c, const union ubifs_key *key, 
	int found, n, err;

	struct ubifs_znode *znode;



	dbg_tnc("name '%.*s' key %s", nm->len, nm->name, DBGKEY(key));

	dbg_tnck(key, "name '%.*s' key ", nm->len, nm->name);

	mutex_lock(&c->tnc_mutex);

	found = ubifs_lookup_level0(c, key, &znode, &n);

	if (!found) {
@@ -1986,8 +1986,7 @@ again: 
	zp = znode->parent;

	if (znode->child_cnt < c->fanout) {

		ubifs_assert(n != c->fanout);

		dbg_tnc("inserted at %d level %d, key %s", n, znode->level,

			DBGKEY(key));

		dbg_tnck(key, "inserted at %d level %d, key ", n, znode->level);



		insert_zbranch(znode, zbr, n);
@@ -2002,7 +2001,7 @@ again: 
	 * Unfortunately, @znode does not have more empty slots and we have to

	 * split it.

	 */

	dbg_tnc("splitting level %d, key %s", znode->level, DBGKEY(key));

	dbg_tnck(key, "splitting level %d, key ", znode->level);



	if (znode->alt)

		/*
@@ -2096,7 +2095,7 @@ do_split: 
	}



	/* Insert new key and branch */

	dbg_tnc("inserting at %d level %d, key %s", n, zn->level, DBGKEY(key));

	dbg_tnck(key, "inserting at %d level %d, key ", n, zn->level);



	insert_zbranch(zi, zbr, n);
@@ -2172,7 +2171,7 @@ int ubifs_tnc_add(struct ubifs_info *c, const union ubifs_key *key, int lnum, 
	struct ubifs_znode *znode;



	mutex_lock(&c->tnc_mutex);

	dbg_tnc("%d:%d, len %d, key %s", lnum, offs, len, DBGKEY(key));

	dbg_tnck(key, "%d:%d, len %d, key ", lnum, offs, len);

	found = lookup_level0_dirty(c, key, &znode, &n);

	if (!found) {

		struct ubifs_zbranch zbr;
@@ -2221,8 +2220,8 @@ int ubifs_tnc_replace(struct ubifs_info *c, const union ubifs_key *key, 
	struct ubifs_znode *znode;



	mutex_lock(&c->tnc_mutex);

	dbg_tnc("old LEB %d:%d, new LEB %d:%d, len %d, key %s", old_lnum,

		old_offs, lnum, offs, len, DBGKEY(key));

	dbg_tnck(key, "old LEB %d:%d, new LEB %d:%d, len %d, key ", old_lnum,

		 old_offs, lnum, offs, len);

	found = lookup_level0_dirty(c, key, &znode, &n);

	if (found < 0) {

		err = found;
@@ -2304,8 +2303,8 @@ int ubifs_tnc_add_nm(struct ubifs_info *c, const union ubifs_key *key, 
	struct ubifs_znode *znode;



	mutex_lock(&c->tnc_mutex);

	dbg_tnc("LEB %d:%d, name '%.*s', key %s", lnum, offs, nm->len, nm->name,

		DBGKEY(key));

	dbg_tnck(key, "LEB %d:%d, name '%.*s', key ",

		 lnum, offs, nm->len, nm->name);

	found = lookup_level0_dirty(c, key, &znode, &n);

	if (found < 0) {

		err = found;
@@ -2398,7 +2397,7 @@ static int tnc_delete(struct ubifs_info *c, struct ubifs_znode *znode, int n) 
	/* Delete without merge for now */

	ubifs_assert(znode->level == 0);

	ubifs_assert(n >= 0 && n < c->fanout);

	dbg_tnc("deleting %s", DBGKEY(&znode->zbranch[n].key));

	dbg_tnck(&znode->zbranch[n].key, "deleting key ");



	zbr = &znode->zbranch[n];

	lnc_free(zbr);
@@ -2508,7 +2507,7 @@ int ubifs_tnc_remove(struct ubifs_info *c, const union ubifs_key *key) 
	struct ubifs_znode *znode;



	mutex_lock(&c->tnc_mutex);

	dbg_tnc("key %s", DBGKEY(key));

	dbg_tnck(key, "key ");

	found = lookup_level0_dirty(c, key, &znode, &n);

	if (found < 0) {

		err = found;
@@ -2539,7 +2538,7 @@ int ubifs_tnc_remove_nm(struct ubifs_info *c, const union ubifs_key *key, 
	struct ubifs_znode *znode;



	mutex_lock(&c->tnc_mutex);

	dbg_tnc("%.*s, key %s", nm->len, nm->name, DBGKEY(key));

	dbg_tnck(key, "%.*s, key ", nm->len, nm->name);

	err = lookup_level0_dirty(c, key, &znode, &n);

	if (err < 0)

		goto out_unlock;
@@ -2654,7 +2653,7 @@ int ubifs_tnc_remove_range(struct ubifs_info *c, union ubifs_key *from_key, 
				dbg_dump_znode(c, znode);

				goto out_unlock;

			}

			dbg_tnc("removing %s", DBGKEY(key));

			dbg_tnck(key, "removing key ");

		}

		if (k) {

			for (i = n + 1 + k; i < znode->child_cnt; i++)
@@ -2774,7 +2773,7 @@ struct ubifs_dent_node *ubifs_tnc_next_ent(struct ubifs_info *c, 
	struct ubifs_zbranch *zbr;

	union ubifs_key *dkey;



	dbg_tnc("%s %s", nm->name ? (char *)nm->name : "(lowest)", DBGKEY(key));

	dbg_tnck(key, "%s ", nm->name ? (char *)nm->name : "(lowest)");

	ubifs_assert(is_hash_key(c, key));



	mutex_lock(&c->tnc_mutex);
@@ -3333,9 +3332,9 @@ int dbg_check_inode_size(struct ubifs_info *c, const struct inode *inode, 


out_dump:

	block = key_block(c, key);

	ubifs_err("inode %lu has size %lld, but there are data at offset %lld "

		  "(data key %s)", (unsigned long)inode->i_ino, size,

		  ((loff_t)block) << UBIFS_BLOCK_SHIFT, DBGKEY(key));

	ubifs_err("inode %lu has size %lld, but there are data at offset %lld",

		  (unsigned long)inode->i_ino, size,

		  ((loff_t)block) << UBIFS_BLOCK_SHIFT);

	mutex_unlock(&c->tnc_mutex);

	dbg_dump_inode(c, inode);

	dbg_dump_stack();

CRA Git | Maintained and supported by SUSTech CRA and CCSE