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

Commit edf6be24 authored by Artem Bityutskiy's avatar Artem Bityutskiy
Browse files

UBIFS: rename dumping functions 



This commit re-names all functions which dump something from "dbg_dump_*()" to
"ubifs_dump_*()". This is done for consistency with UBI and because this way it
will be more logical once we remove the debugging sompilation option.

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

fs/ubifs/commit.c

+2 −2
Original line number Diff line number Diff line
@@ -715,13 +715,13 @@ int dbg_check_old_index(struct ubifs_info *c, struct ubifs_zbranch *zroot) 


out_dump:

	dbg_err("dumping index node (iip=%d)", i->iip);

	dbg_dump_node(c, idx);

	ubifs_dump_node(c, idx);

	list_del(&i->list);

	kfree(i);

	if (!list_empty(&list)) {

		i = list_entry(list.prev, struct idx_node, list);

		dbg_err("dumping parent index node");

		dbg_dump_node(c, &i->idx);

		ubifs_dump_node(c, &i->idx);

	}

out_free:

	while (!list_empty(&list)) {

fs/ubifs/debug.c

+55 −55
Original line number Diff line number Diff line
@@ -232,7 +232,7 @@ static void dump_ch(const struct ubifs_ch *ch) 
	printk(KERN_ERR "\tlen            %u\n", le32_to_cpu(ch->len));

}



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

void ubifs_dump_inode(struct ubifs_info *c, const struct inode *inode)

{

	const struct ubifs_inode *ui = ubifs_inode(inode);

	struct qstr nm = { .name = NULL };
@@ -300,7 +300,7 @@ void dbg_dump_inode(struct ubifs_info *c, const struct inode *inode) 
	kfree(pdent);

}



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

void ubifs_dump_node(const struct ubifs_info *c, const void *node)

{

	int i, n;

	union ubifs_key key;
@@ -603,7 +603,7 @@ void dbg_dump_node(const struct ubifs_info *c, const void *node) 
	spin_unlock(&dbg_lock);

}



void dbg_dump_budget_req(const struct ubifs_budget_req *req)

void ubifs_dump_budget_req(const struct ubifs_budget_req *req)

{

	spin_lock(&dbg_lock);

	printk(KERN_ERR "Budgeting request: new_ino %d, dirtied_ino %d\n",
@@ -620,7 +620,7 @@ void dbg_dump_budget_req(const struct ubifs_budget_req *req) 
	spin_unlock(&dbg_lock);

}



void dbg_dump_lstats(const struct ubifs_lp_stats *lst)

void ubifs_dump_lstats(const struct ubifs_lp_stats *lst)

{

	spin_lock(&dbg_lock);

	printk(KERN_ERR "(pid %d) Lprops statistics: empty_lebs %d, "
@@ -634,7 +634,7 @@ void dbg_dump_lstats(const struct ubifs_lp_stats *lst) 
	spin_unlock(&dbg_lock);

}



void dbg_dump_budg(struct ubifs_info *c, const struct ubifs_budg_info *bi)

void ubifs_dump_budg(struct ubifs_info *c, const struct ubifs_budg_info *bi)

{

	int i;

	struct rb_node *rb;
@@ -707,7 +707,7 @@ void dbg_dump_budg(struct ubifs_info *c, const struct ubifs_budg_info *bi) 
	spin_unlock(&c->space_lock);

}



void dbg_dump_lprop(const struct ubifs_info *c, const struct ubifs_lprops *lp)

void ubifs_dump_lprop(const struct ubifs_info *c, const struct ubifs_lprops *lp)

{

	int i, spc, dark = 0, dead = 0;

	struct rb_node *rb;
@@ -801,7 +801,7 @@ void dbg_dump_lprop(const struct ubifs_info *c, const struct ubifs_lprops *lp) 
	printk(KERN_CONT ")\n");

}



void dbg_dump_lprops(struct ubifs_info *c)

void ubifs_dump_lprops(struct ubifs_info *c)

{

	int lnum, err;

	struct ubifs_lprops lp;
@@ -810,20 +810,20 @@ void dbg_dump_lprops(struct ubifs_info *c) 
	printk(KERN_ERR "(pid %d) start dumping LEB properties\n",

	       current->pid);

	ubifs_get_lp_stats(c, &lst);

	dbg_dump_lstats(&lst);

	ubifs_dump_lstats(&lst);



	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);



		dbg_dump_lprop(c, &lp);

		ubifs_dump_lprop(c, &lp);

	}

	printk(KERN_ERR "(pid %d) finish dumping LEB properties\n",

	       current->pid);

}



