← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise

« back to all changes in this revision

Viewing changes to drivers/mtd/ubi/debug.h

  • Committer: Bazaar Package Importer
  • Author(s): Paolo Pisati
  • Date: 2011-06-29 15:23:51 UTC
  • mfrom: (26.1.1 natty-proposed)
  • Revision ID: james.westby@ubuntu.com-20110629152351-xs96tm303d95rpbk
Tags: 3.0.0-1200.2
* Rebased against 3.0.0-6.7
* BSP from TI based on 3.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/mtd/ubi/debug.h
21
21
#ifndef __UBI_DEBUG_H__
22
22
#define __UBI_DEBUG_H__
23
23
 
24
 
#ifdef CONFIG_MTD_UBI_DEBUG
25
 
#include <linux/random.h>
26
 
 
27
 
#define dbg_err(fmt, ...) ubi_err(fmt, ##__VA_ARGS__)
28
 
 
29
 
#define ubi_assert(expr)  do {                                               \
30
 
        if (unlikely(!(expr))) {                                             \
31
 
                printk(KERN_CRIT "UBI assert failed in %s at %u (pid %d)\n", \
32
 
                       __func__, __LINE__, current->pid);                    \
33
 
                ubi_dbg_dump_stack();                                        \
34
 
        }                                                                    \
35
 
} while (0)
36
 
 
37
 
#define dbg_msg(fmt, ...)                                    \
38
 
        printk(KERN_DEBUG "UBI DBG (pid %d): %s: " fmt "\n", \
39
 
               current->pid, __func__, ##__VA_ARGS__)
40
 
 
41
 
#define ubi_dbg_dump_stack() dump_stack()
42
 
 
43
24
struct ubi_ec_hdr;
44
25
struct ubi_vid_hdr;
45
26
struct ubi_volume;
48
29
struct ubi_scan_leb;
49
30
struct ubi_mkvol_req;
50
31
 
 
32
#ifdef CONFIG_MTD_UBI_DEBUG
 
33
#include <linux/random.h>
 
34
 
 
35
#define ubi_assert(expr)  do {                                               \
 
36
        if (unlikely(!(expr))) {                                             \
 
37
                printk(KERN_CRIT "UBI assert failed in %s at %u (pid %d)\n", \
 
38
                       __func__, __LINE__, current->pid);                    \
 
39
                ubi_dbg_dump_stack();                                        \
 
40
        }                                                                    \
 
41
} while (0)
 
42
 
 
43
#define dbg_err(fmt, ...) ubi_err(fmt, ##__VA_ARGS__)
 
44
 
 
45
#define ubi_dbg_dump_stack() dump_stack()
 
46
 
 
47
#define ubi_dbg_print_hex_dump(l, ps, pt, r, g, b, len, a)  \
 
48
                print_hex_dump(l, ps, pt, r, g, b, len, a)
 
49
 
 
50
#define ubi_dbg_msg(type, fmt, ...) \
 
