Commit 59a7ac12 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: (32 commits)
  MAINTAINERS: change e-mail of Adrian Hunter
  UBIFS: fix master node recovery
  UBIFS: improve power cut emulation testing
  UBIFS: rename recovery testing variables
  UBIFS: remove custom list of superblocks
  UBIFS: stop re-defining UBI operations
  UBIFS: switch to I/O helpers
  UBIFS: switch to ubifs_leb_write
  UBIFS: switch to ubifs_leb_read
  UBIFS: introduce more I/O helpers
  UBIFS: always print stacktrace when switching to R/O mode
  UBIFS: remove unused and unneeded debugging function
  UBIFS: add global debugfs knobs
  UBIFS: introduce debugfs helpers
  UBIFS: re-arrange debugging code a bit
  UBIFS: be more informative in failure mode
  UBIFS: switch self-check knobs to debugfs
  UBIFS: lessen amount of debugging check types
  UBIFS: introduce helper functions for debugging checks and tests
  UBIFS: amend debugging inode size check function prototype
  ...
parents f99b7880 cc8f9b99

Documentation/filesystems/ubifs.txt

+0 −28
Original line number Diff line number Diff line
@@ -111,34 +111,6 @@ The following is an example of the kernel boot arguments to attach mtd0 
to UBI and mount volume "rootfs":

ubi.mtd=0 root=ubi0:rootfs rootfstype=ubifs





Module Parameters for Debugging

===============================



When UBIFS has been compiled with debugging enabled, there are 2 module

parameters that are available to control aspects of testing and debugging.



debug_chks	Selects extra checks that UBIFS can do while running:



		Check					Flag value



		General checks				1

		Check Tree Node Cache (TNC)		2

		Check indexing tree size		4

		Check orphan area			8

		Check old indexing tree			16

		Check LEB properties (lprops)		32

		Check leaf nodes and inodes		64



debug_tsts	Selects a mode of testing, as follows:



		Test mode				Flag value



		Failure mode for recovery testing	4



For example, set debug_chks to 3 to enable general and TNC checks.





References

==========

MAINTAINERS

+2 −1
Original line number Diff line number Diff line 




	List of maintainers and how to submit kernel changes



Please try to follow the guidelines below.  This will make things
@@ -6321,7 +6322,7 @@ F: drivers/scsi/u14-34f.c 


UBI FILE SYSTEM (UBIFS)

M:	Artem Bityutskiy <dedekind1@gmail.com>

M:	Adrian Hunter <adrian.hunter@nokia.com>

M:	Adrian Hunter <adrian.hunter@intel.com>

L:	linux-mtd@lists.infradead.org

T:	git git://git.infradead.org/ubifs-2.6.git

W:	http://www.linux-mtd.infradead.org/doc/ubifs.html

fs/ubifs/commit.c

+4 −4
Original line number Diff line number Diff line
@@ -78,7 +78,7 @@ static int nothing_to_commit(struct ubifs_info *c) 
	 * If the root TNC node is dirty, we definitely have something to

	 * commit.

	 */

	if (c->zroot.znode && test_bit(DIRTY_ZNODE, &c->zroot.znode->flags))

	if (c->zroot.znode && ubifs_zn_dirty(c->zroot.znode))

		return 0;



	/*
@@ -418,7 +418,7 @@ int ubifs_run_commit(struct ubifs_info *c) 


	spin_lock(&c->cs_lock);

	if (c->cmt_state == COMMIT_BROKEN) {

		err = -EINVAL;

		err = -EROFS;

		goto out;

	}
@@ -444,7 +444,7 @@ int ubifs_run_commit(struct ubifs_info *c) 
	 * re-check it.

	 */

	if (c->cmt_state == COMMIT_BROKEN) {

		err = -EINVAL;

		err = -EROFS;

		goto out_cmt_unlock;

	}
@@ -576,7 +576,7 @@ int dbg_check_old_index(struct ubifs_info *c, struct ubifs_zbranch *zroot) 
	struct idx_node *i;

	size_t sz;



	if (!(ubifs_chk_flags & UBIFS_CHK_OLD_IDX))

	if (!dbg_is_chk_index(c))

		return 0;



	INIT_LIST_HEAD(&list);