void dbg_dump_lpt_info(struct ubifs_info *c)

void ubifs_dump_lpt_info(struct ubifs_info *c)

{

	int i;
@@ -862,7 +862,7 @@ void dbg_dump_lpt_info(struct ubifs_info *c) 
	spin_unlock(&dbg_lock);

}



void dbg_dump_sleb(const struct ubifs_info *c,

void ubifs_dump_sleb(const struct ubifs_info *c,

		     const struct ubifs_scan_leb *sleb, int offs)

{

	struct ubifs_scan_node *snod;
@@ -874,11 +874,11 @@ void dbg_dump_sleb(const struct ubifs_info *c, 
		cond_resched();

		printk(KERN_ERR "Dumping node at LEB %d:%d len %d\n", sleb->lnum,

		       snod->offs, snod->len);

		dbg_dump_node(c, snod->node);

		ubifs_dump_node(c, snod->node);

	}

}



void dbg_dump_leb(const struct ubifs_info *c, int lnum)

void ubifs_dump_leb(const struct ubifs_info *c, int lnum)

{

	struct ubifs_scan_leb *sleb;

	struct ubifs_scan_node *snod;
@@ -909,7 +909,7 @@ void dbg_dump_leb(const struct ubifs_info *c, int lnum) 
		cond_resched();

		printk(KERN_ERR "Dumping node at LEB %d:%d len %d\n", lnum,

		       snod->offs, snod->len);

		dbg_dump_node(c, snod->node);

		ubifs_dump_node(c, snod->node);

	}



	printk(KERN_ERR "(pid %d) finish dumping LEB %d\n",
@@ -921,7 +921,7 @@ void dbg_dump_leb(const struct ubifs_info *c, int lnum) 
	return;

}



void dbg_dump_znode(const struct ubifs_info *c,

void ubifs_dump_znode(const struct ubifs_info *c,

		      const struct ubifs_znode *znode)

{

	int n;
@@ -965,7 +965,7 @@ void dbg_dump_znode(const struct ubifs_info *c, 
	spin_unlock(&dbg_lock);

}



void dbg_dump_heap(struct ubifs_info *c, struct ubifs_lpt_heap *heap, int cat)

void ubifs_dump_heap(struct ubifs_info *c, struct ubifs_lpt_heap *heap, int cat)

{

	int i;
@@ -981,7 +981,7 @@ void dbg_dump_heap(struct ubifs_info *c, struct ubifs_lpt_heap *heap, int cat) 
	printk(KERN_ERR "(pid %d) finish dumping heap\n", current->pid);

}



void dbg_dump_pnode(struct ubifs_info *c, struct ubifs_pnode *pnode,

void ubifs_dump_pnode(struct ubifs_info *c, struct ubifs_pnode *pnode,

		      struct ubifs_nnode *parent, int iip)

{

	int i;
@@ -999,7 +999,7 @@ void dbg_dump_pnode(struct ubifs_info *c, struct ubifs_pnode *pnode, 
	}

}



void dbg_dump_tnc(struct ubifs_info *c)

void ubifs_dump_tnc(struct ubifs_info *c)

{

	struct ubifs_znode *znode;

	int level;
@@ -1014,7 +1014,7 @@ void dbg_dump_tnc(struct ubifs_info *c) 
			level = znode->level;

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

		}

		dbg_dump_znode(c, znode);

		ubifs_dump_znode(c, znode);

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

	}

	printk(KERN_ERR "(pid %d) finish dumping TNC tree\n", current->pid);
@@ -1023,18 +1023,18 @@ void dbg_dump_tnc(struct ubifs_info *c) 
static int dump_znode(struct ubifs_info *c, struct ubifs_znode *znode,

		      void *priv)

{

	dbg_dump_znode(c, znode);

	ubifs_dump_znode(c, znode);

	return 0;

}



/**

 * dbg_dump_index - dump the on-flash index.

 * ubifs_dump_index - dump the on-flash index.

 * @c: UBIFS file-system description object

 *

 * This function dumps whole UBIFS indexing B-tree, unlike 'dbg_dump_tnc()'

 * This function dumps whole UBIFS indexing B-tree, unlike 'ubifs_dump_tnc()'

 * which dumps only in-memory znodes and does not read znodes which from flash.

 */

void dbg_dump_index(struct ubifs_info *c)

void ubifs_dump_index(struct ubifs_info *c)

{

	dbg_walk_index(c, NULL, dump_znode, NULL);

}
@@ -1120,15 +1120,15 @@ int dbg_check_space_info(struct ubifs_info *c) 


out:

	ubifs_msg("saved lprops statistics dump");

	dbg_dump_lstats(&d->saved_lst);

	ubifs_dump_lstats(&d->saved_lst);

	ubifs_msg("saved budgeting info dump");

	dbg_dump_budg(c, &d->saved_bi);

	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_get_lp_stats(c, &lst);

	dbg_dump_lstats(&lst);

	ubifs_dump_lstats(&lst);

	ubifs_msg("current budgeting info dump");

	dbg_dump_budg(c, &c->bi);

	ubifs_dump_budg(c, &c->bi);

	dump_stack();

	return -EINVAL;

}
@@ -1223,14 +1223,14 @@ int dbg_check_dir(struct ubifs_info *c, const struct inode *dir) 
			  "but calculated size is %llu", dir->i_ino,

			  (unsigned long long)i_size_read(dir),

			  (unsigned long long)size);

		dbg_dump_inode(c, dir);

		ubifs_dump_inode(c, dir);

		dump_stack();

		return -EINVAL;

	}

	if (dir->i_nlink != nlink) {

		ubifs_err("directory inode %lu has nlink %u, but calculated "

			  "nlink is %u", dir->i_ino, dir->i_nlink, nlink);

		dbg_dump_inode(c, dir);

		ubifs_dump_inode(c, dir);

		dump_stack();

		return -EINVAL;

	}
