Commit 43f32cb1 authored by ZhaoLong Wang's avatar ZhaoLong Wang Committed by Zheng Zengkai
Browse files

ubi: Add six fault injection type for testing 

hulk inclusion
category: feature
bugzilla: https://gitee.com/openeuler/kernel/issues/I60L5U


CVE: NA

-----------------------------------------

This commit adds six fault injection type for testing to cover the
abnormal path of the UBI driver.

Inject the following faults when the UBI reads the LEB:
 +----------------------------+-----------------------------------+
 |    Interface name          |       emulate behavior            |
 +----------------------------+-----------------------------------+
 |  emulate_eccerr            | ECC error                         |
 +----------------------------+-----------------------------------+
 |  emulate_read_failure      | read failure                      |
 |----------------------------+-----------------------------------+
 |  emulate_io_ff             | read content as all FF            |
 |----------------------------+-----------------------------------+
 |  emulate_io_ff_bitflips    | content FF with MTD err reported  |
 +----------------------------+-----------------------------------+
 |  emulate_bad_hdr           | bad leb header                    |
 |----------------------------+-----------------------------------+
 |  emulate_bad_hdr_ebadmsg   | bad header with ECC err           |
 +----------------------------+-----------------------------------+

Signed-off-by: default avatarZhaoLong Wang <wangzhaolong1@huawei.com>
Reviewed-by: default avatarZhihao Cheng <chengzhihao1@huawei.com>
Reviewed-by: default avatarZhang Yi <yi.zhang@huawei.com>
Signed-off-by: default avatarZheng Zengkai <zhengzengkai@huawei.com>
parent 47447a64

drivers/mtd/ubi/debug.c

+30 −0
Original line number Diff line number Diff line
@@ -13,10 +13,16 @@ 
#include <linux/fault-inject.h>



#ifdef CONFIG_MTD_UBI_FAULT_INJECTION

static DECLARE_FAULT_ATTR(fault_eccerr_attr);

static DECLARE_FAULT_ATTR(fault_bitflips_attr);

static DECLARE_FAULT_ATTR(fault_read_failure_attr);

static DECLARE_FAULT_ATTR(fault_write_failure_attr);

static DECLARE_FAULT_ATTR(fault_erase_failure_attr);

static DECLARE_FAULT_ATTR(fault_power_cut_attr);

static DECLARE_FAULT_ATTR(fault_io_ff_attr);

static DECLARE_FAULT_ATTR(fault_io_ff_bitflips_attr);

static DECLARE_FAULT_ATTR(fault_bad_hdr_attr);

static DECLARE_FAULT_ATTR(fault_bad_hdr_ebadmsg_attr);



#define FAIL_ACTION(name, fault_attr)			\

bool should_fail_##name(void)				\
@@ -24,10 +30,16 @@ bool should_fail_##name(void) \ 
	return should_fail(&fault_attr, 1);		\

}



FAIL_ACTION(eccerr,		fault_eccerr_attr)

FAIL_ACTION(bitflips,		fault_bitflips_attr)

FAIL_ACTION(read_failure,	fault_read_failure_attr)

FAIL_ACTION(write_failure,	fault_write_failure_attr)

FAIL_ACTION(erase_failure,	fault_erase_failure_attr)

FAIL_ACTION(power_cut,		fault_power_cut_attr)

FAIL_ACTION(io_ff,		fault_io_ff_attr)

FAIL_ACTION(io_ff_bitflips,	fault_io_ff_bitflips_attr)

FAIL_ACTION(bad_hdr,		fault_bad_hdr_attr)

FAIL_ACTION(bad_hdr_ebadmsg,	fault_bad_hdr_ebadmsg_attr)

#endif
@@ -246,9 +258,15 @@ static void dfs_create_fault_entry(struct dentry *parent) 
		return;

	}



	fault_create_debugfs_attr("emulate_eccerr", dir,

				  &fault_eccerr_attr);



	fault_create_debugfs_attr("emulate_bitflips", dir,

				  &fault_bitflips_attr);



	fault_create_debugfs_attr("emulate_read_failure", dir,

				  &fault_read_failure_attr);



	fault_create_debugfs_attr("emulate_write_failure", dir,

				  &fault_write_failure_attr);
@@ -257,6 +275,18 @@ static void dfs_create_fault_entry(struct dentry *parent) 


	fault_create_debugfs_attr("emulate_power_cut", dir,

				  &fault_power_cut_attr);



	fault_create_debugfs_attr("emulate_io_ff", dir,

				  &fault_io_ff_attr);



	fault_create_debugfs_attr("emulate_io_ff_bitflips", dir,

				  &fault_io_ff_bitflips_attr);



	fault_create_debugfs_attr("emulate_bad_hdr", dir,

				  &fault_bad_hdr_attr);



	fault_create_debugfs_attr("emulate_bad_hdr_ebadmsg", dir,

				  &fault_bad_hdr_ebadmsg_attr);

}