fs/ubifs/debug.c

+502 −260

File changed.

Preview size limit exceeded, changes collapsed.

fs/ubifs/debug.h

+133 −108
Original line number Diff line number Diff line
@@ -31,18 +31,25 @@ typedef int (*dbg_znode_callback)(struct ubifs_info *c, 


#ifdef CONFIG_UBIFS_FS_DEBUG



#include <linux/random.h>

/*

 * The UBIFS debugfs directory name pattern and maximum name length (3 for "ubi"

 * + 1 for "_" and plus 2x2 for 2 UBI numbers and 1 for the trailing zero byte.

 */

#define UBIFS_DFS_DIR_NAME "ubi%d_%d"

#define UBIFS_DFS_DIR_LEN  (3 + 1 + 2*2 + 1)



/**

 * ubifs_debug_info - per-FS debugging information.

 * @old_zroot: old index root - used by 'dbg_check_old_index()'

 * @old_zroot_level: old index root level - used by 'dbg_check_old_index()'

 * @old_zroot_sqnum: old index root sqnum - used by 'dbg_check_old_index()'

 * @failure_mode: failure mode for recovery testing

 * @fail_delay: 0=>don't delay, 1=>delay a time, 2=>delay a number of calls

 * @fail_timeout: time in jiffies when delay of failure mode expires

 * @fail_cnt: current number of calls to failure mode I/O functions

 * @fail_cnt_max: number of calls by which to delay failure mode

 *

 * @pc_happened: non-zero if an emulated power cut happened

 * @pc_delay: 0=>don't delay, 1=>delay a time, 2=>delay a number of calls

 * @pc_timeout: time in jiffies when delay of failure mode expires

 * @pc_cnt: current number of calls to failure mode I/O functions

 * @pc_cnt_max: number of calls by which to delay failure mode

 *

 * @chk_lpt_sz: used by LPT tree size checker

 * @chk_lpt_sz2: used by LPT tree size checker

 * @chk_lpt_wastage: used by LPT tree size checker
@@ -56,21 +63,36 @@ typedef int (*dbg_znode_callback)(struct ubifs_info *c, 
 * @saved_free: saved amount of free space

 * @saved_idx_gc_cnt: saved value of @c->idx_gc_cnt

 *

 * @chk_gen: if general extra checks are enabled

 * @chk_index: if index xtra checks are enabled

 * @chk_orph: if orphans extra checks are enabled

 * @chk_lprops: if lprops extra checks are enabled

 * @chk_fs: if UBIFS contents extra checks are enabled

 * @tst_rcvry: if UBIFS recovery testing mode enabled

 *

 * @dfs_dir_name: name of debugfs directory containing this file-system's files

 * @dfs_dir: direntry object of the file-system debugfs directory

 * @dfs_dump_lprops: "dump lprops" debugfs knob

 * @dfs_dump_budg: "dump budgeting information" debugfs knob

 * @dfs_dump_tnc: "dump TNC" debugfs knob

 * @dfs_chk_gen: debugfs knob to enable UBIFS general extra checks

 * @dfs_chk_index: debugfs knob to enable UBIFS index extra checks

 * @dfs_chk_orph: debugfs knob to enable UBIFS orphans extra checks

 * @dfs_chk_lprops: debugfs knob to enable UBIFS LEP properties extra checks

 * @dfs_chk_fs: debugfs knob to enable UBIFS contents extra checks

 * @dfs_tst_rcvry: debugfs knob to enable UBIFS recovery testing

 */

struct ubifs_debug_info {

	struct ubifs_zbranch old_zroot;

	int old_zroot_level;

	unsigned long long old_zroot_sqnum;

	int failure_mode;

	int fail_delay;

	unsigned long fail_timeout;

	unsigned int fail_cnt;

	unsigned int fail_cnt_max;



	int pc_happened;

	int pc_delay;

	unsigned long pc_timeout;

	unsigned int pc_cnt;

	unsigned int pc_cnt_max;



	long long chk_lpt_sz;

	long long chk_lpt_sz2;

	long long chk_lpt_wastage;
@@ -84,11 +106,43 @@ struct ubifs_debug_info { 
	long long saved_free;

	int saved_idx_gc_cnt;



	char dfs_dir_name[100];

	unsigned int chk_gen:1;

	unsigned int chk_index:1;

	unsigned int chk_orph:1;

	unsigned int chk_lprops:1;

	unsigned int chk_fs:1;

	unsigned int tst_rcvry:1;



	char dfs_dir_name[UBIFS_DFS_DIR_LEN + 1];

	struct dentry *dfs_dir;

	struct dentry *dfs_dump_lprops;

	struct dentry *dfs_dump_budg;

	struct dentry *dfs_dump_tnc;

	struct dentry *dfs_chk_gen;

	struct dentry *dfs_chk_index;

	struct dentry *dfs_chk_orph;

	struct dentry *dfs_chk_lprops;

	struct dentry *dfs_chk_fs;

	struct dentry *dfs_tst_rcvry;

};



/**

 * ubifs_global_debug_info - global (not per-FS) UBIFS debugging information.

 *

 * @chk_gen: if general extra checks are enabled

 * @chk_index: if index xtra checks are enabled

 * @chk_orph: if orphans extra checks are enabled

 * @chk_lprops: if lprops extra checks are enabled

 * @chk_fs: if UBIFS contents extra checks are enabled

 * @tst_rcvry: if UBIFS recovery testing mode enabled

 */

struct ubifs_global_debug_info {

	unsigned int chk_gen:1;

	unsigned int chk_index:1;

	unsigned int chk_orph:1;

	unsigned int chk_lprops:1;

	unsigned int chk_fs:1;

	unsigned int tst_rcvry:1;

};



#define ubifs_assert(expr) do {                                                \
@@ -127,6 +181,8 @@ const char *dbg_key_str1(const struct ubifs_info *c, 
#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__); \
@@ -162,41 +218,36 @@ const char *dbg_key_str1(const struct ubifs_info *c, 
/* Additional recovery messages */

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



/*

 * Debugging check flags.

 *

 * UBIFS_CHK_GEN: general checks

 * UBIFS_CHK_TNC: check TNC

 * UBIFS_CHK_IDX_SZ: check index size

 * UBIFS_CHK_ORPH: check orphans

 * UBIFS_CHK_OLD_IDX: check the old index

 * UBIFS_CHK_LPROPS: check lprops

 * UBIFS_CHK_FS: check the file-system

 */

enum {

	UBIFS_CHK_GEN     = 0x1,

	UBIFS_CHK_TNC     = 0x2,

	UBIFS_CHK_IDX_SZ  = 0x4,

	UBIFS_CHK_ORPH    = 0x8,

	UBIFS_CHK_OLD_IDX = 0x10,

	UBIFS_CHK_LPROPS  = 0x20,

	UBIFS_CHK_FS      = 0x40,

};

extern struct ubifs_global_debug_info ubifs_dbg;



/*

 * Special testing flags.

 *

 * UBIFS_TST_RCVRY: failure mode for recovery testing

 */

enum {

	UBIFS_TST_RCVRY             = 0x4,

};



extern spinlock_t dbg_lock;



extern unsigned int ubifs_msg_flags;

extern unsigned int ubifs_chk_flags;

extern unsigned int ubifs_tst_flags;

static inline int dbg_is_chk_gen(const struct ubifs_info *c)

{

	return !!(ubifs_dbg.chk_gen || c->dbg->chk_gen);

}

static inline int dbg_is_chk_index(const struct ubifs_info *c)

{

	return !!(ubifs_dbg.chk_index || c->dbg->chk_index);

}

static inline int dbg_is_chk_orph(const struct ubifs_info *c)

{

	return !!(ubifs_dbg.chk_orph || c->dbg->chk_orph);

}

static inline int dbg_is_chk_lprops(const struct ubifs_info *c)

{

	return !!(ubifs_dbg.chk_lprops || c->dbg->chk_lprops);

}

static inline int dbg_is_chk_fs(const struct ubifs_info *c)

{

	return !!(ubifs_dbg.chk_fs || c->dbg->chk_fs);

}

static inline int dbg_is_tst_rcvry(const struct ubifs_info *c)

{

	return !!(ubifs_dbg.tst_rcvry || c->dbg->tst_rcvry);

}

static inline int dbg_is_power_cut(const struct ubifs_info *c)

{

	return !!c->dbg->pc_happened;

}



int ubifs_debugging_init(struct ubifs_info *c);

void ubifs_debugging_exit(struct ubifs_info *c);
@@ -207,7 +258,7 @@ 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);

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

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);
@@ -240,8 +291,8 @@ int dbg_check_cats(struct ubifs_info *c); 
int dbg_check_ltab(struct ubifs_info *c);

int dbg_chk_lpt_free_spc(struct ubifs_info *c);

int dbg_chk_lpt_sz(struct ubifs_info *c, int action, int len);

int dbg_check_synced_i_size(struct inode *inode);

int dbg_check_dir_size(struct ubifs_info *c, const struct inode *dir);

int dbg_check_synced_i_size(const struct ubifs_info *c, struct inode *inode);

int dbg_check_dir(struct ubifs_info *c, const struct inode *dir);

int dbg_check_tnc(struct ubifs_info *c, int extra);

int dbg_check_idx_size(struct ubifs_info *c, long long idx_size);

int dbg_check_filesystem(struct ubifs_info *c);
@@ -254,54 +305,12 @@ int dbg_check_inode_size(struct ubifs_info *c, const struct inode *inode, 
int dbg_check_data_nodes_order(struct ubifs_info *c, struct list_head *head);

int dbg_check_nondata_nodes_order(struct ubifs_info *c, struct list_head *head);



/* Force the use of in-the-gaps method for testing */

static inline int dbg_force_in_the_gaps_enabled(void)

{

	return ubifs_chk_flags & UBIFS_CHK_GEN;

}

int dbg_force_in_the_gaps(void);



/* Failure mode for recovery testing */

#define dbg_failure_mode (ubifs_tst_flags & UBIFS_TST_RCVRY)



#ifndef UBIFS_DBG_PRESERVE_UBI

#define ubi_leb_read   dbg_leb_read

#define ubi_leb_write  dbg_leb_write

#define ubi_leb_change dbg_leb_change

#define ubi_leb_erase  dbg_leb_erase

#define ubi_leb_unmap  dbg_leb_unmap

#define ubi_is_mapped  dbg_is_mapped

#define ubi_leb_map    dbg_leb_map

#endif



int dbg_leb_read(struct ubi_volume_desc *desc, int lnum, char *buf, int offset,

		 int len, int check);

int dbg_leb_write(struct ubi_volume_desc *desc, int lnum, const void *buf,

		  int offset, int len, int dtype);

int dbg_leb_change(struct ubi_volume_desc *desc, int lnum, const void *buf,

int dbg_leb_write(struct ubifs_info *c, int lnum, const void *buf, int offs,

		  int len, int dtype);

int dbg_leb_erase(struct ubi_volume_desc *desc, int lnum);

int dbg_leb_unmap(struct ubi_volume_desc *desc, int lnum);

int dbg_is_mapped(struct ubi_volume_desc *desc, int lnum);

int dbg_leb_map(struct ubi_volume_desc *desc, int lnum, int dtype);



static inline int dbg_read(struct ubi_volume_desc *desc, int lnum, char *buf,

			   int offset, int len)

{

	return dbg_leb_read(desc, lnum, buf, offset, len, 0);

}



static inline int dbg_write(struct ubi_volume_desc *desc, int lnum,

			    const void *buf, int offset, int len)

{

	return dbg_leb_write(desc, lnum, buf, offset, len, UBI_UNKNOWN);

}



static inline int dbg_change(struct ubi_volume_desc *desc, int lnum,

				    const void *buf, int len)

{

	return dbg_leb_change(desc, lnum, buf, len, UBI_UNKNOWN);

}

int dbg_leb_change(struct ubifs_info *c, int lnum, const void *buf, int len,

		   int dtype);

int dbg_leb_unmap(struct ubifs_info *c, int lnum);

int dbg_leb_map(struct ubifs_info *c, int lnum, int dtype);



/* Debugfs-related stuff */

int dbg_debugfs_init(void);
@@ -313,7 +322,7 @@ void dbg_debugfs_exit_fs(struct ubifs_info *c); 


/* Use "if (0)" to make compiler check arguments even if debugging is off */

#define ubifs_assert(expr)  do {                                               \

	if (0 && (expr))                                                       \

	if (0)                                                                 \

		printk(KERN_CRIT "UBIFS assert failed in %s at %u (pid %d)\n", \

		       __func__, __LINE__, current->pid);                      \

} while (0)
@@ -323,6 +332,9 @@ void dbg_debugfs_exit_fs(struct ubifs_info *c); 
		ubifs_err(fmt, ##__VA_ARGS__);     \

} while (0)



#define DBGKEY(key)  ((char *)(key))

#define DBGKEY1(key) ((char *)(key))



#define ubifs_dbg_msg(fmt, ...) do {               \

	if (0)                                     \

		pr_debug(fmt "\n", ##__VA_ARGS__); \
@@ -346,9 +358,6 @@ void dbg_debugfs_exit_fs(struct ubifs_info *c); 
#define dbg_scan(fmt, ...)  ubifs_dbg_msg(fmt, ##__VA_ARGS__)

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



#define DBGKEY(key)  ((char *)(key))

#define DBGKEY1(key) ((char *)(key))



static inline int ubifs_debugging_init(struct ubifs_info *c)      { return 0; }

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

static inline const char *dbg_ntype(int type)                     { return ""; }
@@ -357,7 +366,7 @@ 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 void dbg_dump_inode(const struct ubifs_info *c,

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,

				 const void *node)                { return; }
@@ -409,8 +418,10 @@ static inline int dbg_check_ltab(struct ubifs_info *c) { return 0; } 
static inline int dbg_chk_lpt_free_spc(struct ubifs_info *c)      { return 0; }

static inline int dbg_chk_lpt_sz(struct ubifs_info *c,

				 int action, int len)             { return 0; }

static inline int dbg_check_synced_i_size(struct inode *inode)    { return 0; }

static inline int dbg_check_dir_size(struct ubifs_info *c,

static inline int

dbg_check_synced_i_size(const struct ubifs_info *c,

			struct inode *inode)                      { return 0; }

static inline int dbg_check_dir(struct ubifs_info *c,

				const struct inode *dir)          { return 0; }

static inline int dbg_check_tnc(struct ubifs_info *c, int extra)  { return 0; }

static inline int dbg_check_idx_size(struct ubifs_info *c,
@@ -431,9 +442,23 @@ static inline int 
dbg_check_nondata_nodes_order(struct ubifs_info *c,

			      struct list_head *head)             { return 0; }



static inline int dbg_force_in_the_gaps(void)                     { return 0; }

#define dbg_force_in_the_gaps_enabled() 0

#define dbg_failure_mode                0

static inline int dbg_leb_write(struct ubifs_info *c, int lnum,

				const void *buf, int offset,

				int len, int dtype)               { return 0; }

static inline int dbg_leb_change(struct ubifs_info *c, int lnum,

				 const void *buf, int len,

				 int dtype)                       { return 0; }

static inline int dbg_leb_unmap(struct ubifs_info *c, int lnum)   { return 0; }

static inline int dbg_leb_map(struct ubifs_info *c, int lnum,

			      int dtype)                          { return 0; }



static inline int dbg_is_chk_gen(const struct ubifs_info *c)      { return 0; }

static inline int dbg_is_chk_index(const struct ubifs_info *c)    { return 0; }

static inline int dbg_is_chk_orph(const struct ubifs_info *c)     { return 0; }

static inline int dbg_is_chk_lprops(const struct ubifs_info *c)   { return 0; }

static inline int dbg_is_chk_fs(const struct ubifs_info *c)       { return 0; }

static inline int dbg_is_tst_rcvry(const struct ubifs_info *c)    { return 0; }

static inline int dbg_is_power_cut(const struct ubifs_info *c)    { return 0; }



static inline int dbg_debugfs_init(void)                          { return 0; }

static inline void dbg_debugfs_exit(void)                         { return; }

CRA Git | Maintained and supported by SUSTech CRA and CCSE