adulau/aha
1
0
Fork 0
mirror of https://github.com/adulau/aha.git synced 2024-12-29 04:06:22 +00:00
Code Issues Projects Releases Packages Wiki Activity

UBIFS: separate debugging fields out

Browse source 
Introduce a new data structure which contains all debugging
stuff inside. This is cleaner than having debugging stuff
directly in 'c'.

Signed-off-by: Artem Bityutskiy <Artem.Bityutskiy@nokia.com>
This commit is contained in:
Artem Bityutskiy 2008-10-17 13:31:39 +03:00
parent 5dd7cbc083
commit 17c2f9f85c
9 changed files with 156 additions and 113 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

25
fs/ubifs/commit.c
View file

@ -470,12 +470,12 @@ int dbg_old_index_check_init(struct ubifs_info *c, struct ubifs_zbranch *zroot)
{ {
struct ubifs_idx_node *idx; struct ubifs_idx_node *idx;
int lnum, offs, len, err = 0; int lnum, offs, len, err = 0;
struct ubifs_debug_info *d = c->dbg;
c->old_zroot = *zroot; d->old_zroot = *zroot;
lnum = d->old_zroot.lnum;
lnum = c->old_zroot.lnum; offs = d->old_zroot.offs;
offs = c->old_zroot.offs; len = d->old_zroot.len;
len = c->old_zroot.len;
idx = kmalloc(c->max_idx_node_sz, GFP_NOFS); idx = kmalloc(c->max_idx_node_sz, GFP_NOFS);
if (!idx) if (!idx)
@ -485,8 +485,8 @@ int dbg_old_index_check_init(struct ubifs_info *c, struct ubifs_zbranch *zroot)
if (err) if (err)
goto out; goto out;
c->old_zroot_level = le16_to_cpu(idx->level); d->old_zroot_level = le16_to_cpu(idx->level);
c->old_zroot_sqnum = le64_to_cpu(idx->ch.sqnum); d->old_zroot_sqnum = le64_to_cpu(idx->ch.sqnum);
out: out:
kfree(idx); kfree(idx);
return err; return err;
@ -509,6 +509,7 @@ int dbg_check_old_index(struct ubifs_info *c, struct ubifs_zbranch *zroot)
{ {
int lnum, offs, len, err = 0, uninitialized_var(last_level), child_cnt; int lnum, offs, len, err = 0, uninitialized_var(last_level), child_cnt;
int first = 1, iip; int first = 1, iip;
struct ubifs_debug_info *d = c->dbg;
union ubifs_key lower_key, upper_key, l_key, u_key; union ubifs_key lower_key, upper_key, l_key, u_key;
unsigned long long uninitialized_var(last_sqnum); unsigned long long uninitialized_var(last_sqnum);
struct ubifs_idx_node *idx; struct ubifs_idx_node *idx;
@ -525,9 +526,9 @@ int dbg_check_old_index(struct ubifs_info *c, struct ubifs_zbranch *zroot)
UBIFS_IDX_NODE_SZ; UBIFS_IDX_NODE_SZ;
/* Start at the old zroot */ /* Start at the old zroot */
lnum = c->old_zroot.lnum; lnum = d->old_zroot.lnum;
offs = c->old_zroot.offs; offs = d->old_zroot.offs;
len = c->old_zroot.len; len = d->old_zroot.len;
iip = 0; iip = 0;
/* /*
@ -560,11 +561,11 @@ int dbg_check_old_index(struct ubifs_info *c, struct ubifs_zbranch *zroot)
if (first) { if (first) {
first = 0; first = 0;
/* Check root level and sqnum */ /* Check root level and sqnum */
if (le16_to_cpu(idx->level) != c->old_zroot_level) { if (le16_to_cpu(idx->level) != d->old_zroot_level) {
err = 2; err = 2;
goto out_dump; goto out_dump;
} }
if (le64_to_cpu(idx->ch.sqnum) != c->old_zroot_sqnum) { if (le64_to_cpu(idx->ch.sqnum) != d->old_zroot_sqnum) {
err = 3; err = 3;
goto out_dump; goto out_dump;
} }

71
fs/ubifs/debug.c
View file

@ -705,7 +705,7 @@ void dbg_dump_leb(const struct ubifs_info *c, int lnum)
printk(KERN_DEBUG "(pid %d) Dumping LEB %d\n", current->pid, lnum); printk(KERN_DEBUG "(pid %d) Dumping LEB %d\n", current->pid, lnum);
sleb = ubifs_scan(c, lnum, 0, c->dbg_buf); sleb = ubifs_scan(c, lnum, 0, c->dbg->buf);
if (IS_ERR(sleb)) { if (IS_ERR(sleb)) {
ubifs_err("scan error %d", (int)PTR_ERR(sleb)); ubifs_err("scan error %d", (int)PTR_ERR(sleb));
return; return;
@ -2097,7 +2097,7 @@ static int simple_rand(void)
return (next >> 16) & 32767; return (next >> 16) & 32767;
} }
void dbg_failure_mode_registration(struct ubifs_info *c) static void failure_mode_init(struct ubifs_info *c)
{ {
struct failure_mode_info *fmi; struct failure_mode_info *fmi;
@ -2112,7 +2112,7 @@ void dbg_failure_mode_registration(struct ubifs_info *c)
spin_unlock(&fmi_lock); spin_unlock(&fmi_lock);
} }
void dbg_failure_mode_deregistration(struct ubifs_info *c) static void failure_mode_exit(struct ubifs_info *c)
{ {
struct failure_mode_info *fmi, *tmp; struct failure_mode_info *fmi, *tmp;
@ -2146,42 +2146,44 @@ static int in_failure_mode(struct ubi_volume_desc *desc)
struct ubifs_info *c = dbg_find_info(desc); struct ubifs_info *c = dbg_find_info(desc);
if (c && dbg_failure_mode) if (c && dbg_failure_mode)
return c->failure_mode; return c->dbg->failure_mode;
return 0; return 0;
} }
static int do_fail(struct ubi_volume_desc *desc, int lnum, int write) static int do_fail(struct ubi_volume_desc *desc, int lnum, int write)
{ {
struct ubifs_info *c = dbg_find_info(desc); struct ubifs_info *c = dbg_find_info(desc);
struct ubifs_debug_info *d;
if (!c || !dbg_failure_mode) if (!c || !dbg_failure_mode)
return 0; return 0;
if (c->failure_mode) d = c->dbg;
if (d->failure_mode)
return 1; return 1;
if (!c->fail_cnt) { if (!d->fail_cnt) {
/* First call - decide delay to failure */ /* First call - decide delay to failure */
if (chance(1, 2)) { if (chance(1, 2)) {
unsigned int delay = 1 << (simple_rand() >> 11); unsigned int delay = 1 << (simple_rand() >> 11);
if (chance(1, 2)) { if (chance(1, 2)) {
c->fail_delay = 1; d->fail_delay = 1;
c->fail_timeout = jiffies + d->fail_timeout = jiffies +
msecs_to_jiffies(delay); msecs_to_jiffies(delay);
dbg_rcvry("failing after %ums", delay); dbg_rcvry("failing after %ums", delay);
} else { } else {
c->fail_delay = 2; d->fail_delay = 2;
c->fail_cnt_max = delay; d->fail_cnt_max = delay;
dbg_rcvry("failing after %u calls", delay); dbg_rcvry("failing after %u calls", delay);
} }
} }
c->fail_cnt += 1; d->fail_cnt += 1;
} }
/* Determine if failure delay has expired */ /* Determine if failure delay has expired */
if (c->fail_delay == 1) { if (d->fail_delay == 1) {
if (time_before(jiffies, c->fail_timeout)) if (time_before(jiffies, d->fail_timeout))
return 0; return 0;
} else if (c->fail_delay == 2) } else if (d->fail_delay == 2)
if (c->fail_cnt++ < c->fail_cnt_max) if (d->fail_cnt++ < d->fail_cnt_max)
return 0; return 0;
if (lnum == UBIFS_SB_LNUM) { if (lnum == UBIFS_SB_LNUM) {
if (write) { if (write) {
@ -2239,7 +2241,7 @@ static int do_fail(struct ubi_volume_desc *desc, int lnum, int write)
dbg_rcvry("failing in bud LEB %d commit not running", lnum); dbg_rcvry("failing in bud LEB %d commit not running", lnum);
} }
ubifs_err("*** SETTING FAILURE MODE ON (LEB %d) ***", lnum); ubifs_err("*** SETTING FAILURE MODE ON (LEB %d) ***", lnum);
c->failure_mode = 1; d->failure_mode = 1;
dump_stack(); dump_stack();
return 1; return 1;
} }
@ -2344,4 +2346,41 @@ int dbg_leb_map(struct ubi_volume_desc *desc, int lnum, int dtype)
return 0; return 0;
} }
/**
* ubifs_debugging_init - initialize UBIFS debugging.
* @c: UBIFS file-system description object
*
* This function initializes debugging-related data for the file system.
* Returns zero in case of success and a negative error code in case of
* failure.
*/
int ubifs_debugging_init(struct ubifs_info *c)
{
c->dbg = kzalloc(sizeof(struct ubifs_debug_info), GFP_KERNEL);
if (!c->dbg)
return -ENOMEM;
c->dbg->buf = vmalloc(c->leb_size);
if (!c->dbg->buf)
goto out;
failure_mode_init(c);
return 0;
out:
kfree(c->dbg);
return -ENOMEM;
}
/**
* ubifs_debugging_exit - free debugging data.
* @c: UBIFS file-system description object
*/
void ubifs_debugging_exit(struct ubifs_info *c)
{
failure_mode_exit(c);
vfree(c->dbg->buf);
kfree(c->dbg);
}
#endif /* CONFIG_UBIFS_FS_DEBUG */ #endif /* CONFIG_UBIFS_FS_DEBUG */

51
fs/ubifs/debug.h
View file

@ -25,7 +25,43 @@
#ifdef CONFIG_UBIFS_FS_DEBUG #ifdef CONFIG_UBIFS_FS_DEBUG
#define UBIFS_DBG(op) op /**
* ubifs_debug_info - per-FS debugging information.
* @buf: a buffer of LEB size, used for various purposes
* @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
* @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
* @chk_lpt_lebs: used by LPT tree size checker
* @new_nhead_offs: used by LPT tree size checker
* @new_ihead_lnum: used by debugging to check ihead_lnum
* @new_ihead_offs: used by debugging to check ihead_offs
*/
struct ubifs_debug_info {
void *buf;
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;
long long chk_lpt_sz;
long long chk_lpt_sz2;
long long chk_lpt_wastage;
int chk_lpt_lebs;
int new_nhead_offs;
int new_ihead_lnum;
int new_ihead_offs;
};
#define ubifs_assert(expr) do { \ #define ubifs_assert(expr) do { \
if (unlikely(!(expr))) { \ if (unlikely(!(expr))) { \
@ -211,6 +247,9 @@ extern unsigned int ubifs_msg_flags;
extern unsigned int ubifs_chk_flags; extern unsigned int ubifs_chk_flags;
extern unsigned int ubifs_tst_flags; extern unsigned int ubifs_tst_flags;
int ubifs_debugging_init(struct ubifs_info *c);
void ubifs_debugging_exit(struct ubifs_info *c);
/* Dump functions */ /* Dump functions */
const char *dbg_ntype(int type); const char *dbg_ntype(int type);
@ -274,9 +313,6 @@ int dbg_force_in_the_gaps(void);
#define dbg_failure_mode (ubifs_tst_flags & UBIFS_TST_RCVRY) #define dbg_failure_mode (ubifs_tst_flags & UBIFS_TST_RCVRY)
void dbg_failure_mode_registration(struct ubifs_info *c);
void dbg_failure_mode_deregistration(struct ubifs_info *c);
#ifndef UBIFS_DBG_PRESERVE_UBI #ifndef UBIFS_DBG_PRESERVE_UBI
#define ubi_leb_read dbg_leb_read #define ubi_leb_read dbg_leb_read
@ -320,8 +356,6 @@ static inline int dbg_change(struct ubi_volume_desc *desc, int lnum,
#else /* !CONFIG_UBIFS_FS_DEBUG */ #else /* !CONFIG_UBIFS_FS_DEBUG */
#define UBIFS_DBG(op)
/* Use "if (0)" to make compiler check arguments even if debugging is off */ /* Use "if (0)" to make compiler check arguments even if debugging is off */
#define ubifs_assert(expr) do { \ #define ubifs_assert(expr) do { \
if (0 && (expr)) \ if (0 && (expr)) \
@ -360,6 +394,9 @@ static inline int dbg_change(struct ubi_volume_desc *desc, int lnum,
#define DBGKEY(key) ((char *)(key)) #define DBGKEY(key) ((char *)(key))
#define DBGKEY1(key) ((char *)(key)) #define DBGKEY1(key) ((char *)(key))
#define ubifs_debugging_init(c) 0
#define ubifs_debugging_exit(c) ({})
#define dbg_ntype(type) "" #define dbg_ntype(type) ""
#define dbg_cstate(cmt_state) "" #define dbg_cstate(cmt_state) ""
#define dbg_get_key_dump(c, key) ({}) #define dbg_get_key_dump(c, key) ({})
@ -396,8 +433,6 @@ static inline int dbg_change(struct ubi_volume_desc *desc, int lnum,
#define dbg_force_in_the_gaps_enabled 0 #define dbg_force_in_the_gaps_enabled 0
#define dbg_force_in_the_gaps() 0 #define dbg_force_in_the_gaps() 0
#define dbg_failure_mode 0 #define dbg_failure_mode 0
#define dbg_failure_mode_registration(c) ({})
#define dbg_failure_mode_deregistration(c) ({})
#endif /* !CONFIG_UBIFS_FS_DEBUG */ #endif /* !CONFIG_UBIFS_FS_DEBUG */

2
fs/ubifs/lprops.c
View file

@ -1088,7 +1088,7 @@ static int scan_check_cb(struct ubifs_info *c,
} }
} }
sleb = ubifs_scan(c, lnum, 0, c->dbg_buf); sleb = ubifs_scan(c, lnum, 0, c->dbg->buf);
if (IS_ERR(sleb)) { if (IS_ERR(sleb)) {
/* /*
* After an unclean unmount, empty and freeable LEBs * After an unclean unmount, empty and freeable LEBs

55
fs/ubifs/lpt_commit.c
View file

@ -1602,7 +1602,7 @@ static int dbg_check_ltab_lnum(struct ubifs_info *c, int lnum)
{ {
int err, len = c->leb_size, dirty = 0, node_type, node_num, node_len; int err, len = c->leb_size, dirty = 0, node_type, node_num, node_len;
int ret; int ret;
void *buf = c->dbg_buf; void *buf = c->dbg->buf;
dbg_lp("LEB %d", lnum); dbg_lp("LEB %d", lnum);
err = ubi_read(c->ubi, lnum, buf, 0, c->leb_size); err = ubi_read(c->ubi, lnum, buf, 0, c->leb_size);
@ -1731,15 +1731,16 @@ 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_chk_lpt_sz(struct ubifs_info *c, int action, int len)
{ {
struct ubifs_debug_info *d = c->dbg;
long long chk_lpt_sz, lpt_sz; long long chk_lpt_sz, lpt_sz;
int err = 0; int err = 0;
switch (action) { switch (action) {
case 0: case 0:
c->chk_lpt_sz = 0; d->chk_lpt_sz = 0;
c->chk_lpt_sz2 = 0; d->chk_lpt_sz2 = 0;
c->chk_lpt_lebs = 0; d->chk_lpt_lebs = 0;
c->chk_lpt_wastage = 0; d->chk_lpt_wastage = 0;
if (c->dirty_pn_cnt > c->pnode_cnt) { if (c->dirty_pn_cnt > c->pnode_cnt) {
dbg_err("dirty pnodes %d exceed max %d", dbg_err("dirty pnodes %d exceed max %d",
c->dirty_pn_cnt, c->pnode_cnt); c->dirty_pn_cnt, c->pnode_cnt);
@ -1752,35 +1753,35 @@ int dbg_chk_lpt_sz(struct ubifs_info *c, int action, int len)
} }
return err; return err;
case 1: case 1:
c->chk_lpt_sz += len; d->chk_lpt_sz += len;
return 0; return 0;
case 2: case 2:
c->chk_lpt_sz += len; d->chk_lpt_sz += len;
c->chk_lpt_wastage += len; d->chk_lpt_wastage += len;
c->chk_lpt_lebs += 1; d->chk_lpt_lebs += 1;
return 0; return 0;
case 3: case 3:
chk_lpt_sz = c->leb_size; chk_lpt_sz = c->leb_size;
chk_lpt_sz *= c->chk_lpt_lebs; chk_lpt_sz *= d->chk_lpt_lebs;
chk_lpt_sz += len - c->nhead_offs; chk_lpt_sz += len - c->nhead_offs;
if (c->chk_lpt_sz != chk_lpt_sz) { if (d->chk_lpt_sz != chk_lpt_sz) {
dbg_err("LPT wrote %lld but space used was %lld", dbg_err("LPT wrote %lld but space used was %lld",
c->chk_lpt_sz, chk_lpt_sz); d->chk_lpt_sz, chk_lpt_sz);
err = -EINVAL; err = -EINVAL;
} }
if (c->chk_lpt_sz > c->lpt_sz) { if (d->chk_lpt_sz > c->lpt_sz) {
dbg_err("LPT wrote %lld but lpt_sz is %lld", dbg_err("LPT wrote %lld but lpt_sz is %lld",
c->chk_lpt_sz, c->lpt_sz); d->chk_lpt_sz, c->lpt_sz);
err = -EINVAL; err = -EINVAL;
} }
if (c->chk_lpt_sz2 && c->chk_lpt_sz != c->chk_lpt_sz2) { if (d->chk_lpt_sz2 && d->chk_lpt_sz != d->chk_lpt_sz2) {
dbg_err("LPT layout size %lld but wrote %lld", dbg_err("LPT layout size %lld but wrote %lld",
c->chk_lpt_sz, c->chk_lpt_sz2); d->chk_lpt_sz, d->chk_lpt_sz2);
err = -EINVAL; err = -EINVAL;
} }
if (c->chk_lpt_sz2 && c->new_nhead_offs != len) { if (d->chk_lpt_sz2 && d->new_nhead_offs != len) {
dbg_err("LPT new nhead offs: expected %d was %d", dbg_err("LPT new nhead offs: expected %d was %d",
c->new_nhead_offs, len); d->new_nhead_offs, len);
err = -EINVAL; err = -EINVAL;
} }
lpt_sz = (long long)c->pnode_cnt * c->pnode_sz; lpt_sz = (long long)c->pnode_cnt * c->pnode_sz;
@ -1788,22 +1789,22 @@ int dbg_chk_lpt_sz(struct ubifs_info *c, int action, int len)
lpt_sz += c->ltab_sz; lpt_sz += c->ltab_sz;
if (c->big_lpt) if (c->big_lpt)
lpt_sz += c->lsave_sz; lpt_sz += c->lsave_sz;
if (c->chk_lpt_sz - c->chk_lpt_wastage > lpt_sz) { if (d->chk_lpt_sz - d->chk_lpt_wastage > lpt_sz) {
dbg_err("LPT chk_lpt_sz %lld + waste %lld exceeds %lld", dbg_err("LPT chk_lpt_sz %lld + waste %lld exceeds %lld",
c->chk_lpt_sz, c->chk_lpt_wastage, lpt_sz); d->chk_lpt_sz, d->chk_lpt_wastage, lpt_sz);
err = -EINVAL; err = -EINVAL;
} }
if (err) if (err)
dbg_dump_lpt_info(c); dbg_dump_lpt_info(c);
c->chk_lpt_sz2 = c->chk_lpt_sz; d->chk_lpt_sz2 = d->chk_lpt_sz;
c->chk_lpt_sz = 0; d->chk_lpt_sz = 0;
c->chk_lpt_wastage = 0; d->chk_lpt_wastage = 0;
c->chk_lpt_lebs = 0; d->chk_lpt_lebs = 0;
c->new_nhead_offs = len; d->new_nhead_offs = len;
return err; return err;
case 4: case 4:
c->chk_lpt_sz += len; d->chk_lpt_sz += len;
c->chk_lpt_wastage += len; d->chk_lpt_wastage += len;
return 0; return 0;
default: default:
return -EINVAL; return -EINVAL;

2
fs/ubifs/orphan.c
View file

@ -899,7 +899,7 @@ static int dbg_scan_orphans(struct ubifs_info *c, struct check_info *ci)
for (lnum = c->orph_first; lnum <= c->orph_last; lnum++) { for (lnum = c->orph_first; lnum <= c->orph_last; lnum++) {
struct ubifs_scan_leb *sleb; struct ubifs_scan_leb *sleb;
sleb = ubifs_scan(c, lnum, 0, c->dbg_buf); sleb = ubifs_scan(c, lnum, 0, c->dbg->buf);
if (IS_ERR(sleb)) { if (IS_ERR(sleb)) {
err = PTR_ERR(sleb); err = PTR_ERR(sleb);
break; break;

22
fs/ubifs/super.c
View file

@ -1069,11 +1069,9 @@ static int mount_ubifs(struct ubifs_info *c)
if (err) if (err)
return err; return err;
#ifdef CONFIG_UBIFS_FS_DEBUG err = ubifs_debugging_init(c);
c->dbg_buf = vmalloc(c->leb_size); if (err)
if (!c->dbg_buf) return err;
return -ENOMEM;
#endif
err = check_volume_empty(c); err = check_volume_empty(c);
if (err) if (err)
@ -1139,18 +1137,16 @@ static int mount_ubifs(struct ubifs_info *c)
goto out_free; goto out_free;
} }
dbg_failure_mode_registration(c);
err = init_constants_late(c); err = init_constants_late(c);
if (err) if (err)
goto out_dereg; goto out_free;
sz = ALIGN(c->max_idx_node_sz, c->min_io_size); sz = ALIGN(c->max_idx_node_sz, c->min_io_size);
sz = ALIGN(sz + c->max_idx_node_sz, c->min_io_size); sz = ALIGN(sz + c->max_idx_node_sz, c->min_io_size);
c->cbuf = kmalloc(sz, GFP_NOFS); c->cbuf = kmalloc(sz, GFP_NOFS);
if (!c->cbuf) { if (!c->cbuf) {
err = -ENOMEM; err = -ENOMEM;
goto out_dereg; goto out_free;
} }
sprintf(c->bgt_name, BGT_NAME_PATTERN, c->vi.ubi_num, c->vi.vol_id); sprintf(c->bgt_name, BGT_NAME_PATTERN, c->vi.ubi_num, c->vi.vol_id);
@ -1350,14 +1346,12 @@ out_wbufs:
free_wbufs(c); free_wbufs(c);
out_cbuf: out_cbuf:
kfree(c->cbuf); kfree(c->cbuf);
out_dereg:
dbg_failure_mode_deregistration(c);
out_free: out_free:
kfree(c->bu.buf); kfree(c->bu.buf);
vfree(c->ileb_buf); vfree(c->ileb_buf);
vfree(c->sbuf); vfree(c->sbuf);
kfree(c->bottom_up_buf); kfree(c->bottom_up_buf);
UBIFS_DBG(vfree(c->dbg_buf)); ubifs_debugging_exit(c);
return err; return err;
} }
@ -1394,8 +1388,7 @@ static void ubifs_umount(struct ubifs_info *c)
vfree(c->ileb_buf); vfree(c->ileb_buf);
vfree(c->sbuf); vfree(c->sbuf);
kfree(c->bottom_up_buf); kfree(c->bottom_up_buf);
UBIFS_DBG(vfree(c->dbg_buf)); ubifs_debugging_exit(c);
dbg_failure_mode_deregistration(c);
} }
/** /**
@ -1879,7 +1872,6 @@ static int ubifs_fill_super(struct super_block *sb, void *data, int silent)
goto out_iput; goto out_iput;
mutex_unlock(&c->umount_mutex); mutex_unlock(&c->umount_mutex);
return 0; return 0;
out_iput: out_iput:

7
fs/ubifs/tnc_commit.c
View file

@ -553,8 +553,8 @@ static int layout_in_empty_space(struct ubifs_info *c)
} }
#ifdef CONFIG_UBIFS_FS_DEBUG #ifdef CONFIG_UBIFS_FS_DEBUG
c->new_ihead_lnum = lnum; c->dbg->new_ihead_lnum = lnum;
c->new_ihead_offs = buf_offs; c->dbg->new_ihead_offs = buf_offs;
#endif #endif
return 0; return 0;
@ -1002,7 +1002,8 @@ static int write_index(struct ubifs_info *c)
} }
#ifdef CONFIG_UBIFS_FS_DEBUG #ifdef CONFIG_UBIFS_FS_DEBUG
if (lnum != c->new_ihead_lnum || buf_offs != c->new_ihead_offs) { if (lnum != c->dbg->new_ihead_lnum ||
buf_offs != c->dbg->new_ihead_offs) {
ubifs_err("inconsistent ihead"); ubifs_err("inconsistent ihead");
return -EINVAL; return -EINVAL;
} }

34
fs/ubifs/ubifs.h
View file

@ -910,6 +910,8 @@ struct ubifs_mount_opts {
unsigned int compr_type:2; unsigned int compr_type:2;
}; };
struct ubifs_debug_info;
/** /**
* struct ubifs_info - UBIFS file-system description data structure * struct ubifs_info - UBIFS file-system description data structure
* (per-superblock). * (per-superblock).
@ -972,8 +974,6 @@ struct ubifs_mount_opts {
* @ileb_nxt: next pre-allocated index LEBs * @ileb_nxt: next pre-allocated index LEBs
* @old_idx: tree of index nodes obsoleted since the last commit start * @old_idx: tree of index nodes obsoleted since the last commit start
* @bottom_up_buf: a buffer which is used by 'dirty_cow_bottom_up()' in tnc.c * @bottom_up_buf: a buffer which is used by 'dirty_cow_bottom_up()' in tnc.c
* @new_ihead_lnum: used by debugging to check ihead_lnum
* @new_ihead_offs: used by debugging to check ihead_offs
* *
* @mst_node: master node * @mst_node: master node
* @mst_offs: offset of valid master node * @mst_offs: offset of valid master node
@ -1157,15 +1157,7 @@ struct ubifs_mount_opts {
* @always_chk_crc: always check CRCs (while mounting and remounting rw) * @always_chk_crc: always check CRCs (while mounting and remounting rw)
* @mount_opts: UBIFS-specific mount options * @mount_opts: UBIFS-specific mount options
* *
* @dbg_buf: a buffer of LEB size used for debugging purposes * @dbg: debugging-related 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
*/ */
struct ubifs_info { struct ubifs_info {
struct super_block *vfs_sb; struct super_block *vfs_sb;
@ -1221,10 +1213,6 @@ struct ubifs_info {
int ileb_nxt; int ileb_nxt;
struct rb_root old_idx; struct rb_root old_idx;
int *bottom_up_buf; int *bottom_up_buf;
#ifdef CONFIG_UBIFS_FS_DEBUG
int new_ihead_lnum;
int new_ihead_offs;
#endif
struct ubifs_mst_node *mst_node; struct ubifs_mst_node *mst_node;
int mst_offs; int mst_offs;
@ -1399,21 +1387,7 @@ struct ubifs_info {
struct ubifs_mount_opts mount_opts; struct ubifs_mount_opts mount_opts;
#ifdef CONFIG_UBIFS_FS_DEBUG #ifdef CONFIG_UBIFS_FS_DEBUG
void *dbg_buf; struct ubifs_debug_info *dbg;
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;
long long chk_lpt_sz;
long long chk_lpt_sz2;
long long chk_lpt_wastage;
int chk_lpt_lebs;
int new_nhead_lnum;
int new_nhead_offs;
#endif #endif
}; };