#endif

drivers/mtd/ubi/debug.h

+160 −6
Original line number Diff line number Diff line
@@ -14,12 +14,33 @@ 
 */

/* Emulate bit-flips */

#define MASK_BITFLIPS			(1 << 0)

/* Emulates -EIO during write/erase */

#define MASK_WRITE_FAILURE	(1 << 1)

#define MASK_ERASE_FAILURE	(1 << 2)

/* Emulate ecc error */

#define MASK_ECCERR			(1 << 1)

/* Emulates -EIO during data read */

#define MASK_READ_FAILURE		(1 << 2)

#define MASK_READ_FAILURE_EC		(1 << 3)

#define MASK_READ_FAILURE_VID		(1 << 4)

/* Emulates -EIO during data write */

#define MASK_WRITE_FAILURE		(1 << 5)

/* Emulates -EIO during erase a PEB*/

#define MASK_ERASE_FAILURE		(1 << 6)

/* Emulate a power cut when writing EC/VID header */

#define MASK_POWER_CUT_EC	(1 << 3)

#define MASK_POWER_CUT_VID	(1 << 4)

#define MASK_POWER_CUT_EC		(1 << 7)

#define MASK_POWER_CUT_VID		(1 << 8)

/* Emulate a power cut when writing data*/

#define MASK_POWER_CUT_DATA		(1 << 9)

/* Return UBI_IO_FF when reading EC/VID header */

#define MASK_IO_FF_EC			(1 << 10)

#define MASK_IO_FF_VID			(1 << 11)

/* Return UBI_IO_FF_BITFLIPS when reading EC/VID header */

#define MASK_IO_FF_BITFLIPS_EC		(1 << 12)

#define MASK_IO_FF_BITFLIPS_VID		(1 << 13)

/* Return UBI_IO_BAD_HDR when reading EC/VID header */

#define MASK_BAD_HDR_EC			(1 << 14)

#define MASK_BAD_HDR_VID		(1 << 15)

/* Return UBI_IO_BAD_HDR_EBADMSG when reading EC/VID header */

#define MASK_BAD_HDR_EBADMSG_EC		(1 << 16)

#define MASK_BAD_HDR_EBADMSG_VID	(1 << 17)



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

void ubi_dump_ec_hdr(const struct ubi_ec_hdr *ec_hdr);
@@ -79,10 +100,16 @@ static inline int ubi_dbg_is_bgt_disabled(const struct ubi_device *ubi) 


#ifdef CONFIG_MTD_UBI_FAULT_INJECTION



extern bool should_fail_eccerr(void);

extern bool should_fail_bitflips(void);

extern bool should_fail_read_failure(void);

extern bool should_fail_write_failure(void);

extern bool should_fail_erase_failure(void);

extern bool should_fail_power_cut(void);

extern bool should_fail_io_ff(void);

extern bool should_fail_io_ff_bitflips(void);

extern bool should_fail_bad_hdr(void);

extern bool should_fail_bad_hdr_ebadmsg(void);



/**

 * ubi_dbg_is_bitflip - if it is time to emulate a bit-flip.
@@ -97,6 +124,34 @@ static inline bool ubi_dbg_is_bitflip(const struct ubi_device *ubi) 
	return false;

}



/**

 * ubi_dbg_is_eccerr - if it is time to emulate ECC error.

 * @ubi: UBI device description object

 *

 * Returns true if a ECC error should be emulated, otherwise returns false.

 */

static inline bool ubi_dbg_is_eccerr(const struct ubi_device *ubi)

{

	if (ubi->dbg.emulate_failures & MASK_ECCERR)

		return should_fail_eccerr();

	return false;

}



/**

 * ubi_dbg_is_read_failure - if it is time to emulate a read failure.

 * @ubi: UBI device description object

 *

 * Returns true if a read failure should be emulated, otherwise returns

 * false.

 */

static inline bool ubi_dbg_is_read_failure(const struct ubi_device *ubi,

					   unsigned int caller)

{

	if (ubi->dbg.emulate_failures & caller)

		return should_fail_read_failure();

	return false;

}



/**

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

 * @ubi: UBI device description object
@@ -139,6 +194,70 @@ static inline bool ubi_dbg_power_cut(const struct ubi_device *ubi, 
	return false;

}



/**

 * ubi_dbg_is_ff - if it is time to emulate that read region is only 0xFF.

 * @ubi: UBI device description object

 *

 * Returns true if read region should be emulated 0xFF, otherwise

 * returns false.

 */

