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

Commit eadc3875 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

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

* 'linux-next' of git://git.infradead.org/ubi-2.6:
  UBI: clarify the volume notification types' doc
  UBI: remove dead code
  UBI: dump stack when switching to R/O mode
  UBI: fix oops in error path
  UBI: switch debugging tests knobs to debugfs
  UBI: make it possible to use struct ubi_device in debug.h
  UBI: prepare debugging stuff to further debugfs conversion
  UBI: use debugfs for the extra checks knobs
  UBI: change the interface of a debugging check function
parents 59a7ac12 01dc9cc3

drivers/mtd/ubi/build.c

+26 −2
Original line number Diff line number Diff line
@@ -953,10 +953,14 @@ int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num, int vid_hdr_offset) 
	if (!ubi->peb_buf2)

		goto out_free;



	err = ubi_debugging_init_dev(ubi);

	if (err)

		goto out_free;



	err = attach_by_scanning(ubi);

	if (err) {

		dbg_err("failed to attach by scanning, error %d", err);

		goto out_free;

		goto out_debugging;

	}



	if (ubi->autoresize_vol_id != -1) {
@@ -969,12 +973,16 @@ int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num, int vid_hdr_offset) 
	if (err)

		goto out_detach;



	err = ubi_debugfs_init_dev(ubi);

	if (err)

		goto out_uif;



	ubi->bgt_thread = kthread_create(ubi_thread, ubi, ubi->bgt_name);

	if (IS_ERR(ubi->bgt_thread)) {

		err = PTR_ERR(ubi->bgt_thread);

		ubi_err("cannot spawn \"%s\", error %d", ubi->bgt_name,

			err);

		goto out_uif;

		goto out_debugfs;

	}



	ubi_msg("attached mtd%d to ubi%d", mtd->index, ubi_num);
@@ -1008,12 +1016,18 @@ int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num, int vid_hdr_offset) 
	ubi_notify_all(ubi, UBI_VOLUME_ADDED, NULL);

	return ubi_num;



out_debugfs:

	ubi_debugfs_exit_dev(ubi);

out_uif:

	get_device(&ubi->dev);

	ubi_assert(ref);

	uif_close(ubi);

out_detach:

	ubi_wl_close(ubi);

	free_internal_volumes(ubi);

	vfree(ubi->vtbl);

out_debugging:

	ubi_debugging_exit_dev(ubi);

out_free:

	vfree(ubi->peb_buf1);

	vfree(ubi->peb_buf2);
@@ -1080,11 +1094,13 @@ int ubi_detach_mtd_dev(int ubi_num, int anyway) 
	 */

	get_device(&ubi->dev);



	ubi_debugfs_exit_dev(ubi);

	uif_close(ubi);

	ubi_wl_close(ubi);

	free_internal_volumes(ubi);

	vfree(ubi->vtbl);

	put_mtd_device(ubi->mtd);

	ubi_debugging_exit_dev(ubi);

	vfree(ubi->peb_buf1);

	vfree(ubi->peb_buf2);

	ubi_msg("mtd%d is detached from ubi%d", ubi->mtd->index, ubi->ubi_num);
@@ -1199,6 +1215,11 @@ static int __init ubi_init(void) 
	if (!ubi_wl_entry_slab)

		goto out_dev_unreg;



	err = ubi_debugfs_init();

	if (err)

		goto out_slab;





	/* Attach MTD devices */

	for (i = 0; i < mtd_devs; i++) {

		struct mtd_dev_param *p = &mtd_dev_param[i];
@@ -1247,6 +1268,8 @@ out_detach: 
			ubi_detach_mtd_dev(ubi_devices[k]->ubi_num, 1);

			mutex_unlock(&ubi_devices_mutex);

		}

	ubi_debugfs_exit();

out_slab:

	kmem_cache_destroy(ubi_wl_entry_slab);

out_dev_unreg:

	misc_deregister(&ubi_ctrl_cdev);
@@ -1270,6 +1293,7 @@ static void __exit ubi_exit(void) 
			ubi_detach_mtd_dev(ubi_devices[i]->ubi_num, 1);

			mutex_unlock(&ubi_devices_mutex);

		}

	ubi_debugfs_exit();

	kmem_cache_destroy(ubi_wl_entry_slab);

	misc_deregister(&ubi_ctrl_cdev);

	class_remove_file(ubi_class, &ubi_version);