51
        pr_debug("UBI DBG " type ": " fmt "\n", ##__VA_ARGS__)
 
52
 
 
53
/* Just a debugging messages not related to any specific UBI subsystem */
 
54
#define dbg_msg(fmt, ...) ubi_dbg_msg("msg", fmt, ##__VA_ARGS__)
 
55
/* General debugging messages */
 
56
#define dbg_gen(fmt, ...) ubi_dbg_msg("gen", fmt, ##__VA_ARGS__)
 
57
/* Messages from the eraseblock association sub-system */
 
58
#define dbg_eba(fmt, ...) ubi_dbg_msg("eba", fmt, ##__VA_ARGS__)
 
59
/* Messages from the wear-leveling sub-system */
 
60
#define dbg_wl(fmt, ...)  ubi_dbg_msg("wl", fmt, ##__VA_ARGS__)
 
61
/* Messages from the input/output sub-system */
 
62
#define dbg_io(fmt, ...)  ubi_dbg_msg("io", fmt, ##__VA_ARGS__)
 
63
/* Initialization and build messages */
 
64
#define dbg_bld(fmt, ...) ubi_dbg_msg("bld", fmt, ##__VA_ARGS__)
 
65
 
51
66
void ubi_dbg_dump_ec_hdr(const struct ubi_ec_hdr *ec_hdr);
52
67
void ubi_dbg_dump_vid_hdr(const struct ubi_vid_hdr *vid_hdr);
53
68
void ubi_dbg_dump_vol_info(const struct ubi_volume *vol);
57
72
void ubi_dbg_dump_mkvol_req(const struct ubi_mkvol_req *req);
58
73
void ubi_dbg_dump_flash(struct ubi_device *ubi, int pnum, int offset, int len);
59
74
 
60
 
#define ubi_dbg_print_hex_dump(l, ps, pt, r, g, b, len, a)  \
61
 
                print_hex_dump(l, ps, pt, r, g, b, len, a)
62
 
 
63
 
#ifdef CONFIG_MTD_UBI_DEBUG_MSG
64
 
/* General debugging messages */
65
 
#define dbg_gen(fmt, ...) dbg_msg(fmt, ##__VA_ARGS__)
66
 
#else
67
 
#define dbg_gen(fmt, ...) ({})
68
 
#endif
69
 
 
70
 
#ifdef CONFIG_MTD_UBI_DEBUG_MSG_EBA
71
 
/* Messages from the eraseblock association sub-system */
72
 
#define dbg_eba(fmt, ...) dbg_msg(fmt, ##__VA_ARGS__)
73
 
#else
74
 
#define dbg_eba(fmt, ...) ({})
75
 
#endif
76
 
 
77
 
#ifdef CONFIG_MTD_UBI_DEBUG_MSG_WL
78
 
/* Messages from the wear-leveling sub-system */
79
 
#define dbg_wl(fmt, ...) dbg_msg(fmt, ##__VA_ARGS__)
80
 
#else
81
 
#define dbg_wl(fmt, ...) ({})
82
 
#endif
83
 
 
84
 
#ifdef CONFIG_MTD_UBI_DEBUG_MSG_IO
85
 
/* Messages from the input/output sub-system */
86
 
#define dbg_io(fmt, ...) dbg_msg(fmt, ##__VA_ARGS__)
87
 
#else
88
 
#define dbg_io(fmt, ...) ({})
89
 
#endif
90
 
 
91
 
#ifdef CONFIG_MTD_UBI_DEBUG_MSG_BLD
92
 
/* Initialization and build messages */
93
 
#define dbg_bld(fmt, ...) dbg_msg(fmt, ##__VA_ARGS__)
94
 
#define UBI_IO_DEBUG 1
95
 
#else
96
 
#define dbg_bld(fmt, ...) ({})
97
 
#define UBI_IO_DEBUG 0
98
 
#endif
99
 
 
100
 
#ifdef CONFIG_MTD_UBI_DEBUG_PARANOID
 
75
extern unsigned int ubi_chk_flags;
 
76
 
 
77
/*
 
78
 * Debugging check flags.
 
79
 *
 
80
 * UBI_CHK_GEN: general checks
 
81
 * UBI_CHK_IO: check writes and erases
 
82
 */
 
83
enum {
 
84
        UBI_CHK_GEN = 0x1,
 
85
        UBI_CHK_IO  = 0x2,
 
86
};
 
87
 
101
88
int ubi_dbg_check_all_ff(struct ubi_device *ubi, int pnum, int offset, int len);
102
89
int ubi_dbg_check_write(struct ubi_device *ubi, const void *buf, int pnum,
103
90
                        int offset, int len);
104
 
#else
105
 
#define ubi_dbg_check_all_ff(ubi, pnum, offset, len) 0
106
 
#define ubi_dbg_check_write(ubi, buf, pnum, offset, len) 0
107
 
#endif
108
 
 
109
 
#ifdef CONFIG_MTD_UBI_DEBUG_DISABLE_BGT
110
 
#define DBG_DISABLE_BGT 1
111
 
#else
112
 
#define DBG_DISABLE_BGT 0
113
 
#endif
114
 
 
115
 
#ifdef CONFIG_MTD_UBI_DEBUG_EMULATE_BITFLIPS
 
91
 
 
92
extern unsigned int ubi_tst_flags;
 
93
 
 
94
/*
 
95
 * Special testing flags.
 
96
 *
 
97
 * UBIFS_TST_DISABLE_BGT: disable the background thread
 
98
 * UBI_TST_EMULATE_BITFLIPS: emulate bit-flips
 
99
 * UBI_TST_EMULATE_WRITE_FAILURES: emulate write failures
 
100
 * UBI_TST_EMULATE_ERASE_FAILURES: emulate erase failures
 
101
 */
 
102
enum {
 
103
        UBI_TST_DISABLE_BGT            = 0x1,
 
104
        UBI_TST_EMULATE_BITFLIPS       = 0x2,
 
105
        UBI_TST_EMULATE_WRITE_FAILURES = 0x4,
 
106
        UBI_TST_EMULATE_ERASE_FAILURES = 0x8,
 
107
};
 
108
 
 
109
/**
 
110
 * ubi_dbg_is_bgt_disabled - if the background thread is disabled.
 
111
 *
 
112
 * Returns non-zero if the UBI background thread is disabled for testing
 
113
 * purposes.
 
114
 */
 
115
static inline int ubi_dbg_is_bgt_disabled(void)
 
116
{
 
117
        return ubi_tst_flags & UBI_TST_DISABLE_BGT;
 
118
}
 
119
 
116
120
/**
117
121
 * ubi_dbg_is_bitflip - if it is time to emulate a bit-flip.
118
122
 *
120
124
 */
121
125
static inline int ubi_dbg_is_bitflip(void)
122
126
{
123
 
        return !(random32() % 200);
 
127
        if (ubi_tst_flags & UBI_TST_EMULATE_BITFLIPS)
 
128
                return !(random32() % 200);
 
129
        return 0;
124
130
}
125
 
#else
126
 
#define ubi_dbg_is_bitflip() 0
127
 
#endif
128
131
 
129
 
#ifdef CONFIG_MTD_UBI_DEBUG_EMULATE_WRITE_FAILURES
130
132
/**
131
133
 * ubi_dbg_is_write_failure - if it is time to emulate a write failure.
132
134
 *
135
137
 */
136
138
static inline int ubi_dbg_is_write_failure(void)
137
139
{
138
 
        return !(random32() % 500);
 
140
        if (ubi_tst_flags & UBI_TST_EMULATE_WRITE_FAILURES)
 
141
                return !(random32() % 500);
 
142
        return 0;
139
143
}
140
 
#else
141
 
#define ubi_dbg_is_write_failure() 0
142
 
#endif
143
144
 
144
 
#ifdef CONFIG_MTD_UBI_DEBUG_EMULATE_ERASE_FAILURES
145
145
/**
146
146
 * ubi_dbg_is_erase_failure - if its time to emulate an erase failure.
147
147
 *
150
150
 */
151
151
static inline int ubi_dbg_is_erase_failure(void)
152
152
{
 
153
        if (ubi_tst_flags & UBI_TST_EMULATE_ERASE_FAILURES)
153
154
                return !(random32() % 400);
 
155
        return 0;
154
156
}
155
 
#else
156
 
#define ubi_dbg_is_erase_failure() 0
157
 
#endif
158
 
 
159
 
#else
160
 
 
161
 
#define ubi_assert(expr)                 ({})
162
 
#define dbg_err(fmt, ...)                ({})
163
 
#define dbg_msg(fmt, ...)                ({})
164
 
#define dbg_gen(fmt, ...)                ({})
165
 
#define dbg_eba(fmt, ...)                ({})
166
 
#define dbg_wl(fmt, ...)                 ({})
167
 
#define dbg_io(fmt, ...)                 ({})
168
 
#define dbg_bld(fmt, ...)                ({})
169
 
#define ubi_dbg_dump_stack()             ({})
170
 
#define ubi_dbg_dump_ec_hdr(ec_hdr)      ({})
171
 
#define ubi_dbg_dump_vid_hdr(vid_hdr)    ({})
172
 
#define ubi_dbg_dump_vol_info(vol)       ({})
173
 
#define ubi_dbg_dump_vtbl_record(r, idx) ({})
174
 
#define ubi_dbg_dump_sv(sv)              ({})
175
 
#define ubi_dbg_dump_seb(seb, type)      ({})
176
 
#define ubi_dbg_dump_mkvol_req(req)      ({})
177
 
#define ubi_dbg_dump_flash(ubi, pnum, offset, len) ({})
178
 
#define ubi_dbg_print_hex_dump(l, ps, pt, r, g, b, len, a)  ({})
179
 
 
180
 
#define UBI_IO_DEBUG               0
181
 
#define DBG_DISABLE_BGT            0
182
 
#define ubi_dbg_is_bitflip()       0
183
 
#define ubi_dbg_is_write_failure() 0
184
 
#define ubi_dbg_is_erase_failure() 0
185
 
#define ubi_dbg_check_all_ff(ubi, pnum, offset, len) 0
186
 
#define ubi_dbg_check_write(ubi, buf, pnum, offset, len) 0
 
157
 
 
158
#else
 
159
 
 
160
/* Use "if (0)" to make compiler check arguments even if debugging is off */
 
161
#define ubi_assert(expr)  do {                                               \
 
162
        if (0) {                                                             \
 
163
                printk(KERN_CRIT "UBI assert failed in %s at %u (pid %d)\n", \
 
164
                       __func__, __LINE__, current->pid);                    \
 
165
        }                                                                    \
 
166
} while (0)
 
