388 lines · c
1/* SPDX-License-Identifier: GPL-2.0-or-later */2/*3 * Copyright (c) International Business Machines Corp., 20064 *5 * Author: Artem Bityutskiy (Битюцкий Артём)6 */7 8#ifndef __UBI_DEBUG_H__9#define __UBI_DEBUG_H__10 11void ubi_dump_flash(struct ubi_device *ubi, int pnum, int offset, int len);12void ubi_dump_ec_hdr(const struct ubi_ec_hdr *ec_hdr);13void ubi_dump_vid_hdr(const struct ubi_vid_hdr *vid_hdr);14 15#include <linux/random.h>16 17#define ubi_assert(expr) do { \18 if (unlikely(!(expr))) { \19 pr_crit("UBI assert failed in %s at %u (pid %d)\n", \20 __func__, __LINE__, current->pid); \21 dump_stack(); \22 } \23} while (0)24 25#define ubi_dbg_print_hex_dump(l, ps, pt, r, g, b, len, a) \26 print_hex_dump(l, ps, pt, r, g, b, len, a)27 28#define ubi_dbg_msg(type, fmt, ...) \29 pr_debug("UBI DBG " type " (pid %d): " fmt "\n", current->pid, \30 ##__VA_ARGS__)31 32/* General debugging messages */33#define dbg_gen(fmt, ...) ubi_dbg_msg("gen", fmt, ##__VA_ARGS__)34/* Messages from the eraseblock association sub-system */35#define dbg_eba(fmt, ...) ubi_dbg_msg("eba", fmt, ##__VA_ARGS__)36/* Messages from the wear-leveling sub-system */37#define dbg_wl(fmt, ...) ubi_dbg_msg("wl", fmt, ##__VA_ARGS__)38/* Messages from the input/output sub-system */39#define dbg_io(fmt, ...) ubi_dbg_msg("io", fmt, ##__VA_ARGS__)40/* Initialization and build messages */41#define dbg_bld(fmt, ...) ubi_dbg_msg("bld", fmt, ##__VA_ARGS__)42 43void ubi_dump_vol_info(const struct ubi_volume *vol);44void ubi_dump_vtbl_record(const struct ubi_vtbl_record *r, int idx);45void ubi_dump_av(const struct ubi_ainf_volume *av);46void ubi_dump_aeb(const struct ubi_ainf_peb *aeb, int type);47void ubi_dump_mkvol_req(const struct ubi_mkvol_req *req);48int ubi_self_check_all_ff(struct ubi_device *ubi, int pnum, int offset,49 int len);50int ubi_debugfs_init(void);51void ubi_debugfs_exit(void);52int ubi_debugfs_init_dev(struct ubi_device *ubi);53void ubi_debugfs_exit_dev(struct ubi_device *ubi);54 55/**56 * The following function is a legacy implementation of UBI fault-injection57 * hook. When using more powerful fault injection capabilities, the legacy58 * fault injection interface should be retained.59 */60int ubi_dbg_power_cut(struct ubi_device *ubi, int caller);61 62static inline int ubi_dbg_bitflip(const struct ubi_device *ubi)63{64 if (ubi->dbg.emulate_bitflips)65 return !get_random_u32_below(200);66 return 0;67}68 69static inline int ubi_dbg_write_failure(const struct ubi_device *ubi)70{71 if (ubi->dbg.emulate_io_failures)72 return !get_random_u32_below(500);73 return 0;74}75 76static inline int ubi_dbg_erase_failure(const struct ubi_device *ubi)77{78 if (ubi->dbg.emulate_io_failures)79 return !get_random_u32_below(400);80 return 0;81}82 83/**84 * MASK_XXX: Mask for emulate_failures in ubi_debug_info.The mask is used to85 * precisely control the type and process of fault injection.86 */87/* Emulate a power cut when writing EC/VID header */88#define MASK_POWER_CUT_EC (1 << 0)89#define MASK_POWER_CUT_VID (1 << 1)90/* Emulate a power cut when writing data*/91#define MASK_POWER_CUT_DATA (1 << 2)92/* Emulate bit-flips */93#define MASK_BITFLIPS (1 << 3)94/* Emulate ecc error */95#define MASK_ECCERR (1 << 4)96/* Emulates -EIO during data read */97#define MASK_READ_FAILURE (1 << 5)98#define MASK_READ_FAILURE_EC (1 << 6)99#define MASK_READ_FAILURE_VID (1 << 7)100/* Emulates -EIO during data write */101#define MASK_WRITE_FAILURE (1 << 8)102/* Emulates -EIO during erase a PEB*/103#define MASK_ERASE_FAILURE (1 << 9)104/* Return UBI_IO_FF when reading EC/VID header */105#define MASK_IO_FF_EC (1 << 10)106#define MASK_IO_FF_VID (1 << 11)107/* Return UBI_IO_FF_BITFLIPS when reading EC/VID header */108#define MASK_IO_FF_BITFLIPS_EC (1 << 12)109#define MASK_IO_FF_BITFLIPS_VID (1 << 13)110/* Return UBI_IO_BAD_HDR when reading EC/VID header */111#define MASK_BAD_HDR_EC (1 << 14)112#define MASK_BAD_HDR_VID (1 << 15)113/* Return UBI_IO_BAD_HDR_EBADMSG when reading EC/VID header */114#define MASK_BAD_HDR_EBADMSG_EC (1 << 16)115#define MASK_BAD_HDR_EBADMSG_VID (1 << 17)116 117#ifdef CONFIG_MTD_UBI_FAULT_INJECTION118 119extern bool should_fail_eccerr(void);120extern bool should_fail_bitflips(void);121extern bool should_fail_read_failure(void);122extern bool should_fail_write_failure(void);123extern bool should_fail_erase_failure(void);124extern bool should_fail_power_cut(void);125extern bool should_fail_io_ff(void);126extern bool should_fail_io_ff_bitflips(void);127extern bool should_fail_bad_hdr(void);128extern bool should_fail_bad_hdr_ebadmsg(void);129 130static inline bool ubi_dbg_fail_bitflip(const struct ubi_device *ubi)131{132 if (ubi->dbg.emulate_failures & MASK_BITFLIPS)133 return should_fail_bitflips();134 return false;135}136 137static inline bool ubi_dbg_fail_write(const struct ubi_device *ubi)138{139 if (ubi->dbg.emulate_failures & MASK_WRITE_FAILURE)140 return should_fail_write_failure();141 return false;142}143 144static inline bool ubi_dbg_fail_erase(const struct ubi_device *ubi)145{146 if (ubi->dbg.emulate_failures & MASK_ERASE_FAILURE)147 return should_fail_erase_failure();148 return false;149}150 151static inline bool ubi_dbg_fail_power_cut(const struct ubi_device *ubi,152 unsigned int caller)153{154 if (ubi->dbg.emulate_failures & caller)155 return should_fail_power_cut();156 return false;157}158 159static inline bool ubi_dbg_fail_read(const struct ubi_device *ubi,160 unsigned int caller)161{162 if (ubi->dbg.emulate_failures & caller)163 return should_fail_read_failure();164 return false;165}166 167static inline bool ubi_dbg_fail_eccerr(const struct ubi_device *ubi)168{169 if (ubi->dbg.emulate_failures & MASK_ECCERR)170 return should_fail_eccerr();171 return false;172}173 174static inline bool ubi_dbg_fail_ff(const struct ubi_device *ubi,175 unsigned int caller)176{177 if (ubi->dbg.emulate_failures & caller)178 return should_fail_io_ff();179 return false;180}181 182static inline bool ubi_dbg_fail_ff_bitflips(const struct ubi_device *ubi,183 unsigned int caller)184{185 if (ubi->dbg.emulate_failures & caller)186 return should_fail_io_ff_bitflips();187 return false;188}189 190static inline bool ubi_dbg_fail_bad_hdr(const struct ubi_device *ubi,191 unsigned int caller)192{193 if (ubi->dbg.emulate_failures & caller)194 return should_fail_bad_hdr();195 return false;196}197 198static inline bool ubi_dbg_fail_bad_hdr_ebadmsg(const struct ubi_device *ubi,199 unsigned int caller)200{201 if (ubi->dbg.emulate_failures & caller)202 return should_fail_bad_hdr_ebadmsg();203 return false;204}205#else /* CONFIG_MTD_UBI_FAULT_INJECTION */206 207#define ubi_dbg_fail_bitflip(u) false208#define ubi_dbg_fail_write(u) false209#define ubi_dbg_fail_erase(u) false210#define ubi_dbg_fail_power_cut(u, c) false211#define ubi_dbg_fail_read(u, c) false212#define ubi_dbg_fail_eccerr(u) false213#define ubi_dbg_fail_ff(u, c) false214#define ubi_dbg_fail_ff_bitflips(u, v) false215#define ubi_dbg_fail_bad_hdr(u, c) false216#define ubi_dbg_fail_bad_hdr_ebadmsg(u, c) false217 218#endif219 220/**221 * ubi_dbg_is_power_cut - if it is time to emulate power cut.222 * @ubi: UBI device description object223 *224 * Returns true if power cut should be emulated, otherwise returns false.225 */226static inline bool ubi_dbg_is_power_cut(struct ubi_device *ubi,227 unsigned int caller)228{229 if (ubi_dbg_power_cut(ubi, caller))230 return true;231 return ubi_dbg_fail_power_cut(ubi, caller);232}233 234/**235 * ubi_dbg_is_bitflip - if it is time to emulate a bit-flip.236 * @ubi: UBI device description object237 *238 * Returns true if a bit-flip should be emulated, otherwise returns false.239 */240static inline bool ubi_dbg_is_bitflip(const struct ubi_device *ubi)241{242 if (ubi_dbg_bitflip(ubi))243 return true;244 return ubi_dbg_fail_bitflip(ubi);245}246 247/**248 * ubi_dbg_is_write_failure - if it is time to emulate a write failure.249 * @ubi: UBI device description object250 *251 * Returns true if a write failure should be emulated, otherwise returns252 * false.253 */254static inline bool ubi_dbg_is_write_failure(const struct ubi_device *ubi)255{256 if (ubi_dbg_write_failure(ubi))257 return true;258 return ubi_dbg_fail_write(ubi);259}260 261/**262 * ubi_dbg_is_erase_failure - if its time to emulate an erase failure.263 * @ubi: UBI device description object264 *265 * Returns true if an erase failure should be emulated, otherwise returns266 * false.267 */268static inline bool ubi_dbg_is_erase_failure(const struct ubi_device *ubi)269{270 if (ubi_dbg_erase_failure(ubi))271 return true;272 return ubi_dbg_fail_erase(ubi);273}274 275/**276 * ubi_dbg_is_eccerr - if it is time to emulate ECC error.277 * @ubi: UBI device description object278 *279 * Returns true if a ECC error should be emulated, otherwise returns false.280 */281static inline bool ubi_dbg_is_eccerr(const struct ubi_device *ubi)282{283 return ubi_dbg_fail_eccerr(ubi);284}285 286/**287 * ubi_dbg_is_read_failure - if it is time to emulate a read failure.288 * @ubi: UBI device description object289 *290 * Returns true if a read failure should be emulated, otherwise returns291 * false.292 */293static inline bool ubi_dbg_is_read_failure(const struct ubi_device *ubi,294 unsigned int caller)295{296 return ubi_dbg_fail_read(ubi, caller);297}298 299/**300 * ubi_dbg_is_ff - if it is time to emulate that read region is only 0xFF.301 * @ubi: UBI device description object302 *303 * Returns true if read region should be emulated 0xFF, otherwise304 * returns false.305 */306static inline bool ubi_dbg_is_ff(const struct ubi_device *ubi,307 unsigned int caller)308{309 return ubi_dbg_fail_ff(ubi, caller);310}311 312/**313 * ubi_dbg_is_ff_bitflips - if it is time to emulate that read region is only 0xFF314 * with error reported by the MTD driver315 *316 * @ubi: UBI device description object317 *318 * Returns true if read region should be emulated 0xFF and error319 * reported by the MTD driver, otherwise returns false.320 */321static inline bool ubi_dbg_is_ff_bitflips(const struct ubi_device *ubi,322 unsigned int caller)323{324 return ubi_dbg_fail_ff_bitflips(ubi, caller);325}326 327/**328 * ubi_dbg_is_bad_hdr - if it is time to emulate a bad header329 * @ubi: UBI device description object330 *331 * Returns true if a bad header error should be emulated, otherwise332 * returns false.333 */334static inline bool ubi_dbg_is_bad_hdr(const struct ubi_device *ubi,335 unsigned int caller)336{337 return ubi_dbg_fail_bad_hdr(ubi, caller);338}339 340/**341 * ubi_dbg_is_bad_hdr_ebadmsg - if it is time to emulate a bad header with342 * ECC error.343 *344 * @ubi: UBI device description object345 *346 * Returns true if a bad header with ECC error should be emulated, otherwise347 * returns false.348 */349static inline bool ubi_dbg_is_bad_hdr_ebadmsg(const struct ubi_device *ubi,350 unsigned int caller)351{352 return ubi_dbg_fail_bad_hdr_ebadmsg(ubi, caller);353}354 355/**356 * ubi_dbg_is_bgt_disabled - if the background thread is disabled.357 * @ubi: UBI device description object358 *359 * Returns non-zero if the UBI background thread is disabled for testing360 * purposes.361 */362static inline int ubi_dbg_is_bgt_disabled(const struct ubi_device *ubi)363{364 return ubi->dbg.disable_bgt;365}366 367static inline int ubi_dbg_chk_io(const struct ubi_device *ubi)368{369 return ubi->dbg.chk_io;370}371 372static inline int ubi_dbg_chk_gen(const struct ubi_device *ubi)373{374 return ubi->dbg.chk_gen;375}376 377static inline int ubi_dbg_chk_fastmap(const struct ubi_device *ubi)378{379 return ubi->dbg.chk_fastmap;380}381 382static inline void ubi_enable_dbg_chk_fastmap(struct ubi_device *ubi)383{384 ubi->dbg.chk_fastmap = 1;385}386 387#endif /* !__UBI_DEBUG_H__ */388