drivers/mtd/ubi/debug.c

+259 −10
Original line number Diff line number Diff line
@@ -27,17 +27,9 @@ 
#ifdef CONFIG_MTD_UBI_DEBUG



#include "ubi.h"

#include <linux/debugfs.h>

#include <linux/uaccess.h>

#include <linux/module.h>

#include <linux/moduleparam.h>



unsigned int ubi_chk_flags;

unsigned int ubi_tst_flags;



module_param_named(debug_chks, ubi_chk_flags, uint, S_IRUGO | S_IWUSR);

module_param_named(debug_tsts, ubi_chk_flags, uint, S_IRUGO | S_IWUSR);



MODULE_PARM_DESC(debug_chks, "Debug check flags");

MODULE_PARM_DESC(debug_tsts, "Debug special test flags");



/**

 * ubi_dbg_dump_ec_hdr - dump an erase counter header.
@@ -239,4 +231,261 @@ out: 
	return;

}



/**

 * ubi_debugging_init_dev - initialize debugging for an UBI device.

 * @ubi: UBI device description object

 *

 * This function initializes debugging-related data for UBI device @ubi.

 * Returns zero in case of success and a negative error code in case of

 * failure.

 */

int ubi_debugging_init_dev(struct ubi_device *ubi)

{

	ubi->dbg = kzalloc(sizeof(struct ubi_debug_info), GFP_KERNEL);

	if (!ubi->dbg)

		return -ENOMEM;



	return 0;

}



/**

 * ubi_debugging_exit_dev - free debugging data for an UBI device.

 * @ubi: UBI device description object

 */

void ubi_debugging_exit_dev(struct ubi_device *ubi)

{

	kfree(ubi->dbg);

}



/*

 * Root directory for UBI stuff in debugfs. Contains sub-directories which

 * contain the stuff specific to particular UBI devices.

 */

static struct dentry *dfs_rootdir;



/**

 * ubi_debugfs_init - create UBI debugfs directory.

 *

 * Create UBI debugfs directory. Returns zero in case of success and a negative

 * error code in case of failure.

 */

int ubi_debugfs_init(void)

{

	dfs_rootdir = debugfs_create_dir("ubi", NULL);

	if (IS_ERR_OR_NULL(dfs_rootdir)) {

		int err = dfs_rootdir ? -ENODEV : PTR_ERR(dfs_rootdir);



		ubi_err("cannot create \"ubi\" debugfs directory, error %d\n",

			err);

		return err;

	}



	return 0;

}



/**

 * ubi_debugfs_exit - remove UBI debugfs directory.

 */

void ubi_debugfs_exit(void)

{

	debugfs_remove(dfs_rootdir);

}



/* Read an UBI debugfs file */

static ssize_t dfs_file_read(struct file *file, char __user *user_buf,

			     size_t count, loff_t *ppos)

{

	unsigned long ubi_num = (unsigned long)file->private_data;

	struct dentry *dent = file->f_path.dentry;

	struct ubi_device *ubi;

	struct ubi_debug_info *d;

	char buf[3];

	int val;



	ubi = ubi_get_device(ubi_num);

	if (!ubi)

		return -ENODEV;

	d = ubi->dbg;



	if (dent == d->dfs_chk_gen)

		val = d->chk_gen;

	else if (dent == d->dfs_chk_io)

		val = d->chk_io;

	else if (dent == d->dfs_disable_bgt)

		val = d->disable_bgt;

	else if (dent == d->dfs_emulate_bitflips)

		val = d->emulate_bitflips;

	else if (dent == d->dfs_emulate_io_failures)

		val = d->emulate_io_failures;

	else {

		count = -EINVAL;

		goto out;

	}



	if (val)

		buf[0] = '1';

	else

		buf[0] = '0';

	buf[1] = '\n';

	buf[2] = 0x00;



	count = simple_read_from_buffer(user_buf, count, ppos, buf, 2);



out:

	ubi_put_device(ubi);

	return count;

}



/* Write an UBI debugfs file */

static ssize_t dfs_file_write(struct file *file, const char __user *user_buf,

			      size_t count, loff_t *ppos)