167
 
 
168
#define dbg_err(fmt, ...) do {                                               \
 
169
        if (0)                                                               \
 
170
                ubi_err(fmt, ##__VA_ARGS__);                                 \
 
171
} while (0)
 
172
 
 
173
#define ubi_dbg_msg(fmt, ...) do {                                           \
 
174
        if (0)                                                               \
 
175
                pr_debug(fmt "\n", ##__VA_ARGS__);                           \
 
176
} while (0)
 
177
 
 
178
#define dbg_msg(fmt, ...)  ubi_dbg_msg(fmt, ##__VA_ARGS__)
 
179
#define dbg_gen(fmt, ...)  ubi_dbg_msg(fmt, ##__VA_ARGS__)
 
180
#define dbg_eba(fmt, ...)  ubi_dbg_msg(fmt, ##__VA_ARGS__)
 
181
#define dbg_wl(fmt, ...)   ubi_dbg_msg(fmt, ##__VA_ARGS__)
 
182
#define dbg_io(fmt, ...)   ubi_dbg_msg(fmt, ##__VA_ARGS__)
 
183
#define dbg_bld(fmt, ...)  ubi_dbg_msg(fmt, ##__VA_ARGS__)
 
184
 
 
185
static inline void ubi_dbg_dump_stack(void)                          { return; }
 