@@ -1293,7 +1293,7 @@ static int dbg_check_key_order(struct ubifs_info *c, struct ubifs_zbranch *zbr1, 
		dbg_err("but it should have key %s according to tnc",

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

					 DBG_KEY_BUF_LEN));

		dbg_dump_node(c, dent1);

		ubifs_dump_node(c, dent1);

		goto out_free;

	}
@@ -1305,7 +1305,7 @@ static int dbg_check_key_order(struct ubifs_info *c, struct ubifs_zbranch *zbr1, 
		dbg_err("but it should have key %s according to tnc",

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

					 DBG_KEY_BUF_LEN));

		dbg_dump_node(c, dent2);

		ubifs_dump_node(c, dent2);

		goto out_free;

	}
@@ -1324,9 +1324,9 @@ static int dbg_check_key_order(struct ubifs_info *c, struct ubifs_zbranch *zbr1, 
			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);

	ubifs_dump_node(c, dent1);

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

	dbg_dump_node(c, dent2);

	ubifs_dump_node(c, dent2);



out_free:

	kfree(dent2);
@@ -1529,10 +1529,10 @@ static int dbg_check_znode(struct ubifs_info *c, struct ubifs_zbranch *zbr) 
out:

	ubifs_err("failed, error %d", err);

	ubifs_msg("dump of the znode");

	dbg_dump_znode(c, znode);

	ubifs_dump_znode(c, znode);

	if (zp) {

		ubifs_msg("dump of the parent znode");

		dbg_dump_znode(c, zp);

		ubifs_dump_znode(c, zp);

	}

	dump_stack();

	return -EINVAL;
@@ -1599,9 +1599,9 @@ int dbg_check_tnc(struct ubifs_info *c, int extra) 
				return err;

			if (err) {

				ubifs_msg("first znode");

				dbg_dump_znode(c, prev);

				ubifs_dump_znode(c, prev);

				ubifs_msg("second znode");

				dbg_dump_znode(c, znode);

				ubifs_dump_znode(c, znode);

				return -EINVAL;

			}

		}