static inline bool ubi_dbg_is_ff(const struct ubi_device *ubi,

				 unsigned int caller)

{

	if (ubi->dbg.emulate_failures & caller)

		return should_fail_io_ff();

	return false;

}



/**

 * ubi_dbg_is_ff_bitflips - if it is time to emulate that read region is only 0xFF

 * with error reported by the MTD driver

 *

 * @ubi: UBI device description object

 *

 * Returns true if read region should be emulated 0xFF and error

 * reported by the MTD driver, otherwise returns false.

 */

static inline bool ubi_dbg_is_ff_bitflips(const struct ubi_device *ubi,

					  unsigned int caller)

{

	if (ubi->dbg.emulate_failures & caller)

		return should_fail_io_ff_bitflips();

	return false;

}



/**

 * ubi_dbg_is_bad_hdr - if it is time to emulate a bad header

 * @ubi: UBI device description object

 *

 * Returns true if a bad header error should be emulated, otherwise

 * returns false.

 */

static inline bool ubi_dbg_is_bad_hdr(const struct ubi_device *ubi,

				      unsigned int caller)

{

	if (ubi->dbg.emulate_failures & caller)

		return should_fail_bad_hdr();

	return false;

}



/**

 * ubi_dbg_is_bad_hdr_ebadmsg - if it is time to emulate a bad header with

 * ECC error.

 *

 * @ubi: UBI device description object

 *

 * Returns true if a bad header with ECC error should be emulated, otherwise

 * returns false.

 */

static inline bool ubi_dbg_is_bad_hdr_ebadmsg(const struct ubi_device *ubi,

					      unsigned int caller)

{

	if (ubi->dbg.emulate_failures & caller)

		return should_fail_bad_hdr_ebadmsg();

	return false;

}



#else /* CONFIG_MTD_UBI_FAULT_INJECTION */



static inline bool ubi_dbg_is_bitflip(const struct ubi_device *ubi)
@@ -146,6 +265,17 @@ static inline bool ubi_dbg_is_bitflip(const struct ubi_device *ubi) 
	return false;

}



static inline bool ubi_dbg_is_eccerr(const struct ubi_device *ubi)

{

	return false;

}



static inline bool ubi_dbg_is_read_failure(const struct ubi_device *ubi,

					   unsigned int caller)

{

	return false;

}



static inline bool ubi_dbg_is_write_failure(const struct ubi_device *ubi)