186
static inline void
 
187
ubi_dbg_dump_ec_hdr(const struct ubi_ec_hdr *ec_hdr)                 { return; }
 
188
static inline void
 
189
ubi_dbg_dump_vid_hdr(const struct ubi_vid_hdr *vid_hdr)              { return; }
 
190
static inline void
 
191
ubi_dbg_dump_vol_info(const struct ubi_volume *vol)                  { return; }
 
192
static inline void
 
193
ubi_dbg_dump_vtbl_record(const struct ubi_vtbl_record *r, int idx)   { return; }
 
194
static inline void ubi_dbg_dump_sv(const struct ubi_scan_volume *sv) { return; }
 
195
static inline void ubi_dbg_dump_seb(const struct ubi_scan_leb *seb,
 
196
                                    int type)                        { return; }
 
197
static inline void
 
198
ubi_dbg_dump_mkvol_req(const struct ubi_mkvol_req *req)              { return; }
 
199
static inline void ubi_dbg_dump_flash(struct ubi_device *ubi,
 
200
                                      int pnum, int offset, int len) { return; }
 
201
static inline void
 
202
ubi_dbg_print_hex_dump(const char *l, const char *ps, int pt, int r,
 
203
                       int g, const void *b, size_t len, bool a)     { return; }
 
204
 
 
205
static inline int ubi_dbg_is_bgt_disabled(void)                    { return 0; }
 
206
static inline int ubi_dbg_is_bitflip(void)                         { return 0; }
 
207
static inline int ubi_dbg_is_write_failure(void)                   { return 0; }
 
208
static inline int ubi_dbg_is_erase_failure(void)                   { return 0; }
 
209
static inline int ubi_dbg_check_all_ff(struct ubi_device *ubi,
 
210
                                       int pnum, int offset,
 
211
                                       int len)                    { return 0; }
 
212
static inline int ubi_dbg_check_write(struct ubi_device *ubi,
 
213
                                      const void *buf, int pnum,
 
214
                                      int offset, int len)         { return 0; }
187
215
 
188
216
#endif /* !CONFIG_MTD_UBI_DEBUG */
189
217
#endif /* !__UBI_DEBUG_H__ */