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

Commit 94b1984a authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'linux-next' of git://git.infradead.org/ubifs-2.6 

* 'linux-next' of git://git.infradead.org/ubifs-2.6:
  UBIFS: fix key printing
  UBIFS: use snprintf instead of sprintf when printing keys
  UBIFS: fix debugging messages
  UBIFS: make debugging messages light again
  UBI: fix debugging messages
  UBI: make vid_hdr non-static
parents 1a52bb0b 515315a1

drivers/mtd/ubi/debug.h

+4 −1
Original line number Diff line number Diff line
@@ -43,7 +43,10 @@ 
	pr_debug("UBI DBG " type ": " fmt "\n", ##__VA_ARGS__)



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

#define dbg_msg(fmt, ...) ubi_dbg_msg("msg", fmt, ##__VA_ARGS__)

#define dbg_msg(fmt, ...)                                    \

	printk(KERN_DEBUG "UBI DBG (pid %d): %s: " fmt "\n", \

	       current->pid, __func__, ##__VA_ARGS__)



/* General debugging messages */

#define dbg_gen(fmt, ...) ubi_dbg_msg("gen", fmt, ##__VA_ARGS__)

/* Messages from the eraseblock association sub-system */

drivers/mtd/ubi/vtbl.c

+1 −1
Original line number Diff line number Diff line
@@ -306,7 +306,7 @@ static int create_vtbl(struct ubi_device *ubi, struct ubi_scan_info *si, 
		       int copy, void *vtbl)

{

	int err, tries = 0;

	static struct ubi_vid_hdr *vid_hdr;

	struct ubi_vid_hdr *vid_hdr;

	struct ubi_scan_leb *new_seb;



	ubi_msg("create volume table (copy #%d)", copy + 1);

fs/ubifs/debug.c

+46 −44
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 sprintf_key(const struct ubifs_info *c, const union ubifs_key *key,

			char *buffer)

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);
@@ -112,45 +109,34 @@ static void sprintf_key(const struct ubifs_info *c, const union ubifs_key *key, 
	if (c->key_fmt == UBIFS_SIMPLE_KEY_FMT) {

		switch (type) {

		case UBIFS_INO_KEY:

			sprintf(p, "(%lu, %s)", (unsigned long)key_inum(c, key),

			len -= snprintf(p, len, "(%lu, %s)",

					(unsigned long)key_inum(c, key),

					get_key_type(type));

			break;

		case UBIFS_DENT_KEY:

		case UBIFS_XENT_KEY:

			sprintf(p, "(%lu, %s, %#08x)",

			len -= snprintf(p, len, "(%lu, %s, %#08x)",

					(unsigned long)key_inum(c, key),

					get_key_type(type), key_hash(c, key));

			break;

		case UBIFS_DATA_KEY:

			sprintf(p, "(%lu, %s, %u)",

			len -= snprintf(p, len, "(%lu, %s, %u)",

					(unsigned long)key_inum(c, key),

					get_key_type(type), key_block(c, key));

			break;

		case UBIFS_TRUN_KEY:

			sprintf(p, "(%lu, %s)",

			len -= snprintf(p, len, "(%lu, %s)",

					(unsigned long)key_inum(c, key),

					get_key_type(type));

			break;

		default:

			sprintf(p, "(bad key type: %#08x, %#08x)",

			len -= snprintf(p, len, "(bad key type: %#08x, %#08x)",

					key->u32[0], key->u32[1]);

		}

	} else

		sprintf(p, "bad key format %d", c->key_fmt);

}



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

{

	/* dbg_lock must be held */

	sprintf_key(c, key, dbg_key_buf0);

	return dbg_key_buf0;

}



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

{

	/* dbg_lock must be held */

	sprintf_key(c, key, dbg_key_buf1);

	return dbg_key_buf1;

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

	ubifs_assert(len > 0);

	return p;

}



const char *dbg_ntype(int type)
@@ -319,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;
@@ -474,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",
@@ -517,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);
@@ -541,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",
@@ -582,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;

	}
@@ -934,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)
@@ -958,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);

}
@@ -1260,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);
@@ -1290,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;

	}
@@ -1300,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;

	}
@@ -1319,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

+25 −19
Original line number Diff line number Diff line
@@ -169,40 +169,39 @@ 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);



/*

 * DBGKEY macros require @dbg_lock to be held, which it is in the dbg message

 * macros.

 */

#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, ...) do {                        \

	spin_lock(&dbg_lock);                                     \

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

	spin_unlock(&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, ...)   ubifs_dbg_msg("msg", fmt, ##__VA_ARGS__)

#define dbg_msg(fmt, ...)                                                      \

	printk(KERN_DEBUG "UBIFS DBG (pid %d): %s: " fmt "\n", current->pid,   \

	       __func__, ##__VA_ARGS__)



/* General messages */

#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 */
@@ -218,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)
@@ -258,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,
@@ -368,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) */