@@ -1690,7 +1690,7 @@ int dbg_walk_index(struct ubifs_info *c, dbg_leaf_callback leaf_cb, 
			if (err) {

				ubifs_err("znode checking function returned "

					  "error %d", err);

				dbg_dump_znode(c, znode);

				ubifs_dump_znode(c, znode);

				goto out_dump;

			}

		}
@@ -1758,7 +1758,7 @@ int dbg_walk_index(struct ubifs_info *c, dbg_leaf_callback leaf_cb, 
	else

		zbr = &c->zroot;

	ubifs_msg("dump of znode at LEB %d:%d", zbr->lnum, zbr->offs);

	dbg_dump_znode(c, znode);

	ubifs_dump_znode(c, znode);

out_unlock:

	mutex_unlock(&c->tnc_mutex);

	return err;
@@ -2194,7 +2194,7 @@ static int check_leaf(struct ubifs_info *c, struct ubifs_zbranch *zbr, 


out_dump:

	ubifs_msg("dump of node at LEB %d:%d", zbr->lnum, zbr->offs);

	dbg_dump_node(c, node);

	ubifs_dump_node(c, node);

out_free:

	kfree(node);

	return err;
@@ -2352,7 +2352,7 @@ static int check_inodes(struct ubifs_info *c, struct fsck_data *fsckd) 


	ubifs_msg("dump of the inode %lu sitting in LEB %d:%d",

		  (unsigned long)fscki->inum, zbr->lnum, zbr->offs);

	dbg_dump_node(c, ino);

	ubifs_dump_node(c, ino);

	kfree(ino);

	return -EINVAL;

}
@@ -2423,12 +2423,12 @@ int dbg_check_data_nodes_order(struct ubifs_info *c, struct list_head *head) 


		if (sa->type != UBIFS_DATA_NODE) {

			ubifs_err("bad node type %d", sa->type);

			dbg_dump_node(c, sa->node);

			ubifs_dump_node(c, sa->node);

			return -EINVAL;

		}

		if (sb->type != UBIFS_DATA_NODE) {

			ubifs_err("bad node type %d", sb->type);

			dbg_dump_node(c, sb->node);

			ubifs_dump_node(c, sb->node);

			return -EINVAL;

		}
@@ -2459,8 +2459,8 @@ int dbg_check_data_nodes_order(struct ubifs_info *c, struct list_head *head) 
	return 0;



error_dump:

	dbg_dump_node(c, sa->node);

	dbg_dump_node(c, sb->node);

	ubifs_dump_node(c, sa->node);

	ubifs_dump_node(c, sb->node);

	return -EINVAL;

}
@@ -2491,13 +2491,13 @@ 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);

			dbg_dump_node(c, sa->node);

			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);

			dbg_dump_node(c, sb->node);

			ubifs_dump_node(c, sb->node);

			return -EINVAL;

		}
@@ -2547,9 +2547,9 @@ int dbg_check_nondata_nodes_order(struct ubifs_info *c, struct list_head *head) 


error_dump:

	ubifs_msg("dumping first node");

	dbg_dump_node(c, sa->node);

	ubifs_dump_node(c, sa->node);

	ubifs_msg("dumping second node");

	dbg_dump_node(c, sb->node);

	ubifs_dump_node(c, sb->node);

	return -EINVAL;

	return 0;

}
@@ -2857,16 +2857,16 @@ static ssize_t dfs_file_write(struct file *file, const char __user *u, 
	 * 'ubifs-debug' file-system instead.

	 */

	if (file->f_path.dentry == d->dfs_dump_lprops) {

		dbg_dump_lprops(c);

		ubifs_dump_lprops(c);

		return count;

	}

	if (file->f_path.dentry == d->dfs_dump_budg) {

		dbg_dump_budg(c, &c->bi);

		ubifs_dump_budg(c, &c->bi);

		return count;

	}

	if (file->f_path.dentry == d->dfs_dump_tnc) {

		mutex_lock(&c->tnc_mutex);

		dbg_dump_tnc(c);

		ubifs_dump_tnc(c);

		mutex_unlock(&c->tnc_mutex);

		return count;

	}

fs/ubifs/debug.h

+48 −51
Original line number Diff line number Diff line
@@ -255,27 +255,27 @@ 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,

		       int offs);

