Merge git://git.kernel.org/pub/scm/linux/kernel/git/sam/kbuild-next
[linux-2.6.git] / drivers / mtd / ubi / io.c
1 /*
2  * Copyright (c) International Business Machines Corp., 2006
3  * Copyright (c) Nokia Corporation, 2006, 2007
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
13  * the GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18  *
19  * Author: Artem Bityutskiy (Битюцкий Артём)
20  */
21
22 /*
23  * UBI input/output sub-system.
24  *
25  * This sub-system provides a uniform way to work with all kinds of the
26  * underlying MTD devices. It also implements handy functions for reading and
27  * writing UBI headers.
28  *
29  * We are trying to have a paranoid mindset and not to trust to what we read
30  * from the flash media in order to be more secure and robust. So this
31  * sub-system validates every single header it reads from the flash media.
32  *
33  * Some words about how the eraseblock headers are stored.
34  *
35  * The erase counter header is always stored at offset zero. By default, the
36  * VID header is stored after the EC header at the closest aligned offset
37  * (i.e. aligned to the minimum I/O unit size). Data starts next to the VID
38  * header at the closest aligned offset. But this default layout may be
39  * changed. For example, for different reasons (e.g., optimization) UBI may be
40  * asked to put the VID header at further offset, and even at an unaligned
41  * offset. Of course, if the offset of the VID header is unaligned, UBI adds
42  * proper padding in front of it. Data offset may also be changed but it has to
43  * be aligned.
44  *
45  * About minimal I/O units. In general, UBI assumes flash device model where
46  * there is only one minimal I/O unit size. E.g., in case of NOR flash it is 1,
47  * in case of NAND flash it is a NAND page, etc. This is reported by MTD in the
48  * @ubi->mtd->writesize field. But as an exception, UBI admits of using another
49  * (smaller) minimal I/O unit size for EC and VID headers to make it possible
50  * to do different optimizations.
51  *
52  * This is extremely useful in case of NAND flashes which admit of several
53  * write operations to one NAND page. In this case UBI can fit EC and VID
54  * headers at one NAND page. Thus, UBI may use "sub-page" size as the minimal
55  * I/O unit for the headers (the @ubi->hdrs_min_io_size field). But it still
56  * reports NAND page size (@ubi->min_io_size) as a minimal I/O unit for the UBI
57  * users.
58  *
59  * Example: some Samsung NANDs with 2KiB pages allow 4x 512-byte writes, so
60  * although the minimal I/O unit is 2K, UBI uses 512 bytes for EC and VID
61  * headers.
62  *
63  * Q: why not just to treat sub-page as a minimal I/O unit of this flash
64  * device, e.g., make @ubi->min_io_size = 512 in the example above?
65  *
66  * A: because when writing a sub-page, MTD still writes a full 2K page but the
67  * bytes which are no relevant to the sub-page are 0xFF. So, basically, writing
68  * 4x512 sub-pages is 4 times slower then writing one 2KiB NAND page. Thus, we
69  * prefer to use sub-pages only for EV and VID headers.
70  *
71  * As it was noted above, the VID header may start at a non-aligned offset.
72  * For example, in case of a 2KiB page NAND flash with a 512 bytes sub-page,
73  * the VID header may reside at offset 1984 which is the last 64 bytes of the
74  * last sub-page (EC header is always at offset zero). This causes some
75  * difficulties when reading and writing VID headers.
76  *
77  * Suppose we have a 64-byte buffer and we read a VID header at it. We change
78  * the data and want to write this VID header out. As we can only write in
79  * 512-byte chunks, we have to allocate one more buffer and copy our VID header
80  * to offset 448 of this buffer.
81  *
82  * The I/O sub-system does the following trick in order to avoid this extra
83  * copy. It always allocates a @ubi->vid_hdr_alsize bytes buffer for the VID
84  * header and returns a pointer to offset @ubi->vid_hdr_shift of this buffer.
85  * When the VID header is being written out, it shifts the VID header pointer
86  * back and writes the whole sub-page.
87  */
88
89 #include <linux/crc32.h>
90 #include <linux/err.h>
91 #include "ubi.h"
92
93 #ifdef CONFIG_MTD_UBI_DEBUG_PARANOID
94 static int paranoid_check_not_bad(const struct ubi_device *ubi, int pnum);
95 static int paranoid_check_peb_ec_hdr(const struct ubi_device *ubi, int pnum);
96 static int paranoid_check_ec_hdr(const struct ubi_device *ubi, int pnum,
97                                  const struct ubi_ec_hdr *ec_hdr);
98 static int paranoid_check_peb_vid_hdr(const struct ubi_device *ubi, int pnum);
99 static int paranoid_check_vid_hdr(const struct ubi_device *ubi, int pnum,
100                                   const struct ubi_vid_hdr *vid_hdr);
101 static int paranoid_check_all_ff(struct ubi_device *ubi, int pnum, int offset,
102                                  int len);
103 #else
104 #define paranoid_check_not_bad(ubi, pnum) 0
105 #define paranoid_check_peb_ec_hdr(ubi, pnum)  0
106 #define paranoid_check_ec_hdr(ubi, pnum, ec_hdr)  0
107 #define paranoid_check_peb_vid_hdr(ubi, pnum) 0
108 #define paranoid_check_vid_hdr(ubi, pnum, vid_hdr) 0
109 #define paranoid_check_all_ff(ubi, pnum, offset, len) 0
110 #endif
111
112 /**
113  * ubi_io_read - read data from a physical eraseblock.
114  * @ubi: UBI device description object
115  * @buf: buffer where to store the read data
116  * @pnum: physical eraseblock number to read from
117  * @offset: offset within the physical eraseblock from where to read
118  * @len: how many bytes to read
119  *
120  * This function reads data from offset @offset of physical eraseblock @pnum
121  * and stores the read data in the @buf buffer. The following return codes are
122  * possible:
123  *
124  * o %0 if all the requested data were successfully read;
125  * o %UBI_IO_BITFLIPS if all the requested data were successfully read, but
126  *   correctable bit-flips were detected; this is harmless but may indicate
127  *   that this eraseblock may become bad soon (but do not have to);
128  * o %-EBADMSG if the MTD subsystem reported about data integrity problems, for
129  *   example it can be an ECC error in case of NAND; this most probably means
130  *   that the data is corrupted;
131  * o %-EIO if some I/O error occurred;
132  * o other negative error codes in case of other errors.
133  */
134 int ubi_io_read(const struct ubi_device *ubi, void *buf, int pnum, int offset,
135                 int len)
136 {
137         int err, retries = 0;
138         size_t read;
139         loff_t addr;
140
141         dbg_io("read %d bytes from PEB %d:%d", len, pnum, offset);
142
143         ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
144         ubi_assert(offset >= 0 && offset + len <= ubi->peb_size);
145         ubi_assert(len > 0);
146
147         err = paranoid_check_not_bad(ubi, pnum);
148         if (err)
149                 return err > 0 ? -EINVAL : err;
150
151         addr = (loff_t)pnum * ubi->peb_size + offset;
152 retry:
153         err = ubi->mtd->read(ubi->mtd, addr, len, &read, buf);
154         if (err) {
155                 if (err == -EUCLEAN) {
156                         /*
157                          * -EUCLEAN is reported if there was a bit-flip which
158                          * was corrected, so this is harmless.
159                          *
160                          * We do not report about it here unless debugging is
161                          * enabled. A corresponding message will be printed
162                          * later, when it is has been scrubbed.
163                          */
164                         dbg_msg("fixable bit-flip detected at PEB %d", pnum);
165                         ubi_assert(len == read);
166                         return UBI_IO_BITFLIPS;
167                 }
168
169                 if (read != len && retries++ < UBI_IO_RETRIES) {
170                         dbg_io("error %d while reading %d bytes from PEB %d:%d,"
171                                " read only %zd bytes, retry",
172                                err, len, pnum, offset, read);
173                         yield();
174                         goto retry;
175                 }
176
177                 ubi_err("error %d while reading %d bytes from PEB %d:%d, "
178                         "read %zd bytes", err, len, pnum, offset, read);
179                 ubi_dbg_dump_stack();
180
181                 /*
182                  * The driver should never return -EBADMSG if it failed to read
183                  * all the requested data. But some buggy drivers might do
184                  * this, so we change it to -EIO.
185                  */
186                 if (read != len && err == -EBADMSG) {
187                         ubi_assert(0);
188                         err = -EIO;
189                 }
190         } else {
191                 ubi_assert(len == read);
192
193                 if (ubi_dbg_is_bitflip()) {
194                         dbg_gen("bit-flip (emulated)");
195                         err = UBI_IO_BITFLIPS;
196                 }
197         }
198
199         return err;
200 }
201
202 /**
203  * ubi_io_write - write data to a physical eraseblock.
204  * @ubi: UBI device description object
205  * @buf: buffer with the data to write
206  * @pnum: physical eraseblock number to write to
207  * @offset: offset within the physical eraseblock where to write
208  * @len: how many bytes to write
209  *
210  * This function writes @len bytes of data from buffer @buf to offset @offset
211  * of physical eraseblock @pnum. If all the data were successfully written,
212  * zero is returned. If an error occurred, this function returns a negative
213  * error code. If %-EIO is returned, the physical eraseblock most probably went
214  * bad.
215  *
216  * Note, in case of an error, it is possible that something was still written
217  * to the flash media, but may be some garbage.
218  */
219 int ubi_io_write(struct ubi_device *ubi, const void *buf, int pnum, int offset,
220                  int len)
221 {
222         int err;
223         size_t written;
224         loff_t addr;
225
226         dbg_io("write %d bytes to PEB %d:%d", len, pnum, offset);
227
228         ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
229         ubi_assert(offset >= 0 && offset + len <= ubi->peb_size);
230         ubi_assert(offset % ubi->hdrs_min_io_size == 0);
231         ubi_assert(len > 0 && len % ubi->hdrs_min_io_size == 0);
232
233         if (ubi->ro_mode) {
234                 ubi_err("read-only mode");
235                 return -EROFS;
236         }
237
238         /* The below has to be compiled out if paranoid checks are disabled */
239
240         err = paranoid_check_not_bad(ubi, pnum);
241         if (err)
242                 return err > 0 ? -EINVAL : err;
243
244         /* The area we are writing to has to contain all 0xFF bytes */
245         err = paranoid_check_all_ff(ubi, pnum, offset, len);
246         if (err)
247                 return err > 0 ? -EINVAL : err;
248
249         if (offset >= ubi->leb_start) {
250                 /*
251                  * We write to the data area of the physical eraseblock. Make
252                  * sure it has valid EC and VID headers.
253                  */
254                 err = paranoid_check_peb_ec_hdr(ubi, pnum);
255                 if (err)
256                         return err > 0 ? -EINVAL : err;
257                 err = paranoid_check_peb_vid_hdr(ubi, pnum);
258                 if (err)
259                         return err > 0 ? -EINVAL : err;
260         }
261
262         if (ubi_dbg_is_write_failure()) {
263                 dbg_err("cannot write %d bytes to PEB %d:%d "
264                         "(emulated)", len, pnum, offset);
265                 ubi_dbg_dump_stack();
266                 return -EIO;
267         }
268
269         addr = (loff_t)pnum * ubi->peb_size + offset;
270         err = ubi->mtd->write(ubi->mtd, addr, len, &written, buf);
271         if (err) {
272                 ubi_err("error %d while writing %d bytes to PEB %d:%d, written"
273                         " %zd bytes", err, len, pnum, offset, written);
274                 ubi_dbg_dump_stack();
275         } else
276                 ubi_assert(written == len);
277
278         return err;
279 }
280
281 /**
282  * erase_callback - MTD erasure call-back.
283  * @ei: MTD erase information object.
284  *
285  * Note, even though MTD erase interface is asynchronous, all the current
286  * implementations are synchronous anyway.
287  */
288 static void erase_callback(struct erase_info *ei)
289 {
290         wake_up_interruptible((wait_queue_head_t *)ei->priv);
291 }
292
293 /**
294  * do_sync_erase - synchronously erase a physical eraseblock.
295  * @ubi: UBI device description object
296  * @pnum: the physical eraseblock number to erase
297  *
298  * This function synchronously erases physical eraseblock @pnum and returns
299  * zero in case of success and a negative error code in case of failure. If
300  * %-EIO is returned, the physical eraseblock most probably went bad.
301  */
302 static int do_sync_erase(struct ubi_device *ubi, int pnum)
303 {
304         int err, retries = 0;
305         struct erase_info ei;
306         wait_queue_head_t wq;
307
308         dbg_io("erase PEB %d", pnum);
309
310 retry:
311         init_waitqueue_head(&wq);
312         memset(&ei, 0, sizeof(struct erase_info));
313
314         ei.mtd      = ubi->mtd;
315         ei.addr     = (loff_t)pnum * ubi->peb_size;
316         ei.len      = ubi->peb_size;
317         ei.callback = erase_callback;
318         ei.priv     = (unsigned long)&wq;
319
320         err = ubi->mtd->erase(ubi->mtd, &ei);
321         if (err) {
322                 if (retries++ < UBI_IO_RETRIES) {
323                         dbg_io("error %d while erasing PEB %d, retry",
324                                err, pnum);
325                         yield();
326                         goto retry;
327                 }
328                 ubi_err("cannot erase PEB %d, error %d", pnum, err);
329                 ubi_dbg_dump_stack();
330                 return err;
331         }
332
333         err = wait_event_interruptible(wq, ei.state == MTD_ERASE_DONE ||
334                                            ei.state == MTD_ERASE_FAILED);
335         if (err) {
336                 ubi_err("interrupted PEB %d erasure", pnum);
337                 return -EINTR;
338         }
339
340         if (ei.state == MTD_ERASE_FAILED) {
341                 if (retries++ < UBI_IO_RETRIES) {
342                         dbg_io("error while erasing PEB %d, retry", pnum);
343                         yield();
344                         goto retry;
345                 }
346                 ubi_err("cannot erase PEB %d", pnum);
347                 ubi_dbg_dump_stack();
348                 return -EIO;
349         }
350
351         err = paranoid_check_all_ff(ubi, pnum, 0, ubi->peb_size);
352         if (err)
353                 return err > 0 ? -EINVAL : err;
354
355         if (ubi_dbg_is_erase_failure() && !err) {
356                 dbg_err("cannot erase PEB %d (emulated)", pnum);
357                 return -EIO;
358         }
359
360         return 0;
361 }
362
363 /**
364  * check_pattern - check if buffer contains only a certain byte pattern.
365  * @buf: buffer to check
366  * @patt: the pattern to check
367  * @size: buffer size in bytes
368  *
369  * This function returns %1 in there are only @patt bytes in @buf, and %0 if
370  * something else was also found.
371  */
372 static int check_pattern(const void *buf, uint8_t patt, int size)
373 {
374         int i;
375
376         for (i = 0; i < size; i++)
377                 if (((const uint8_t *)buf)[i] != patt)
378                         return 0;
379         return 1;
380 }
381
382 /* Patterns to write to a physical eraseblock when torturing it */
383 static uint8_t patterns[] = {0xa5, 0x5a, 0x0};
384
385 /**
386  * torture_peb - test a supposedly bad physical eraseblock.
387  * @ubi: UBI device description object
388  * @pnum: the physical eraseblock number to test
389  *
390  * This function returns %-EIO if the physical eraseblock did not pass the
391  * test, a positive number of erase operations done if the test was
392  * successfully passed, and other negative error codes in case of other errors.
393  */
394 static int torture_peb(struct ubi_device *ubi, int pnum)
395 {
396         int err, i, patt_count;
397
398         ubi_msg("run torture test for PEB %d", pnum);
399         patt_count = ARRAY_SIZE(patterns);
400         ubi_assert(patt_count > 0);
401
402         mutex_lock(&ubi->buf_mutex);
403         for (i = 0; i < patt_count; i++) {
404                 err = do_sync_erase(ubi, pnum);
405                 if (err)
406                         goto out;
407
408                 /* Make sure the PEB contains only 0xFF bytes */
409                 err = ubi_io_read(ubi, ubi->peb_buf1, pnum, 0, ubi->peb_size);
410                 if (err)
411                         goto out;
412
413                 err = check_pattern(ubi->peb_buf1, 0xFF, ubi->peb_size);
414                 if (err == 0) {
415                         ubi_err("erased PEB %d, but a non-0xFF byte found",
416                                 pnum);
417                         err = -EIO;
418                         goto out;
419                 }
420
421                 /* Write a pattern and check it */
422                 memset(ubi->peb_buf1, patterns[i], ubi->peb_size);
423                 err = ubi_io_write(ubi, ubi->peb_buf1, pnum, 0, ubi->peb_size);
424                 if (err)
425                         goto out;
426
427                 memset(ubi->peb_buf1, ~patterns[i], ubi->peb_size);
428                 err = ubi_io_read(ubi, ubi->peb_buf1, pnum, 0, ubi->peb_size);
429                 if (err)
430                         goto out;
431
432                 err = check_pattern(ubi->peb_buf1, patterns[i], ubi->peb_size);
433                 if (err == 0) {
434                         ubi_err("pattern %x checking failed for PEB %d",
435                                 patterns[i], pnum);
436                         err = -EIO;
437                         goto out;
438                 }
439         }
440
441         err = patt_count;
442         ubi_msg("PEB %d passed torture test, do not mark it a bad", pnum);
443
444 out:
445         mutex_unlock(&ubi->buf_mutex);
446         if (err == UBI_IO_BITFLIPS || err == -EBADMSG) {
447                 /*
448                  * If a bit-flip or data integrity error was detected, the test
449                  * has not passed because it happened on a freshly erased
450                  * physical eraseblock which means something is wrong with it.
451                  */
452                 ubi_err("read problems on freshly erased PEB %d, must be bad",
453                         pnum);
454                 err = -EIO;
455         }
456         return err;
457 }
458
459 /**
460  * ubi_io_sync_erase - synchronously erase a physical eraseblock.
461  * @ubi: UBI device description object
462  * @pnum: physical eraseblock number to erase
463  * @torture: if this physical eraseblock has to be tortured
464  *
465  * This function synchronously erases physical eraseblock @pnum. If @torture
466  * flag is not zero, the physical eraseblock is checked by means of writing
467  * different patterns to it and reading them back. If the torturing is enabled,
468  * the physical eraseblock is erased more then once.
469  *
470  * This function returns the number of erasures made in case of success, %-EIO
471  * if the erasure failed or the torturing test failed, and other negative error
472  * codes in case of other errors. Note, %-EIO means that the physical
473  * eraseblock is bad.
474  */
475 int ubi_io_sync_erase(struct ubi_device *ubi, int pnum, int torture)
476 {
477         int err, ret = 0;
478
479         ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
480
481         err = paranoid_check_not_bad(ubi, pnum);
482         if (err != 0)
483                 return err > 0 ? -EINVAL : err;
484
485         if (ubi->ro_mode) {
486                 ubi_err("read-only mode");
487                 return -EROFS;
488         }
489
490         if (torture) {
491                 ret = torture_peb(ubi, pnum);
492                 if (ret < 0)
493                         return ret;
494         }
495
496         err = do_sync_erase(ubi, pnum);
497         if (err)
498                 return err;
499
500         return ret + 1;
501 }
502
503 /**
504  * ubi_io_is_bad - check if a physical eraseblock is bad.
505  * @ubi: UBI device description object
506  * @pnum: the physical eraseblock number to check
507  *
508  * This function returns a positive number if the physical eraseblock is bad,
509  * zero if not, and a negative error code if an error occurred.
510  */
511 int ubi_io_is_bad(const struct ubi_device *ubi, int pnum)
512 {
513         struct mtd_info *mtd = ubi->mtd;
514
515         ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
516
517         if (ubi->bad_allowed) {
518                 int ret;
519
520                 ret = mtd->block_isbad(mtd, (loff_t)pnum * ubi->peb_size);
521                 if (ret < 0)
522                         ubi_err("error %d while checking if PEB %d is bad",
523                                 ret, pnum);
524                 else if (ret)
525                         dbg_io("PEB %d is bad", pnum);
526                 return ret;
527         }
528
529         return 0;
530 }
531
532 /**
533  * ubi_io_mark_bad - mark a physical eraseblock as bad.
534  * @ubi: UBI device description object
535  * @pnum: the physical eraseblock number to mark
536  *
537  * This function returns zero in case of success and a negative error code in
538  * case of failure.
539  */
540 int ubi_io_mark_bad(const struct ubi_device *ubi, int pnum)
541 {
542         int err;
543         struct mtd_info *mtd = ubi->mtd;
544
545         ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
546
547         if (ubi->ro_mode) {
548                 ubi_err("read-only mode");
549                 return -EROFS;
550         }
551
552         if (!ubi->bad_allowed)
553                 return 0;
554
555         err = mtd->block_markbad(mtd, (loff_t)pnum * ubi->peb_size);
556         if (err)
557                 ubi_err("cannot mark PEB %d bad, error %d", pnum, err);
558         return err;
559 }
560
561 /**
562  * validate_ec_hdr - validate an erase counter header.
563  * @ubi: UBI device description object
564  * @ec_hdr: the erase counter header to check
565  *
566  * This function returns zero if the erase counter header is OK, and %1 if
567  * not.
568  */
569 static int validate_ec_hdr(const struct ubi_device *ubi,
570                            const struct ubi_ec_hdr *ec_hdr)
571 {
572         long long ec;
573         int vid_hdr_offset, leb_start;
574
575         ec = be64_to_cpu(ec_hdr->ec);
576         vid_hdr_offset = be32_to_cpu(ec_hdr->vid_hdr_offset);
577         leb_start = be32_to_cpu(ec_hdr->data_offset);
578
579         if (ec_hdr->version != UBI_VERSION) {
580                 ubi_err("node with incompatible UBI version found: "
581                         "this UBI version is %d, image version is %d",
582                         UBI_VERSION, (int)ec_hdr->version);
583                 goto bad;
584         }
585
586         if (vid_hdr_offset != ubi->vid_hdr_offset) {
587                 ubi_err("bad VID header offset %d, expected %d",
588                         vid_hdr_offset, ubi->vid_hdr_offset);
589                 goto bad;
590         }
591
592         if (leb_start != ubi->leb_start) {
593                 ubi_err("bad data offset %d, expected %d",
594                         leb_start, ubi->leb_start);
595                 goto bad;
596         }
597
598         if (ec < 0 || ec > UBI_MAX_ERASECOUNTER) {
599                 ubi_err("bad erase counter %lld", ec);
600                 goto bad;
601         }
602
603         return 0;
604
605 bad:
606         ubi_err("bad EC header");
607         ubi_dbg_dump_ec_hdr(ec_hdr);
608         ubi_dbg_dump_stack();
609         return 1;
610 }
611
612 /**
613  * ubi_io_read_ec_hdr - read and check an erase counter header.
614  * @ubi: UBI device description object
615  * @pnum: physical eraseblock to read from
616  * @ec_hdr: a &struct ubi_ec_hdr object where to store the read erase counter
617  * header
618  * @verbose: be verbose if the header is corrupted or was not found
619  *
620  * This function reads erase counter header from physical eraseblock @pnum and
621  * stores it in @ec_hdr. This function also checks CRC checksum of the read
622  * erase counter header. The following codes may be returned:
623  *
624  * o %0 if the CRC checksum is correct and the header was successfully read;
625  * o %UBI_IO_BITFLIPS if the CRC is correct, but bit-flips were detected
626  *   and corrected by the flash driver; this is harmless but may indicate that
627  *   this eraseblock may become bad soon (but may be not);
628  * o %UBI_IO_BAD_EC_HDR if the erase counter header is corrupted (a CRC error);
629  * o %UBI_IO_PEB_EMPTY if the physical eraseblock is empty;
630  * o a negative error code in case of failure.
631  */
632 int ubi_io_read_ec_hdr(struct ubi_device *ubi, int pnum,
633                        struct ubi_ec_hdr *ec_hdr, int verbose)
634 {
635         int err, read_err = 0;
636         uint32_t crc, magic, hdr_crc;
637
638         dbg_io("read EC header from PEB %d", pnum);
639         ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
640         if (UBI_IO_DEBUG)
641                 verbose = 1;
642
643         err = ubi_io_read(ubi, ec_hdr, pnum, 0, UBI_EC_HDR_SIZE);
644         if (err) {
645                 if (err != UBI_IO_BITFLIPS && err != -EBADMSG)
646                         return err;
647
648                 /*
649                  * We read all the data, but either a correctable bit-flip
650                  * occurred, or MTD reported about some data integrity error,
651                  * like an ECC error in case of NAND. The former is harmless,
652                  * the later may mean that the read data is corrupted. But we
653                  * have a CRC check-sum and we will detect this. If the EC
654                  * header is still OK, we just report this as there was a
655                  * bit-flip.
656                  */
657                 read_err = err;
658         }
659
660         magic = be32_to_cpu(ec_hdr->magic);
661         if (magic != UBI_EC_HDR_MAGIC) {
662                 /*
663                  * The magic field is wrong. Let's check if we have read all
664                  * 0xFF. If yes, this physical eraseblock is assumed to be
665                  * empty.
666                  *
667                  * But if there was a read error, we do not test it for all
668                  * 0xFFs. Even if it does contain all 0xFFs, this error
669                  * indicates that something is still wrong with this physical
670                  * eraseblock and we anyway cannot treat it as empty.
671                  */
672                 if (read_err != -EBADMSG &&
673                     check_pattern(ec_hdr, 0xFF, UBI_EC_HDR_SIZE)) {
674                         /* The physical eraseblock is supposedly empty */
675
676                         /*
677                          * The below is just a paranoid check, it has to be
678                          * compiled out if paranoid checks are disabled.
679                          */
680                         err = paranoid_check_all_ff(ubi, pnum, 0,
681                                                     ubi->peb_size);
682                         if (err)
683                                 return err > 0 ? UBI_IO_BAD_EC_HDR : err;
684
685                         if (verbose)
686                                 ubi_warn("no EC header found at PEB %d, "
687                                          "only 0xFF bytes", pnum);
688                         return UBI_IO_PEB_EMPTY;
689                 }
690
691                 /*
692                  * This is not a valid erase counter header, and these are not
693                  * 0xFF bytes. Report that the header is corrupted.
694                  */
695                 if (verbose) {
696                         ubi_warn("bad magic number at PEB %d: %08x instead of "
697                                  "%08x", pnum, magic, UBI_EC_HDR_MAGIC);
698                         ubi_dbg_dump_ec_hdr(ec_hdr);
699                 }
700                 return UBI_IO_BAD_EC_HDR;
701         }
702
703         crc = crc32(UBI_CRC32_INIT, ec_hdr, UBI_EC_HDR_SIZE_CRC);
704         hdr_crc = be32_to_cpu(ec_hdr->hdr_crc);
705
706         if (hdr_crc != crc) {
707                 if (verbose) {
708                         ubi_warn("bad EC header CRC at PEB %d, calculated "
709                                  "%#08x, read %#08x", pnum, crc, hdr_crc);
710                         ubi_dbg_dump_ec_hdr(ec_hdr);
711                 }
712                 return UBI_IO_BAD_EC_HDR;
713         }
714
715         /* And of course validate what has just been read from the media */
716         err = validate_ec_hdr(ubi, ec_hdr);
717         if (err) {
718                 ubi_err("validation failed for PEB %d", pnum);
719                 return -EINVAL;
720         }
721
722         return read_err ? UBI_IO_BITFLIPS : 0;
723 }
724
725 /**
726  * ubi_io_write_ec_hdr - write an erase counter header.
727  * @ubi: UBI device description object
728  * @pnum: physical eraseblock to write to
729  * @ec_hdr: the erase counter header to write
730  *
731  * This function writes erase counter header described by @ec_hdr to physical
732  * eraseblock @pnum. It also fills most fields of @ec_hdr before writing, so
733  * the caller do not have to fill them. Callers must only fill the @ec_hdr->ec
734  * field.
735  *
736  * This function returns zero in case of success and a negative error code in
737  * case of failure. If %-EIO is returned, the physical eraseblock most probably
738  * went bad.
739  */
740 int ubi_io_write_ec_hdr(struct ubi_device *ubi, int pnum,
741                         struct ubi_ec_hdr *ec_hdr)
742 {
743         int err;
744         uint32_t crc;
745
746         dbg_io("write EC header to PEB %d", pnum);
747         ubi_assert(pnum >= 0 &&  pnum < ubi->peb_count);
748
749         ec_hdr->magic = cpu_to_be32(UBI_EC_HDR_MAGIC);
750         ec_hdr->version = UBI_VERSION;
751         ec_hdr->vid_hdr_offset = cpu_to_be32(ubi->vid_hdr_offset);
752         ec_hdr->data_offset = cpu_to_be32(ubi->leb_start);
753         crc = crc32(UBI_CRC32_INIT, ec_hdr, UBI_EC_HDR_SIZE_CRC);
754         ec_hdr->hdr_crc = cpu_to_be32(crc);
755
756         err = paranoid_check_ec_hdr(ubi, pnum, ec_hdr);
757         if (err)
758                 return -EINVAL;
759
760         err = ubi_io_write(ubi, ec_hdr, pnum, 0, ubi->ec_hdr_alsize);
761         return err;
762 }
763
764 /**
765  * validate_vid_hdr - validate a volume identifier header.
766  * @ubi: UBI device description object
767  * @vid_hdr: the volume identifier header to check
768  *
769  * This function checks that data stored in the volume identifier header
770  * @vid_hdr. Returns zero if the VID header is OK and %1 if not.
771  */
772 static int validate_vid_hdr(const struct ubi_device *ubi,
773                             const struct ubi_vid_hdr *vid_hdr)
774 {
775         int vol_type = vid_hdr->vol_type;
776         int copy_flag = vid_hdr->copy_flag;
777         int vol_id = be32_to_cpu(vid_hdr->vol_id);
778         int lnum = be32_to_cpu(vid_hdr->lnum);
779         int compat = vid_hdr->compat;
780         int data_size = be32_to_cpu(vid_hdr->data_size);
781         int used_ebs = be32_to_cpu(vid_hdr->used_ebs);
782         int data_pad = be32_to_cpu(vid_hdr->data_pad);
783         int data_crc = be32_to_cpu(vid_hdr->data_crc);
784         int usable_leb_size = ubi->leb_size - data_pad;
785
786         if (copy_flag != 0 && copy_flag != 1) {
787                 dbg_err("bad copy_flag");
788                 goto bad;
789         }
790
791         if (vol_id < 0 || lnum < 0 || data_size < 0 || used_ebs < 0 ||
792             data_pad < 0) {
793                 dbg_err("negative values");
794                 goto bad;
795         }
796
797         if (vol_id >= UBI_MAX_VOLUMES && vol_id < UBI_INTERNAL_VOL_START) {
798                 dbg_err("bad vol_id");
799                 goto bad;
800         }
801
802         if (vol_id < UBI_INTERNAL_VOL_START && compat != 0) {
803                 dbg_err("bad compat");
804                 goto bad;
805         }
806
807         if (vol_id >= UBI_INTERNAL_VOL_START && compat != UBI_COMPAT_DELETE &&
808             compat != UBI_COMPAT_RO && compat != UBI_COMPAT_PRESERVE &&
809             compat != UBI_COMPAT_REJECT) {
810                 dbg_err("bad compat");
811                 goto bad;
812         }
813
814         if (vol_type != UBI_VID_DYNAMIC && vol_type != UBI_VID_STATIC) {
815                 dbg_err("bad vol_type");
816                 goto bad;
817         }
818
819         if (data_pad >= ubi->leb_size / 2) {
820                 dbg_err("bad data_pad");
821                 goto bad;
822         }
823
824         if (vol_type == UBI_VID_STATIC) {
825                 /*
826                  * Although from high-level point of view static volumes may
827                  * contain zero bytes of data, but no VID headers can contain
828                  * zero at these fields, because they empty volumes do not have
829                  * mapped logical eraseblocks.
830                  */
831                 if (used_ebs == 0) {
832                         dbg_err("zero used_ebs");
833                         goto bad;
834                 }
835                 if (data_size == 0) {
836                         dbg_err("zero data_size");
837                         goto bad;
838                 }
839                 if (lnum < used_ebs - 1) {
840                         if (data_size != usable_leb_size) {
841                                 dbg_err("bad data_size");
842                                 goto bad;
843                         }
844                 } else if (lnum == used_ebs - 1) {
845                         if (data_size == 0) {
846                                 dbg_err("bad data_size at last LEB");
847                                 goto bad;
848                         }
849                 } else {
850                         dbg_err("too high lnum");
851                         goto bad;
852                 }
853         } else {
854                 if (copy_flag == 0) {
855                         if (data_crc != 0) {
856                                 dbg_err("non-zero data CRC");
857                                 goto bad;
858                         }
859                         if (data_size != 0) {
860                                 dbg_err("non-zero data_size");
861                                 goto bad;
862                         }
863                 } else {
864                         if (data_size == 0) {
865                                 dbg_err("zero data_size of copy");
866                                 goto bad;
867                         }
868                 }
869                 if (used_ebs != 0) {
870                         dbg_err("bad used_ebs");
871                         goto bad;
872                 }
873         }
874
875         return 0;
876
877 bad:
878         ubi_err("bad VID header");
879         ubi_dbg_dump_vid_hdr(vid_hdr);
880         ubi_dbg_dump_stack();
881         return 1;
882 }
883
884 /**
885  * ubi_io_read_vid_hdr - read and check a volume identifier header.
886  * @ubi: UBI device description object
887  * @pnum: physical eraseblock number to read from
888  * @vid_hdr: &struct ubi_vid_hdr object where to store the read volume
889  * identifier header
890  * @verbose: be verbose if the header is corrupted or wasn't found
891  *
892  * This function reads the volume identifier header from physical eraseblock
893  * @pnum and stores it in @vid_hdr. It also checks CRC checksum of the read
894  * volume identifier header. The following codes may be returned:
895  *
896  * o %0 if the CRC checksum is correct and the header was successfully read;
897  * o %UBI_IO_BITFLIPS if the CRC is correct, but bit-flips were detected
898  *   and corrected by the flash driver; this is harmless but may indicate that
899  *   this eraseblock may become bad soon;
900  * o %UBI_IO_BAD_VID_HRD if the volume identifier header is corrupted (a CRC
901  *   error detected);
902  * o %UBI_IO_PEB_FREE if the physical eraseblock is free (i.e., there is no VID
903  *   header there);
904  * o a negative error code in case of failure.
905  */
906 int ubi_io_read_vid_hdr(struct ubi_device *ubi, int pnum,
907                         struct ubi_vid_hdr *vid_hdr, int verbose)
908 {
909         int err, read_err = 0;
910         uint32_t crc, magic, hdr_crc;
911         void *p;
912
913         dbg_io("read VID header from PEB %d", pnum);
914         ubi_assert(pnum >= 0 &&  pnum < ubi->peb_count);
915         if (UBI_IO_DEBUG)
916                 verbose = 1;
917
918         p = (char *)vid_hdr - ubi->vid_hdr_shift;
919         err = ubi_io_read(ubi, p, pnum, ubi->vid_hdr_aloffset,
920                           ubi->vid_hdr_alsize);
921         if (err) {
922                 if (err != UBI_IO_BITFLIPS && err != -EBADMSG)
923                         return err;
924
925                 /*
926                  * We read all the data, but either a correctable bit-flip
927                  * occurred, or MTD reported about some data integrity error,
928                  * like an ECC error in case of NAND. The former is harmless,
929                  * the later may mean the read data is corrupted. But we have a
930                  * CRC check-sum and we will identify this. If the VID header is
931                  * still OK, we just report this as there was a bit-flip.
932                  */
933                 read_err = err;
934         }
935
936         magic = be32_to_cpu(vid_hdr->magic);
937         if (magic != UBI_VID_HDR_MAGIC) {
938                 /*
939                  * If we have read all 0xFF bytes, the VID header probably does
940                  * not exist and the physical eraseblock is assumed to be free.
941                  *
942                  * But if there was a read error, we do not test the data for
943                  * 0xFFs. Even if it does contain all 0xFFs, this error
944                  * indicates that something is still wrong with this physical
945                  * eraseblock and it cannot be regarded as free.
946                  */
947                 if (read_err != -EBADMSG &&
948                     check_pattern(vid_hdr, 0xFF, UBI_VID_HDR_SIZE)) {
949                         /* The physical eraseblock is supposedly free */
950
951                         /*
952                          * The below is just a paranoid check, it has to be
953                          * compiled out if paranoid checks are disabled.
954                          */
955                         err = paranoid_check_all_ff(ubi, pnum, ubi->leb_start,
956                                                     ubi->leb_size);
957                         if (err)
958                                 return err > 0 ? UBI_IO_BAD_VID_HDR : err;
959
960                         if (verbose)
961                                 ubi_warn("no VID header found at PEB %d, "
962                                          "only 0xFF bytes", pnum);
963                         return UBI_IO_PEB_FREE;
964                 }
965
966                 /*
967                  * This is not a valid VID header, and these are not 0xFF
968                  * bytes. Report that the header is corrupted.
969                  */
970                 if (verbose) {
971                         ubi_warn("bad magic number at PEB %d: %08x instead of "
972                                  "%08x", pnum, magic, UBI_VID_HDR_MAGIC);
973                         ubi_dbg_dump_vid_hdr(vid_hdr);
974                 }
975                 return UBI_IO_BAD_VID_HDR;
976         }
977
978         crc = crc32(UBI_CRC32_INIT, vid_hdr, UBI_VID_HDR_SIZE_CRC);
979         hdr_crc = be32_to_cpu(vid_hdr->hdr_crc);
980
981         if (hdr_crc != crc) {
982                 if (verbose) {
983                         ubi_warn("bad CRC at PEB %d, calculated %#08x, "
984                                  "read %#08x", pnum, crc, hdr_crc);
985                         ubi_dbg_dump_vid_hdr(vid_hdr);
986                 }
987                 return UBI_IO_BAD_VID_HDR;
988         }
989
990         /* Validate the VID header that we have just read */
991         err = validate_vid_hdr(ubi, vid_hdr);
992         if (err) {
993                 ubi_err("validation failed for PEB %d", pnum);
994                 return -EINVAL;
995         }
996
997         return read_err ? UBI_IO_BITFLIPS : 0;
998 }
999
1000 /**
1001  * ubi_io_write_vid_hdr - write a volume identifier header.
1002  * @ubi: UBI device description object
1003  * @pnum: the physical eraseblock number to write to
1004  * @vid_hdr: the volume identifier header to write
1005  *
1006  * This function writes the volume identifier header described by @vid_hdr to
1007  * physical eraseblock @pnum. This function automatically fills the
1008  * @vid_hdr->magic and the @vid_hdr->version fields, as well as calculates
1009  * header CRC checksum and stores it at vid_hdr->hdr_crc.
1010  *
1011  * This function returns zero in case of success and a negative error code in
1012  * case of failure. If %-EIO is returned, the physical eraseblock probably went
1013  * bad.
1014  */
1015 int ubi_io_write_vid_hdr(struct ubi_device *ubi, int pnum,
1016                          struct ubi_vid_hdr *vid_hdr)
1017 {
1018         int err;
1019         uint32_t crc;
1020         void *p;
1021
1022         dbg_io("write VID header to PEB %d", pnum);
1023         ubi_assert(pnum >= 0 &&  pnum < ubi->peb_count);
1024
1025         err = paranoid_check_peb_ec_hdr(ubi, pnum);
1026         if (err)
1027                 return err > 0 ? -EINVAL: err;
1028
1029         vid_hdr->magic = cpu_to_be32(UBI_VID_HDR_MAGIC);
1030         vid_hdr->version = UBI_VERSION;
1031         crc = crc32(UBI_CRC32_INIT, vid_hdr, UBI_VID_HDR_SIZE_CRC);
1032         vid_hdr->hdr_crc = cpu_to_be32(crc);
1033
1034         err = paranoid_check_vid_hdr(ubi, pnum, vid_hdr);
1035         if (err)
1036                 return -EINVAL;
1037
1038         p = (char *)vid_hdr - ubi->vid_hdr_shift;
1039         err = ubi_io_write(ubi, p, pnum, ubi->vid_hdr_aloffset,
1040                            ubi->vid_hdr_alsize);
1041         return err;
1042 }
1043
1044 #ifdef CONFIG_MTD_UBI_DEBUG_PARANOID
1045
1046 /**
1047  * paranoid_check_not_bad - ensure that a physical eraseblock is not bad.
1048  * @ubi: UBI device description object
1049  * @pnum: physical eraseblock number to check
1050  *
1051  * This function returns zero if the physical eraseblock is good, a positive
1052  * number if it is bad and a negative error code if an error occurred.
1053  */
1054 static int paranoid_check_not_bad(const struct ubi_device *ubi, int pnum)
1055 {
1056         int err;
1057
1058         err = ubi_io_is_bad(ubi, pnum);
1059         if (!err)
1060                 return err;
1061
1062         ubi_err("paranoid check failed for PEB %d", pnum);
1063         ubi_dbg_dump_stack();
1064         return err;
1065 }
1066
1067 /**
1068  * paranoid_check_ec_hdr - check if an erase counter header is all right.
1069  * @ubi: UBI device description object
1070  * @pnum: physical eraseblock number the erase counter header belongs to
1071  * @ec_hdr: the erase counter header to check
1072  *
1073  * This function returns zero if the erase counter header contains valid
1074  * values, and %1 if not.
1075  */
1076 static int paranoid_check_ec_hdr(const struct ubi_device *ubi, int pnum,
1077                                  const struct ubi_ec_hdr *ec_hdr)
1078 {
1079         int err;
1080         uint32_t magic;
1081
1082         magic = be32_to_cpu(ec_hdr->magic);
1083         if (magic != UBI_EC_HDR_MAGIC) {
1084                 ubi_err("bad magic %#08x, must be %#08x",
1085                         magic, UBI_EC_HDR_MAGIC);
1086                 goto fail;
1087         }
1088
1089         err = validate_ec_hdr(ubi, ec_hdr);
1090         if (err) {
1091                 ubi_err("paranoid check failed for PEB %d", pnum);
1092                 goto fail;
1093         }
1094
1095         return 0;
1096
1097 fail:
1098         ubi_dbg_dump_ec_hdr(ec_hdr);
1099         ubi_dbg_dump_stack();
1100         return 1;
1101 }
1102
1103 /**
1104  * paranoid_check_peb_ec_hdr - check erase counter header.
1105  * @ubi: UBI device description object
1106  * @pnum: the physical eraseblock number to check
1107  *
1108  * This function returns zero if the erase counter header is all right, %1 if
1109  * not, and a negative error code if an error occurred.
1110  */
1111 static int paranoid_check_peb_ec_hdr(const struct ubi_device *ubi, int pnum)
1112 {
1113         int err;
1114         uint32_t crc, hdr_crc;
1115         struct ubi_ec_hdr *ec_hdr;
1116
1117         ec_hdr = kzalloc(ubi->ec_hdr_alsize, GFP_NOFS);
1118         if (!ec_hdr)
1119                 return -ENOMEM;
1120
1121         err = ubi_io_read(ubi, ec_hdr, pnum, 0, UBI_EC_HDR_SIZE);
1122         if (err && err != UBI_IO_BITFLIPS && err != -EBADMSG)
1123                 goto exit;
1124
1125         crc = crc32(UBI_CRC32_INIT, ec_hdr, UBI_EC_HDR_SIZE_CRC);
1126         hdr_crc = be32_to_cpu(ec_hdr->hdr_crc);
1127         if (hdr_crc != crc) {
1128                 ubi_err("bad CRC, calculated %#08x, read %#08x", crc, hdr_crc);
1129                 ubi_err("paranoid check failed for PEB %d", pnum);
1130                 ubi_dbg_dump_ec_hdr(ec_hdr);
1131                 ubi_dbg_dump_stack();
1132                 err = 1;
1133                 goto exit;
1134         }
1135
1136         err = paranoid_check_ec_hdr(ubi, pnum, ec_hdr);
1137
1138 exit:
1139         kfree(ec_hdr);
1140         return err;
1141 }
1142
1143 /**
1144  * paranoid_check_vid_hdr - check that a volume identifier header is all right.
1145  * @ubi: UBI device description object
1146  * @pnum: physical eraseblock number the volume identifier header belongs to
1147  * @vid_hdr: the volume identifier header to check
1148  *
1149  * This function returns zero if the volume identifier header is all right, and
1150  * %1 if not.
1151  */
1152 static int paranoid_check_vid_hdr(const struct ubi_device *ubi, int pnum,
1153                                   const struct ubi_vid_hdr *vid_hdr)
1154 {
1155         int err;
1156         uint32_t magic;
1157
1158         magic = be32_to_cpu(vid_hdr->magic);
1159         if (magic != UBI_VID_HDR_MAGIC) {
1160                 ubi_err("bad VID header magic %#08x at PEB %d, must be %#08x",
1161                         magic, pnum, UBI_VID_HDR_MAGIC);
1162                 goto fail;
1163         }
1164
1165         err = validate_vid_hdr(ubi, vid_hdr);
1166         if (err) {
1167                 ubi_err("paranoid check failed for PEB %d", pnum);
1168                 goto fail;
1169         }
1170
1171         return err;
1172
1173 fail:
1174         ubi_err("paranoid check failed for PEB %d", pnum);
1175         ubi_dbg_dump_vid_hdr(vid_hdr);
1176         ubi_dbg_dump_stack();
1177         return 1;
1178
1179 }
1180
1181 /**
1182  * paranoid_check_peb_vid_hdr - check volume identifier header.
1183  * @ubi: UBI device description object
1184  * @pnum: the physical eraseblock number to check
1185  *
1186  * This function returns zero if the volume identifier header is all right,
1187  * %1 if not, and a negative error code if an error occurred.
1188  */
1189 static int paranoid_check_peb_vid_hdr(const struct ubi_device *ubi, int pnum)
1190 {
1191         int err;
1192         uint32_t crc, hdr_crc;
1193         struct ubi_vid_hdr *vid_hdr;
1194         void *p;
1195
1196         vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS);
1197         if (!vid_hdr)
1198                 return -ENOMEM;
1199
1200         p = (char *)vid_hdr - ubi->vid_hdr_shift;
1201         err = ubi_io_read(ubi, p, pnum, ubi->vid_hdr_aloffset,
1202                           ubi->vid_hdr_alsize);
1203         if (err && err != UBI_IO_BITFLIPS && err != -EBADMSG)
1204                 goto exit;
1205
1206         crc = crc32(UBI_CRC32_INIT, vid_hdr, UBI_EC_HDR_SIZE_CRC);
1207         hdr_crc = be32_to_cpu(vid_hdr->hdr_crc);
1208         if (hdr_crc != crc) {
1209                 ubi_err("bad VID header CRC at PEB %d, calculated %#08x, "
1210                         "read %#08x", pnum, crc, hdr_crc);
1211                 ubi_err("paranoid check failed for PEB %d", pnum);
1212                 ubi_dbg_dump_vid_hdr(vid_hdr);
1213                 ubi_dbg_dump_stack();
1214                 err = 1;
1215                 goto exit;
1216         }
1217
1218         err = paranoid_check_vid_hdr(ubi, pnum, vid_hdr);
1219
1220 exit:
1221         ubi_free_vid_hdr(ubi, vid_hdr);
1222         return err;
1223 }
1224
1225 /**
1226  * paranoid_check_all_ff - check that a region of flash is empty.
1227  * @ubi: UBI device description object
1228  * @pnum: the physical eraseblock number to check
1229  * @offset: the starting offset within the physical eraseblock to check
1230  * @len: the length of the region to check
1231  *
1232  * This function returns zero if only 0xFF bytes are present at offset
1233  * @offset of the physical eraseblock @pnum, %1 if not, and a negative error
1234  * code if an error occurred.
1235  */
1236 static int paranoid_check_all_ff(struct ubi_device *ubi, int pnum, int offset,
1237                                  int len)
1238 {
1239         size_t read;
1240         int err;
1241         loff_t addr = (loff_t)pnum * ubi->peb_size + offset;
1242
1243         mutex_lock(&ubi->dbg_buf_mutex);
1244         err = ubi->mtd->read(ubi->mtd, addr, len, &read, ubi->dbg_peb_buf);
1245         if (err && err != -EUCLEAN) {
1246                 ubi_err("error %d while reading %d bytes from PEB %d:%d, "
1247                         "read %zd bytes", err, len, pnum, offset, read);
1248                 goto error;
1249         }
1250
1251         err = check_pattern(ubi->dbg_peb_buf, 0xFF, len);
1252         if (err == 0) {
1253                 ubi_err("flash region at PEB %d:%d, length %d does not "
1254                         "contain all 0xFF bytes", pnum, offset, len);
1255                 goto fail;
1256         }
1257         mutex_unlock(&ubi->dbg_buf_mutex);
1258
1259         return 0;
1260
1261 fail:
1262         ubi_err("paranoid check failed for PEB %d", pnum);
1263         ubi_msg("hex dump of the %d-%d region", offset, offset + len);
1264         print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1,
1265                        ubi->dbg_peb_buf, len, 1);
1266         err = 1;
1267 error:
1268         ubi_dbg_dump_stack();
1269         mutex_unlock(&ubi->dbg_buf_mutex);
1270         return err;
1271 }
1272
1273 #endif /* CONFIG_MTD_UBI_DEBUG_PARANOID */