{

	unsigned long ubi_num = (unsigned long)file->private_data;

	struct dentry *dent = file->f_path.dentry;

	struct ubi_device *ubi;

	struct ubi_debug_info *d;

	size_t buf_size;

	char buf[8];

	int val;



	ubi = ubi_get_device(ubi_num);

	if (!ubi)

		return -ENODEV;

	d = ubi->dbg;



	buf_size = min_t(size_t, count, (sizeof(buf) - 1));

	if (copy_from_user(buf, user_buf, buf_size)) {

		count = -EFAULT;

		goto out;

	}



	if (buf[0] == '1')

		val = 1;

	else if (buf[0] == '0')

		val = 0;

	else {

		count = -EINVAL;

		goto out;

	}



	if (dent == d->dfs_chk_gen)

		d->chk_gen = val;

	else if (dent == d->dfs_chk_io)

		d->chk_io = val;

	else if (dent == d->dfs_disable_bgt)

		d->disable_bgt = val;

	else if (dent == d->dfs_emulate_bitflips)

		d->emulate_bitflips = val;

	else if (dent == d->dfs_emulate_io_failures)

		d->emulate_io_failures = val;

	else

		count = -EINVAL;



out:

	ubi_put_device(ubi);

	return count;

}



static int default_open(struct inode *inode, struct file *file)

{

	if (inode->i_private)

		file->private_data = inode->i_private;



	return 0;

}



/* File operations for all UBI debugfs files */

static const struct file_operations dfs_fops = {

	.read   = dfs_file_read,

	.write  = dfs_file_write,

	.open   = default_open,

	.llseek = no_llseek,

	.owner  = THIS_MODULE,

};



/**

 * ubi_debugfs_init_dev - initialize debugfs for an UBI device.

 * @ubi: UBI device description object

 *

 * This function creates all debugfs files for UBI device @ubi. Returns zero in

 * case of success and a negative error code in case of failure.

 */

int ubi_debugfs_init_dev(struct ubi_device *ubi)

{

	int err, n;

	unsigned long ubi_num = ubi->ubi_num;

	const char *fname;

	struct dentry *dent;

	struct ubi_debug_info *d = ubi->dbg;



	n = snprintf(d->dfs_dir_name, UBI_DFS_DIR_LEN + 1, UBI_DFS_DIR_NAME,

		     ubi->ubi_num);

	if (n == UBI_DFS_DIR_LEN) {

		/* The array size is too small */

		fname = UBI_DFS_DIR_NAME;

		dent = ERR_PTR(-EINVAL);

		goto out;

	}



	fname = d->dfs_dir_name;

	dent = debugfs_create_dir(fname, dfs_rootdir);

	if (IS_ERR_OR_NULL(dent))

		goto out;

	d->dfs_dir = dent;



	fname = "chk_gen";

	dent = debugfs_create_file(fname, S_IWUSR, d->dfs_dir, (void *)ubi_num,

				   &dfs_fops);

	if (IS_ERR_OR_NULL(dent))

		goto out_remove;

	d->dfs_chk_gen = dent;



	fname = "chk_io";

	dent = debugfs_create_file(fname, S_IWUSR, d->dfs_dir, (void *)ubi_num,

				   &dfs_fops);

	if (IS_ERR_OR_NULL(dent))

		goto out_remove;

	d->dfs_chk_io = dent;



	fname = "tst_disable_bgt";

	dent = debugfs_create_file(fname, S_IWUSR, d->dfs_dir, (void *)ubi_num,

				   &dfs_fops);

	if (IS_ERR_OR_NULL(dent))

		goto out_remove;

	d->dfs_disable_bgt = dent;



	fname = "tst_emulate_bitflips";

	dent = debugfs_create_file(fname, S_IWUSR, d->dfs_dir, (void *)ubi_num,

				   &dfs_fops);

	if (IS_ERR_OR_NULL(dent))

		goto out_remove;

	d->dfs_emulate_bitflips = dent;



	fname = "tst_emulate_io_failures";

	dent = debugfs_create_file(fname, S_IWUSR, d->dfs_dir, (void *)ubi_num,

				   &dfs_fops);

	if (IS_ERR_OR_NULL(dent))

		goto out_remove;

	d->dfs_emulate_io_failures = dent;



	return 0;



out_remove:

	debugfs_remove_recursive(d->dfs_dir);

out:

	err = dent ? PTR_ERR(dent) : -ENODEV;

	ubi_err("cannot create \"%s\" debugfs file or directory, error %d\n",

		fname, err);

	return err;

}