{

	return false;
@@ -162,6 +292,30 @@ static inline bool ubi_dbg_power_cut(const struct ubi_device *ubi, 
	return false;

}



static inline bool ubi_dbg_is_ff(const struct ubi_device *ubi,

				 unsigned int caller)

{

	return false;

}



static inline bool ubi_dbg_is_ff_bitflips(const struct ubi_device *ubi,

					  unsigned int caller)

{

	return false;

}



static inline bool ubi_dbg_is_bad_hdr(const struct ubi_device *ubi,

				      unsigned int caller)

{

	return false;

}



static inline bool ubi_dbg_is_bad_hdr_ebadmsg(const struct ubi_device *ubi,

					      unsigned int caller)

{

	return false;

}



#endif

static inline int ubi_dbg_chk_io(const struct ubi_device *ubi)

{

drivers/mtd/ubi/io.c

+72 −2
Original line number Diff line number Diff line
@@ -193,6 +193,18 @@ int ubi_io_read(const struct ubi_device *ubi, void *buf, int pnum, int offset, 
	} else {

		ubi_assert(len == read);



		if (ubi_dbg_is_read_failure(ubi, MASK_READ_FAILURE)) {

			ubi_warn(ubi, "cannot read %d bytes from PEB %d:%d (emulated)",

				 len, pnum, offset);

			return -EIO;

		}



		if (ubi_dbg_is_eccerr(ubi)) {

			ubi_warn(ubi, "ECC error (emulated) while reading %d bytes from PEB %d:%d, read %zd bytes",

				 len, pnum, offset, read);

			return -EBADMSG;

		}



		if (ubi_dbg_is_bitflip(ubi)) {

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

			err = UBI_IO_BITFLIPS;
@@ -775,7 +787,36 @@ int ubi_io_read_ec_hdr(struct ubi_device *ubi, int pnum, 
	 * If there was %-EBADMSG, but the header CRC is still OK, report about

	 * a bit-flip to force scrubbing on this PEB.

	 */

	return read_err ? UBI_IO_BITFLIPS : 0;

	if (read_err)

		return UBI_IO_BITFLIPS;



	if (ubi_dbg_is_read_failure(ubi, MASK_READ_FAILURE_EC)) {

		ubi_warn(ubi, "cannot read EC header from PEB %d(emulated)",

			 pnum);

		return -EIO;

	}



	if (ubi_dbg_is_ff(ubi, MASK_IO_FF_EC)) {

		ubi_warn(ubi, "bit-all-ff (emulated)");

		return UBI_IO_FF;

	}



	if (ubi_dbg_is_ff_bitflips(ubi, MASK_IO_FF_BITFLIPS_EC)) {

		ubi_warn(ubi, "bit-all-ff with error reported by MTD driver (emulated)");

		return UBI_IO_FF_BITFLIPS;

	}



	if (ubi_dbg_is_bad_hdr(ubi, MASK_BAD_HDR_EC)) {

		ubi_warn(ubi, "bad_hdr (emulated)");

		return UBI_IO_BAD_HDR;

	}



	if (ubi_dbg_is_bad_hdr_ebadmsg(ubi, MASK_BAD_HDR_EBADMSG_EC)) {

		ubi_warn(ubi, "bad_hdr with ECC error (emulated)");

		return UBI_IO_BAD_HDR_EBADMSG;

	}



	return 0;

}



/**
@@ -1030,7 +1071,36 @@ int ubi_io_read_vid_hdr(struct ubi_device *ubi, int pnum, 
		return -EINVAL;

	}



	return read_err ? UBI_IO_BITFLIPS : 0;

	if (read_err)

		return UBI_IO_BITFLIPS;



	if (ubi_dbg_is_read_failure(ubi, MASK_READ_FAILURE_VID)) {

		ubi_warn(ubi, "cannot read VID header from PEB %d(emulated)",

			 pnum);

		return -EIO;

	}



	if (ubi_dbg_is_ff(ubi, MASK_IO_FF_VID)) {

		ubi_warn(ubi, "bit-all-ff (emulated)\n");

		return UBI_IO_FF;

	}



	if (ubi_dbg_is_ff_bitflips(ubi, MASK_IO_FF_BITFLIPS_VID)) {

		ubi_warn(ubi, "bit-all-ff with error reported by MTD driver (emulated)\n");

		return UBI_IO_FF_BITFLIPS;

	}



	if (ubi_dbg_is_bad_hdr(ubi, MASK_BAD_HDR_VID)) {

		ubi_warn(ubi, "bad_hdr (emulated)\n");

		return UBI_IO_BAD_HDR;

	}



	if (ubi_dbg_is_bad_hdr_ebadmsg(ubi, MASK_BAD_HDR_EBADMSG_VID)) {

		ubi_warn(ubi, "bad_hdr with ECC error (emulated)\n");

		return UBI_IO_BAD_HDR_EBADMSG;

	}



	return 0;

}



/**

drivers/mtd/ubi/ubi.h

+19 −12
Original line number Diff line number Diff line
@@ -1109,18 +1109,6 @@ static inline int ubi_io_read_data(const struct ubi_device *ubi, void *buf, 
	return ubi_io_read(ubi, buf, pnum, offset + ubi->leb_start, len);

}



/*

 * This function is equivalent to 'ubi_io_write()', but @offset is relative to

 * the beginning of the logical eraseblock, not to the beginning of the

 * physical eraseblock.

 */

static inline int ubi_io_write_data(struct ubi_device *ubi, const void *buf,

				    int pnum, int offset, int len)

{

	ubi_assert(offset >= 0);

	return ubi_io_write(ubi, buf, pnum, offset + ubi->leb_start, len);

}



/**

 * ubi_ro_mode - switch to read-only mode.

 * @ubi: UBI device description object
@@ -1134,6 +1122,25 @@ static inline void ubi_ro_mode(struct ubi_device *ubi) 
	}

}



/*

 * This function is equivalent to 'ubi_io_write()', but @offset is relative to

 * the beginning of the logical eraseblock, not to the beginning of the

 * physical eraseblock.

 */

static inline int ubi_io_write_data(struct ubi_device *ubi, const void *buf,

				    int pnum, int offset, int len)

{

	ubi_assert(offset >= 0);



	if (ubi_dbg_power_cut(ubi, MASK_POWER_CUT_DATA)) {

		ubi_warn(ubi, "XXXXX emulating a power cut when writing data XXXXX");

		ubi_ro_mode(ubi);

		return -EROFS;

	}



	return ubi_io_write(ubi, buf, pnum, offset + ubi->leb_start, len);

}



/**

 * vol_id2idx - get table index by volume ID.

 * @ubi: UBI device description object