| Message ID | 20230318015621.1408243-4-wangzhaolong1@huawei.com |
|---|---|
| State | Changes Requested |
| Delegated to: | Richard Weinberger |
| Headers | show |
| Series | ubi: Enhanced fault injection capability for the UBI driver | expand |
> This commit adds six fault injection type for testing to cover the > abnormal path of the UBI driver. > [...] > > diff --git a/drivers/mtd/ubi/debug.h b/drivers/mtd/ubi/debug.h > index 2486fcab4205..8272c2b93dd4 100644 > --- a/drivers/mtd/ubi/debug.h > +++ b/drivers/mtd/ubi/debug.h > @@ -13,13 +13,34 @@ > * precisely control the type and process of fault injection. > */ > /* 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) > +#define MASK_BITFLIPS (1 << 0) > +/* 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,28 +194,70 @@ static inline bool ubi_dbg_power_cut(const struct ubi_device *ubi, > return false; > } > > -#else /* CONFIG_MTD_UBI_FAULT_INJECTION */ Why not keeping double function definations style, then you don't need to check 'CONFIG_MTD_UBI_FAULT_INJECTION' in other *.c(eg. io.c). > - > -static inline bool ubi_dbg_is_bitflip(const struct ubi_device *ubi) > +/** > + * 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; > } > > -static inline bool ubi_dbg_is_write_failure(const struct ubi_device *ubi) > +/** > + * 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; > } > > -static inline bool ubi_dbg_is_erase_failure(const struct ubi_device *ubi) > +/** > + * 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; > } > > -static inline bool ubi_dbg_power_cut(const struct ubi_device *ubi, > - unsigned int caller) > +/** > + * 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; > } > + > #endif > > static inline int ubi_dbg_chk_io(const struct ubi_device *ubi) > diff --git a/drivers/mtd/ubi/io.c b/drivers/mtd/ubi/io.c > index 906ad0811d52..e64914c3cc8d 100644 > --- a/drivers/mtd/ubi/io.c > +++ b/drivers/mtd/ubi/io.c > @@ -192,11 +192,24 @@ int ubi_io_read(const struct ubi_device *ubi, void *buf, int pnum, int offset, > } > } else { > ubi_assert(len == read); > +#ifdef CONFIG_MTD_UBI_FAULT_INJECTION > + 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; > } > +#endif > } > > return err; > @@ -259,14 +272,14 @@ int ubi_io_write(struct ubi_device *ubi, const void *buf, int pnum, int offset, > if (err) > return err; > } > - > +#ifdef CONFIG_MTD_UBI_FAULT_INJECTION > if (ubi_dbg_is_write_failure(ubi)) { > ubi_err(ubi, "cannot write %d bytes to PEB %d:%d (emulated)", > len, pnum, offset); > dump_stack(); > return -EIO; > } > - > +#endif > addr = (loff_t)pnum * ubi->peb_size + offset; > err = mtd_write(ubi->mtd, addr, len, &written, buf); > if (err) { > @@ -339,12 +352,12 @@ static int do_sync_erase(struct ubi_device *ubi, int pnum) > err = ubi_self_check_all_ff(ubi, pnum, 0, ubi->peb_size); > if (err) > return err; > - > +#ifdef CONFIG_MTD_UBI_FAULT_INJECTION > if (ubi_dbg_is_erase_failure(ubi)) { > ubi_err(ubi, "cannot erase PEB %d (emulated)", pnum); > return -EIO; > } > - > +#endif > return 0; > } > > @@ -782,7 +795,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; > +#ifdef CONFIG_MTD_UBI_FAULT_INJECTION > + 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; > + } > +#endif > + return 0; > } > > /** > @@ -820,13 +862,13 @@ int ubi_io_write_ec_hdr(struct ubi_device *ubi, int pnum, > err = self_check_ec_hdr(ubi, pnum, ec_hdr); > if (err) > return err; > - > +#ifdef CONFIG_MTD_UBI_FAULT_INJECTION > if (ubi_dbg_power_cut(ubi, MASK_POWER_CUT_EC)) { > ubi_warn(ubi, "XXXXX emulating a power cut when writing EC header XXXXX"); > ubi_ro_mode(ubi); > return -EROFS; > } > - > +#endif > err = ubi_io_write(ubi, ec_hdr, pnum, 0, ubi->ec_hdr_alsize); > return err; > } > @@ -1032,7 +1074,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; > +#ifdef CONFIG_MTD_UBI_FAULT_INJECTION > + 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; > + } > +#endif > + return 0; > } > > /** > @@ -1073,13 +1144,13 @@ int ubi_io_write_vid_hdr(struct ubi_device *ubi, int pnum, > err = self_check_vid_hdr(ubi, pnum, vid_hdr); > if (err) > return err; > - > +#ifdef CONFIG_MTD_UBI_FAULT_INJECTION > if (ubi_dbg_power_cut(ubi, MASK_POWER_CUT_VID)) { > ubi_warn(ubi, "XXXXX emulating a power cut when writing VID header XXXXX"); > ubi_ro_mode(ubi); > return -EROFS; > } > - > +#endif > err = ubi_io_write(ubi, p, pnum, ubi->vid_hdr_aloffset, > ubi->vid_hdr_alsize); > return err; > diff --git a/drivers/mtd/ubi/ubi.h b/drivers/mtd/ubi/ubi.h > index e20e9a6f9c05..7ff55a74b313 100644 > --- a/drivers/mtd/ubi/ubi.h > +++ b/drivers/mtd/ubi/ubi.h > @@ -1107,18 +1107,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 > @@ -1132,6 +1120,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); > +#ifdef CONFIG_MTD_UBI_FAULT_INJECTION > + 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; > + } > +#endif > + 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 >
diff --git a/drivers/mtd/ubi/debug.c b/drivers/mtd/ubi/debug.c index 9c92bd59b639..0c58cbabe9fc 100644 --- a/drivers/mtd/ubi/debug.c +++ b/drivers/mtd/ubi/debug.c @@ -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 @@ -245,9 +257,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); @@ -256,6 +274,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 diff --git a/drivers/mtd/ubi/debug.h b/drivers/mtd/ubi/debug.h index 2486fcab4205..8272c2b93dd4 100644 --- a/drivers/mtd/ubi/debug.h +++ b/drivers/mtd/ubi/debug.h @@ -13,13 +13,34 @@ * precisely control the type and process of fault injection. */ /* 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) +#define MASK_BITFLIPS (1 << 0) +/* 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,28 +194,70 @@ static inline bool ubi_dbg_power_cut(const struct ubi_device *ubi, return false; } -#else /* CONFIG_MTD_UBI_FAULT_INJECTION */ - -static inline bool ubi_dbg_is_bitflip(const struct ubi_device *ubi) +/** + * 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; } -static inline bool ubi_dbg_is_write_failure(const struct ubi_device *ubi) +/** + * 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; } -static inline bool ubi_dbg_is_erase_failure(const struct ubi_device *ubi) +/** + * 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; } -static inline bool ubi_dbg_power_cut(const struct ubi_device *ubi, - unsigned int caller) +/** + * 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; } + #endif static inline int ubi_dbg_chk_io(const struct ubi_device *ubi) diff --git a/drivers/mtd/ubi/io.c b/drivers/mtd/ubi/io.c index 906ad0811d52..e64914c3cc8d 100644 --- a/drivers/mtd/ubi/io.c +++ b/drivers/mtd/ubi/io.c @@ -192,11 +192,24 @@ int ubi_io_read(const struct ubi_device *ubi, void *buf, int pnum, int offset, } } else { ubi_assert(len == read); +#ifdef CONFIG_MTD_UBI_FAULT_INJECTION + 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; } +#endif } return err; @@ -259,14 +272,14 @@ int ubi_io_write(struct ubi_device *ubi, const void *buf, int pnum, int offset, if (err) return err; } - +#ifdef CONFIG_MTD_UBI_FAULT_INJECTION if (ubi_dbg_is_write_failure(ubi)) { ubi_err(ubi, "cannot write %d bytes to PEB %d:%d (emulated)", len, pnum, offset); dump_stack(); return -EIO; } - +#endif addr = (loff_t)pnum * ubi->peb_size + offset; err = mtd_write(ubi->mtd, addr, len, &written, buf); if (err) { @@ -339,12 +352,12 @@ static int do_sync_erase(struct ubi_device *ubi, int pnum) err = ubi_self_check_all_ff(ubi, pnum, 0, ubi->peb_size); if (err) return err; - +#ifdef CONFIG_MTD_UBI_FAULT_INJECTION if (ubi_dbg_is_erase_failure(ubi)) { ubi_err(ubi, "cannot erase PEB %d (emulated)", pnum); return -EIO; } - +#endif return 0; } @@ -782,7 +795,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; +#ifdef CONFIG_MTD_UBI_FAULT_INJECTION + 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; + } +#endif + return 0; } /** @@ -820,13 +862,13 @@ int ubi_io_write_ec_hdr(struct ubi_device *ubi, int pnum, err = self_check_ec_hdr(ubi, pnum, ec_hdr); if (err) return err; - +#ifdef CONFIG_MTD_UBI_FAULT_INJECTION if (ubi_dbg_power_cut(ubi, MASK_POWER_CUT_EC)) { ubi_warn(ubi, "XXXXX emulating a power cut when writing EC header XXXXX"); ubi_ro_mode(ubi); return -EROFS; } - +#endif err = ubi_io_write(ubi, ec_hdr, pnum, 0, ubi->ec_hdr_alsize); return err; } @@ -1032,7 +1074,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; +#ifdef CONFIG_MTD_UBI_FAULT_INJECTION + 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; + } +#endif + return 0; } /** @@ -1073,13 +1144,13 @@ int ubi_io_write_vid_hdr(struct ubi_device *ubi, int pnum, err = self_check_vid_hdr(ubi, pnum, vid_hdr); if (err) return err; - +#ifdef CONFIG_MTD_UBI_FAULT_INJECTION if (ubi_dbg_power_cut(ubi, MASK_POWER_CUT_VID)) { ubi_warn(ubi, "XXXXX emulating a power cut when writing VID header XXXXX"); ubi_ro_mode(ubi); return -EROFS; } - +#endif err = ubi_io_write(ubi, p, pnum, ubi->vid_hdr_aloffset, ubi->vid_hdr_alsize); return err; diff --git a/drivers/mtd/ubi/ubi.h b/drivers/mtd/ubi/ubi.h index e20e9a6f9c05..7ff55a74b313 100644 --- a/drivers/mtd/ubi/ubi.h +++ b/drivers/mtd/ubi/ubi.h @@ -1107,18 +1107,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 @@ -1132,6 +1120,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); +#ifdef CONFIG_MTD_UBI_FAULT_INJECTION + 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; + } +#endif + 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
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: ZhaoLong Wang <wangzhaolong1@huawei.com> --- drivers/mtd/ubi/debug.c | 30 ++++++++++ drivers/mtd/ubi/debug.h | 123 +++++++++++++++++++++++++++++++++++----- drivers/mtd/ubi/io.c | 91 +++++++++++++++++++++++++---- drivers/mtd/ubi/ubi.h | 31 ++++++---- 4 files changed, 240 insertions(+), 35 deletions(-)