/**

 * dbg_debug_exit_dev - free all debugfs files corresponding to device @ubi

 * @ubi: UBI device description object

 */

void ubi_debugfs_exit_dev(struct ubi_device *ubi)

{

	debugfs_remove_recursive(ubi->dbg->dfs_dir);

}



#endif /* CONFIG_MTD_UBI_DEBUG */

drivers/mtd/ubi/debug.h

+66 −47
Original line number Diff line number Diff line
@@ -21,14 +21,6 @@ 
#ifndef __UBI_DEBUG_H__

#define __UBI_DEBUG_H__



struct ubi_ec_hdr;

struct ubi_vid_hdr;

struct ubi_volume;

struct ubi_vtbl_record;

struct ubi_scan_volume;

struct ubi_scan_leb;

struct ubi_mkvol_req;



#ifdef CONFIG_MTD_UBI_DEBUG

#include <linux/random.h>
@@ -71,86 +63,103 @@ void ubi_dbg_dump_sv(const struct ubi_scan_volume *sv); 
void ubi_dbg_dump_seb(const struct ubi_scan_leb *seb, int type);

void ubi_dbg_dump_mkvol_req(const struct ubi_mkvol_req *req);

void ubi_dbg_dump_flash(struct ubi_device *ubi, int pnum, int offset, int len);



extern unsigned int ubi_chk_flags;



/*

 * Debugging check flags.

 *

 * UBI_CHK_GEN: general checks

 * UBI_CHK_IO: check writes and erases

 */

enum {

	UBI_CHK_GEN = 0x1,

	UBI_CHK_IO  = 0x2,

};



int ubi_dbg_check_all_ff(struct ubi_device *ubi, int pnum, int offset, int len);

int ubi_dbg_check_write(struct ubi_device *ubi, const void *buf, int pnum,

			int offset, int len);



extern unsigned int ubi_tst_flags;

int ubi_debugging_init_dev(struct ubi_device *ubi);

void ubi_debugging_exit_dev(struct ubi_device *ubi);

int ubi_debugfs_init(void);

void ubi_debugfs_exit(void);

int ubi_debugfs_init_dev(struct ubi_device *ubi);

void ubi_debugfs_exit_dev(struct ubi_device *ubi);



/*

 * Special testing flags.

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

 * + 2 for the number plus 1 for the trailing zero byte.

 */

#define UBI_DFS_DIR_NAME "ubi%d"

#define UBI_DFS_DIR_LEN  (3 + 2 + 1)



/**

 * struct ubi_debug_info - debugging information for an UBI device.

 *

 * UBIFS_TST_DISABLE_BGT: disable the background thread

 * UBI_TST_EMULATE_BITFLIPS: emulate bit-flips

 * UBI_TST_EMULATE_WRITE_FAILURES: emulate write failures

 * UBI_TST_EMULATE_ERASE_FAILURES: emulate erase failures

 * @chk_gen: if UBI general extra checks are enabled

 * @chk_io: if UBI I/O extra checks are enabled

 * @disable_bgt: disable the background task for testing purposes

 * @emulate_bitflips: emulate bit-flips for testing purposes

 * @emulate_io_failures: emulate write/erase failures for testing purposes

 * @dfs_dir_name: name of debugfs directory containing files of this UBI device

 * @dfs_dir: direntry object of the UBI device debugfs directory

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

 * @dfs_chk_io: debugfs knob to enable UBI I/O extra checks

 * @dfs_disable_bgt: debugfs knob to disable the background task

 * @dfs_emulate_bitflips: debugfs knob to emulate bit-flips

 * @dfs_emulate_io_failures: debugfs knob to emulate write/erase failures

 */

enum {

	UBI_TST_DISABLE_BGT            = 0x1,

	UBI_TST_EMULATE_BITFLIPS       = 0x2,

	UBI_TST_EMULATE_WRITE_FAILURES = 0x4,

	UBI_TST_EMULATE_ERASE_FAILURES = 0x8,

struct ubi_debug_info {

	unsigned int chk_gen:1;

	unsigned int chk_io:1;

	unsigned int disable_bgt:1;

	unsigned int emulate_bitflips:1;