void dbg_dump_budget_req(const struct ubifs_budget_req *req);

void dbg_dump_lstats(const struct ubifs_lp_stats *lst);

void dbg_dump_budg(struct ubifs_info *c, const struct ubifs_budg_info *bi);

void dbg_dump_lprop(const struct ubifs_info *c, const struct ubifs_lprops *lp);

void dbg_dump_lprops(struct ubifs_info *c);

void dbg_dump_lpt_info(struct ubifs_info *c);

void dbg_dump_leb(const struct ubifs_info *c, int lnum);

void dbg_dump_sleb(const struct ubifs_info *c,

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

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

void ubifs_dump_budget_req(const struct ubifs_budget_req *req);

void ubifs_dump_lstats(const struct ubifs_lp_stats *lst);

void ubifs_dump_budg(struct ubifs_info *c, const struct ubifs_budg_info *bi);

void ubifs_dump_lprop(const struct ubifs_info *c,

		      const struct ubifs_lprops *lp);

void ubifs_dump_lprops(struct ubifs_info *c);

void ubifs_dump_lpt_info(struct ubifs_info *c);

void ubifs_dump_leb(const struct ubifs_info *c, int lnum);

void ubifs_dump_sleb(const struct ubifs_info *c,

		     const struct ubifs_scan_leb *sleb, int offs);

void dbg_dump_znode(const struct ubifs_info *c,

void ubifs_dump_znode(const struct ubifs_info *c,

		      const struct ubifs_znode *znode);

void dbg_dump_heap(struct ubifs_info *c, struct ubifs_lpt_heap *heap, int cat);

void dbg_dump_pnode(struct ubifs_info *c, struct ubifs_pnode *pnode,

void ubifs_dump_heap(struct ubifs_info *c, struct ubifs_lpt_heap *heap,

		     int cat);

void ubifs_dump_pnode(struct ubifs_info *c, struct ubifs_pnode *pnode,

		      struct ubifs_nnode *parent, int iip);

void dbg_dump_tnc(struct ubifs_info *c);

void dbg_dump_index(struct ubifs_info *c);

void dbg_dump_lpt_lebs(const struct ubifs_info *c);

void ubifs_dump_tnc(struct ubifs_info *c);

void ubifs_dump_index(struct ubifs_info *c);

void ubifs_dump_lpt_lebs(const struct ubifs_info *c);



int dbg_walk_index(struct ubifs_info *c, dbg_leaf_callback leaf_cb,

		   dbg_znode_callback znode_cb, void *priv);
@@ -371,42 +371,39 @@ 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,

static inline void ubifs_dump_inode(struct ubifs_info *c,

				    const struct inode *inode)    { return; }

static inline void dbg_dump_node(const struct ubifs_info *c,

static inline void ubifs_dump_node(const struct ubifs_info *c,

				   const void *node)              { return; }

static inline void dbg_dump_lpt_node(const struct ubifs_info *c,

				     void *node, int lnum,

				     int offs)                    { return; }

static inline void

dbg_dump_budget_req(const struct ubifs_budget_req *req)           { return; }

ubifs_dump_budget_req(const struct ubifs_budget_req *req)         { return; }

static inline void

dbg_dump_lstats(const struct ubifs_lp_stats *lst)                 { return; }

ubifs_dump_lstats(const struct ubifs_lp_stats *lst)               { return; }

static inline void

dbg_dump_budg(struct ubifs_info *c,

ubifs_dump_budg(struct ubifs_info *c,

	      const struct ubifs_budg_info *bi)                   { return; }

static inline void dbg_dump_lprop(const struct ubifs_info *c,

static inline void ubifs_dump_lprop(const struct ubifs_info *c,

				    const struct ubifs_lprops *lp){ return; }

static inline void dbg_dump_lprops(struct ubifs_info *c)          { return; }

static inline void dbg_dump_lpt_info(struct ubifs_info *c)        { return; }

static inline void dbg_dump_leb(const struct ubifs_info *c,

static inline void ubifs_dump_lprops(struct ubifs_info *c)        { return; }

static inline void ubifs_dump_lpt_info(struct ubifs_info *c)      { return; }

static inline void ubifs_dump_leb(const struct ubifs_info *c,

				  int lnum)                       { return; }

static inline void

dbg_dump_sleb(const struct ubifs_info *c,

ubifs_dump_sleb(const struct ubifs_info *c,

		const struct ubifs_scan_leb *sleb, int offs)      { return; }

static inline void

dbg_dump_znode(const struct ubifs_info *c,

ubifs_dump_znode(const struct ubifs_info *c,

		 const struct ubifs_znode *znode)                 { return; }

static inline void dbg_dump_heap(struct ubifs_info *c,

static inline void ubifs_dump_heap(struct ubifs_info *c,

				   struct ubifs_lpt_heap *heap,

				   int cat)                       { return; }

static inline void dbg_dump_pnode(struct ubifs_info *c,

static inline void ubifs_dump_pnode(struct ubifs_info *c,

				    struct ubifs_pnode *pnode,

				    struct ubifs_nnode *parent,

				    int iip)                      { return; }

static inline void dbg_dump_tnc(struct ubifs_info *c)             { return; }

static inline void dbg_dump_index(struct ubifs_info *c)           { return; }

static inline void dbg_dump_lpt_lebs(const struct ubifs_info *c)  { return; }

static inline void ubifs_dump_tnc(struct ubifs_info *c)           { return; }

static inline void ubifs_dump_index(struct ubifs_info *c)         { return; }

static inline void ubifs_dump_lpt_lebs(const struct ubifs_info *c){ return; }



static inline int dbg_walk_index(struct ubifs_info *c,

				 dbg_leaf_callback leaf_cb,

fs/ubifs/file.c

+1 −1
Original line number Diff line number Diff line
@@ -97,7 +97,7 @@ static int read_block(struct inode *inode, void *addr, unsigned int block, 
dump:

	ubifs_err("bad data node (block %u, inode %lu)",

		  block, inode->i_ino);

	dbg_dump_node(c, dn);

	ubifs_dump_node(c, dn);

	return -EINVAL;

}

fs/ubifs/io.c

+6 −6
Original line number Diff line number Diff line
@@ -294,7 +294,7 @@ int ubifs_check_node(const struct ubifs_info *c, const void *buf, int lnum, 
out:

	if (!quiet) {

		ubifs_err("bad node at LEB %d:%d", lnum, offs);

		dbg_dump_node(c, buf);

		ubifs_dump_node(c, buf);

		dump_stack();

	}

	return err;
@@ -841,9 +841,9 @@ int ubifs_wbuf_write_nolock(struct ubifs_wbuf *wbuf, void *buf, int len) 
out:

	ubifs_err("cannot write %d bytes to LEB %d:%d, error %d",

		  len, wbuf->lnum, wbuf->offs, err);

	dbg_dump_node(c, buf);

	ubifs_dump_node(c, buf);

	dump_stack();

	dbg_dump_leb(c, wbuf->lnum);

	ubifs_dump_leb(c, wbuf->lnum);

	return err;

}
@@ -881,7 +881,7 @@ int ubifs_write_node(struct ubifs_info *c, void *buf, int len, int lnum, 
	ubifs_prepare_node(c, buf, len, 1);

	err = ubifs_leb_write(c, lnum, buf, offs, buf_len, dtype);

	if (err)

		dbg_dump_node(c, buf);

		ubifs_dump_node(c, buf);



	return err;

}
@@ -960,7 +960,7 @@ int ubifs_read_node_wbuf(struct ubifs_wbuf *wbuf, void *buf, int type, int len, 


out:

	ubifs_err("bad node at LEB %d:%d", lnum, offs);

	dbg_dump_node(c, buf);

	ubifs_dump_node(c, buf);

	dump_stack();

	return -EINVAL;

}
@@ -1017,7 +1017,7 @@ int ubifs_read_node(const struct ubifs_info *c, void *buf, int type, int len, 
out:

	ubifs_err("bad node at LEB %d:%d, LEB mapping status %d", lnum, offs,

		  ubi_is_mapped(c->ubi, lnum));

	dbg_dump_node(c, buf);

	ubifs_dump_node(c, buf);

	dump_stack();

	return -EINVAL;

}