	unsigned int emulate_io_failures:1;

	char dfs_dir_name[UBI_DFS_DIR_LEN + 1];

	struct dentry *dfs_dir;

	struct dentry *dfs_chk_gen;

	struct dentry *dfs_chk_io;

	struct dentry *dfs_disable_bgt;

	struct dentry *dfs_emulate_bitflips;

	struct dentry *dfs_emulate_io_failures;

};



/**

 * ubi_dbg_is_bgt_disabled - if the background thread is disabled.

 * @ubi: UBI device description object

 *

 * Returns non-zero if the UBI background thread is disabled for testing

 * purposes.

 */

static inline int ubi_dbg_is_bgt_disabled(void)

static inline int ubi_dbg_is_bgt_disabled(const struct ubi_device *ubi)

{

	return ubi_tst_flags & UBI_TST_DISABLE_BGT;

	return ubi->dbg->disable_bgt;

}



/**

 * ubi_dbg_is_bitflip - if it is time to emulate a bit-flip.

 * @ubi: UBI device description object

 *

 * Returns non-zero if a bit-flip should be emulated, otherwise returns zero.

 */

static inline int ubi_dbg_is_bitflip(void)

static inline int ubi_dbg_is_bitflip(const struct ubi_device *ubi)

{

	if (ubi_tst_flags & UBI_TST_EMULATE_BITFLIPS)

	if (ubi->dbg->emulate_bitflips)

		return !(random32() % 200);

	return 0;

}



/**

 * ubi_dbg_is_write_failure - if it is time to emulate a write failure.

 * @ubi: UBI device description object

 *

 * Returns non-zero if a write failure should be emulated, otherwise returns

 * zero.

 */

static inline int ubi_dbg_is_write_failure(void)

static inline int ubi_dbg_is_write_failure(const struct ubi_device *ubi)

{

	if (ubi_tst_flags & UBI_TST_EMULATE_WRITE_FAILURES)

	if (ubi->dbg->emulate_io_failures)

		return !(random32() % 500);

	return 0;

}



/**

 * ubi_dbg_is_erase_failure - if its time to emulate an erase failure.

 * @ubi: UBI device description object

 *

 * Returns non-zero if an erase failure should be emulated, otherwise returns

 * zero.

 */

static inline int ubi_dbg_is_erase_failure(void)

static inline int ubi_dbg_is_erase_failure(const struct ubi_device *ubi)

{

	if (ubi_tst_flags & UBI_TST_EMULATE_ERASE_FAILURES)

	if (ubi->dbg->emulate_io_failures)

		return !(random32() % 400);

	return 0;

}
@@ -201,11 +210,6 @@ static inline void ubi_dbg_dump_flash(struct ubi_device *ubi, 
static inline void

ubi_dbg_print_hex_dump(const char *l, const char *ps, int pt, int r,

		       int g, const void *b, size_t len, bool a)     { return; }



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

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

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

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

static inline int ubi_dbg_check_all_ff(struct ubi_device *ubi,

				       int pnum, int offset,

				       int len)                    { return 0; }
@@ -213,5 +217,20 @@ static inline int ubi_dbg_check_write(struct ubi_device *ubi, 
				      const void *buf, int pnum,

				      int offset, int len)         { return 0; }



static inline int ubi_debugging_init_dev(struct ubi_device *ubi)   { return 0; }

static inline void ubi_debugging_exit_dev(struct ubi_device *ubi)  { return; }

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

static inline void ubi_debugfs_exit(void)                          { return; }

static inline int ubi_debugfs_init_dev(struct ubi_device *ubi)     { return 0; }

static inline void ubi_debugfs_exit_dev(struct ubi_device *ubi)    { return; }



static inline int

ubi_dbg_is_bgt_disabled(const struct ubi_device *ubi)              { return 0; }

static inline int ubi_dbg_is_bitflip(const struct ubi_device *ubi) { return 0; }

static inline int

ubi_dbg_is_write_failure(const struct ubi_device *ubi)             { return 0; }

static inline int

ubi_dbg_is_erase_failure(const struct ubi_device *ubi)             { return 0; }



#endif /* !CONFIG_MTD_UBI_DEBUG */

#endif /* !__UBI_DEBUG_H__ */

drivers/mtd/ubi/io.c

+10 −10
Original line number Diff line number Diff line
@@ -212,7 +212,7 @@ retry: 
	} else {

		ubi_assert(len == read);



		if (ubi_dbg_is_bitflip()) {

		if (ubi_dbg_is_bitflip(ubi)) {

			dbg_gen("bit-flip (emulated)");

			err = UBI_IO_BITFLIPS;

		}
@@ -281,7 +281,7 @@ int ubi_io_write(struct ubi_device *ubi, const void *buf, int pnum, int offset, 
			return err;

	}



	if (ubi_dbg_is_write_failure()) {

	if (ubi_dbg_is_write_failure(ubi)) {

		dbg_err("cannot write %d bytes to PEB %d:%d "

			"(emulated)", len, pnum, offset);

		ubi_dbg_dump_stack();
@@ -396,7 +396,7 @@ retry: 
	if (err)

		return err;



	if (ubi_dbg_is_erase_failure()) {

	if (ubi_dbg_is_erase_failure(ubi)) {

		dbg_err("cannot erase PEB %d (emulated)", pnum);

		return -EIO;

	}
@@ -1146,7 +1146,7 @@ static int paranoid_check_not_bad(const struct ubi_device *ubi, int pnum) 
{

	int err;



	if (!(ubi_chk_flags & UBI_CHK_IO))

	if (!ubi->dbg->chk_io)

		return 0;



	err = ubi_io_is_bad(ubi, pnum);
@@ -1173,7 +1173,7 @@ static int paranoid_check_ec_hdr(const struct ubi_device *ubi, int pnum, 
	int err;

	uint32_t magic;



	if (!(ubi_chk_flags & UBI_CHK_IO))

	if (!ubi->dbg->chk_io)

		return 0;



	magic = be32_to_cpu(ec_hdr->magic);
@@ -1211,7 +1211,7 @@ static int paranoid_check_peb_ec_hdr(const struct ubi_device *ubi, int pnum) 
	uint32_t crc, hdr_crc;

	struct ubi_ec_hdr *ec_hdr;



	if (!(ubi_chk_flags & UBI_CHK_IO))

	if (!ubi->dbg->chk_io)

		return 0;



	ec_hdr = kzalloc(ubi->ec_hdr_alsize, GFP_NOFS);
@@ -1255,7 +1255,7 @@ static int paranoid_check_vid_hdr(const struct ubi_device *ubi, int pnum, 
	int err;

	uint32_t magic;



	if (!(ubi_chk_flags & UBI_CHK_IO))

	if (!ubi->dbg->chk_io)

		return 0;



	magic = be32_to_cpu(vid_hdr->magic);
@@ -1296,7 +1296,7 @@ static int paranoid_check_peb_vid_hdr(const struct ubi_device *ubi, int pnum) 
	struct ubi_vid_hdr *vid_hdr;

	void *p;



	if (!(ubi_chk_flags & UBI_CHK_IO))

	if (!ubi->dbg->chk_io)

		return 0;



	vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS);
@@ -1348,7 +1348,7 @@ int ubi_dbg_check_write(struct ubi_device *ubi, const void *buf, int pnum, 
	void *buf1;

	loff_t addr = (loff_t)pnum * ubi->peb_size + offset;



	if (!(ubi_chk_flags & UBI_CHK_IO))

	if (!ubi->dbg->chk_io)

		return 0;



	buf1 = __vmalloc(len, GFP_NOFS, PAGE_KERNEL);
@@ -1412,7 +1412,7 @@ int ubi_dbg_check_all_ff(struct ubi_device *ubi, int pnum, int offset, int len) 
	void *buf;

	loff_t addr = (loff_t)pnum * ubi->peb_size + offset;



	if (!(ubi_chk_flags & UBI_CHK_IO))

	if (!ubi->dbg->chk_io)

		return 0;



	buf = __vmalloc(len, GFP_NOFS, PAGE_KERNEL);

drivers/mtd/ubi/scan.c

+1 −1
Original line number Diff line number Diff line
@@ -1347,7 +1347,7 @@ static int paranoid_check_si(struct ubi_device *ubi, struct ubi_scan_info *si) 
	struct ubi_scan_leb *seb, *last_seb;

	uint8_t *buf;



	if (!(ubi_chk_flags & UBI_CHK_GEN))

	if (!ubi->dbg->chk_gen)

		return 0;



	/*