mac80211: unify config_interface and bss_info_changed
[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 than 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
641         err = ubi_io_read(ubi, ec_hdr, pnum, 0, UBI_EC_HDR_SIZE);
642         if (err) {
643                 if (err != UBI_IO_BITFLIPS && err != -EBADMSG)
644                         return err;
645
646                 /*
647                  * We read all the data, but either a correctable bit-flip
648                  * occurred, or MTD reported about some data integrity error,
649                  * like an ECC error in case of NAND. The former is harmless,
650                  * the later may mean that the read data is corrupted. But we
651                  * have a CRC check-sum and we will detect this. If the EC
652                  * header is still OK, we just report this as there was a
653                  * bit-flip.
654                  */
655                 read_err = err;
656         }
657
658         magic = be32_to_cpu(ec_hdr->magic);
659         if (magic != UBI_EC_HDR_MAGIC) {
660                 /*
661                  * The magic field is wrong. Let's check if we have read all
662                  * 0xFF. If yes, this physical eraseblock is assumed to be
663                  * empty.
664                  *
665                  * But if there was a read error, we do not test it for all
666                  * 0xFFs. Even if it does contain all 0xFFs, this error
667                  * indicates that something is still wrong with this physical
668                  * eraseblock and we anyway cannot treat it as empty.
669                  */
670                 if (read_err != -EBADMSG &&
671                     check_pattern(ec_hdr, 0xFF, UBI_EC_HDR_SIZE)) {
672                         /* The physical eraseblock is supposedly empty */
673
674                         /*
675                          * The below is just a paranoid check, it has to be
676                          * compiled out if paranoid checks are disabled.
677                          */
678                         err = paranoid_check_all_ff(ubi, pnum, 0,
679                                                     ubi->peb_size);
680                         if (err)
681                                 return err > 0 ? UBI_IO_BAD_EC_HDR : err;
682
683                         if (verbose)
684                                 ubi_warn("no EC header found at PEB %d, "
685                                          "only 0xFF bytes", pnum);
686                         else if (UBI_IO_DEBUG)
687                                 dbg_msg("no EC header found at PEB %d, "
688                                         "only 0xFF bytes", pnum);
689                         return UBI_IO_PEB_EMPTY;
690                 }
691
692                 /*
693                  * This is not a valid erase counter header, and these are not
694                  * 0xFF bytes. Report that the header is corrupted.
695                  */
696                 if (verbose) {
697                         ubi_warn("bad magic number at PEB %d: %08x instead of "
698                                  "%08x", pnum, magic, UBI_EC_HDR_MAGIC);
699                         ubi_dbg_dump_ec_hdr(ec_hdr);
700                 } else if (UBI_IO_DEBUG)
701                         dbg_msg("bad magic number at PEB %d: %08x instead of "
702                                 "%08x", pnum, magic, UBI_EC_HDR_MAGIC);
703                 return UBI_IO_BAD_EC_HDR;
704         }
705
706         crc = crc32(UBI_CRC32_INIT, ec_hdr, UBI_EC_HDR_SIZE_CRC);
707         hdr_crc = be32_to_cpu(ec_hdr->hdr_crc);
708
709         if (hdr_crc != crc) {
710                 if (verbose) {
711                         ubi_warn("bad EC header CRC at PEB %d, calculated "
712                                  "%#08x, read %#08x", pnum, crc, hdr_crc);
713                         ubi_dbg_dump_ec_hdr(ec_hdr);
714                 } else if (UBI_IO_DEBUG)
715                         dbg_msg("bad EC header CRC at PEB %d, calculated "
716                                 "%#08x, read %#08x", pnum, crc, hdr_crc);
717                 return UBI_IO_BAD_EC_HDR;
718         }
719
720         /* And of course validate what has just been read from the media */
721         err = validate_ec_hdr(ubi, ec_hdr);
722         if (err) {
723                 ubi_err("validation failed for PEB %d", pnum);
724                 return -EINVAL;
725         }
726
727         return read_err ? UBI_IO_BITFLIPS : 0;
728 }
729
730 /**
731  * ubi_io_write_ec_hdr - write an erase counter header.
732  * @ubi: UBI device description object
733  * @pnum: physical eraseblock to write to
734  * @ec_hdr: the erase counter header to write
735  *
736  * This function writes erase counter header described by @ec_hdr to physical
737  * eraseblock @pnum. It also fills most fields of @ec_hdr before writing, so
738  * the caller do not have to fill them. Callers must only fill the @ec_hdr->ec
739  * field.
740  *
741  * This function returns zero in case of success and a negative error code in
742  * case of failure. If %-EIO is returned, the physical eraseblock most probably
743  * went bad.
744  */
745 int ubi_io_write_ec_hdr(struct ubi_device *ubi, int pnum,
746                         struct ubi_ec_hdr *ec_hdr)
747 {
748         int err;
749         uint32_t crc;
750
751         dbg_io("write EC header to PEB %d", pnum);
752         ubi_assert(pnum >= 0 &&  pnum < ubi->peb_count);
753
754         ec_hdr->magic = cpu_to_be32(UBI_EC_HDR_MAGIC);
755         ec_hdr->version = UBI_VERSION;
756         ec_hdr->vid_hdr_offset = cpu_to_be32(ubi->vid_hdr_offset);
757         ec_hdr->data_offset = cpu_to_be32(ubi->leb_start);
758         crc = crc32(UBI_CRC32_INIT, ec_hdr, UBI_EC_HDR_SIZE_CRC);
759         ec_hdr->hdr_crc = cpu_to_be32(crc);
760
761         err = paranoid_check_ec_hdr(ubi, pnum, ec_hdr);
762         if (err)
763                 return -EINVAL;
764
765         err = ubi_io_write(ubi, ec_hdr, pnum, 0, ubi->ec_hdr_alsize);
766         return err;
767 }
768
769 /**
770  * validate_vid_hdr - validate a volume identifier header.
771  * @ubi: UBI device description object
772  * @vid_hdr: the volume identifier header to check
773  *
774  * This function checks that data stored in the volume identifier header
775  * @vid_hdr. Returns zero if the VID header is OK and %1 if not.
776  */
777 static int validate_vid_hdr(const struct ubi_device *ubi,
778                             const struct ubi_vid_hdr *vid_hdr)
779 {
780         int vol_type = vid_hdr->vol_type;
781         int copy_flag = vid_hdr->copy_flag;
782         int vol_id = be32_to_cpu(vid_hdr->vol_id);
783         int lnum = be32_to_cpu(vid_hdr->lnum);
784         int compat = vid_hdr->compat;
785         int data_size = be32_to_cpu(vid_hdr->data_size);
786         int used_ebs = be32_to_cpu(vid_hdr->used_ebs);
787         int data_pad = be32_to_cpu(vid_hdr->data_pad);
788         int data_crc = be32_to_cpu(vid_hdr->data_crc);
789         int usable_leb_size = ubi->leb_size - data_pad;
790
791         if (copy_flag != 0 && copy_flag != 1) {
792                 dbg_err("bad copy_flag");
793                 goto bad;
794         }
795
796         if (vol_id < 0 || lnum < 0 || data_size < 0 || used_ebs < 0 ||
797             data_pad < 0) {
798                 dbg_err("negative values");
799                 goto bad;
800         }
801
802         if (vol_id >= UBI_MAX_VOLUMES && vol_id < UBI_INTERNAL_VOL_START) {
803                 dbg_err("bad vol_id");
804                 goto bad;
805         }
806
807         if (vol_id < UBI_INTERNAL_VOL_START && compat != 0) {
808                 dbg_err("bad compat");
809                 goto bad;
810         }
811
812         if (vol_id >= UBI_INTERNAL_VOL_START && compat != UBI_COMPAT_DELETE &&
813             compat != UBI_COMPAT_RO && compat != UBI_COMPAT_PRESERVE &&
814             compat != UBI_COMPAT_REJECT) {
815                 dbg_err("bad compat");
816                 goto bad;
817         }
818
819         if (vol_type != UBI_VID_DYNAMIC && vol_type != UBI_VID_STATIC) {
820                 dbg_err("bad vol_type");
821                 goto bad;
822         }
823
824         if (data_pad >= ubi->leb_size / 2) {
825                 dbg_err("bad data_pad");
826                 goto bad;
827         }
828
829         if (vol_type == UBI_VID_STATIC) {
830                 /*
831                  * Although from high-level point of view static volumes may
832                  * contain zero bytes of data, but no VID headers can contain
833                  * zero at these fields, because they empty volumes do not have
834                  * mapped logical eraseblocks.
835                  */
836                 if (used_ebs == 0) {
837                         dbg_err("zero used_ebs");
838                         goto bad;
839                 }
840                 if (data_size == 0) {
841                         dbg_err("zero data_size");
842                         goto bad;
843                 }
844                 if (lnum < used_ebs - 1) {
845                         if (data_size != usable_leb_size) {
846                                 dbg_err("bad data_size");
847                                 goto bad;
848                         }
849                 } else if (lnum == used_ebs - 1) {
850                         if (data_size == 0) {
851                                 dbg_err("bad data_size at last LEB");
852                                 goto bad;
853                         }
854                 } else {
855                         dbg_err("too high lnum");
856                         goto bad;
857                 }
858         } else {
859                 if (copy_flag == 0) {
860                         if (data_crc != 0) {
861                                 dbg_err("non-zero data CRC");
862                                 goto bad;
863                         }
864                         if (data_size != 0) {
865                                 dbg_err("non-zero data_size");
866                                 goto bad;
867                         }
868                 } else {
869                         if (data_size == 0) {
870                                 dbg_err("zero data_size of copy");
871                                 goto bad;
872                         }
873                 }
874                 if (used_ebs != 0) {
875                         dbg_err("bad used_ebs");
876                         goto bad;
877                 }
878         }
879
880         return 0;
881
882 bad:
883         ubi_err("bad VID header");
884         ubi_dbg_dump_vid_hdr(vid_hdr);
885         ubi_dbg_dump_stack();
886         return 1;
887 }
888
889 /**
890  * ubi_io_read_vid_hdr - read and check a volume identifier header.
891  * @ubi: UBI device description object
892  * @pnum: physical eraseblock number to read from
893  * @vid_hdr: &struct ubi_vid_hdr object where to store the read volume
894  * identifier header
895  * @verbose: be verbose if the header is corrupted or wasn't found
896  *
897  * This function reads the volume identifier header from physical eraseblock
898  * @pnum and stores it in @vid_hdr. It also checks CRC checksum of the read
899  * volume identifier header. The following codes may be returned:
900  *
901  * o %0 if the CRC checksum is correct and the header was successfully read;
902  * o %UBI_IO_BITFLIPS if the CRC is correct, but bit-flips were detected
903  *   and corrected by the flash driver; this is harmless but may indicate that
904  *   this eraseblock may become bad soon;
905  * o %UBI_IO_BAD_VID_HRD if the volume identifier header is corrupted (a CRC
906  *   error detected);
907  * o %UBI_IO_PEB_FREE if the physical eraseblock is free (i.e., there is no VID
908  *   header there);
909  * o a negative error code in case of failure.
910  */
911 int ubi_io_read_vid_hdr(struct ubi_device *ubi, int pnum,
912                         struct ubi_vid_hdr *vid_hdr, int verbose)
913 {
914         int err, read_err = 0;
915         uint32_t crc, magic, hdr_crc;
916         void *p;
917
918         dbg_io("read VID header from PEB %d", pnum);
919         ubi_assert(pnum >= 0 &&  pnum < ubi->peb_count);
920
921         p = (char *)vid_hdr - ubi->vid_hdr_shift;
922         err = ubi_io_read(ubi, p, pnum, ubi->vid_hdr_aloffset,
923                           ubi->vid_hdr_alsize);
924         if (err) {
925                 if (err != UBI_IO_BITFLIPS && err != -EBADMSG)
926                         return err;
927
928                 /*
929                  * We read all the data, but either a correctable bit-flip
930                  * occurred, or MTD reported about some data integrity error,
931                  * like an ECC error in case of NAND. The former is harmless,
932                  * the later may mean the read data is corrupted. But we have a
933                  * CRC check-sum and we will identify this. If the VID header is
934                  * still OK, we just report this as there was a bit-flip.
935                  */
936                 read_err = err;
937         }
938
939         magic = be32_to_cpu(vid_hdr->magic);
940         if (magic != UBI_VID_HDR_MAGIC) {
941                 /*
942                  * If we have read all 0xFF bytes, the VID header probably does
943                  * not exist and the physical eraseblock is assumed to be free.
944                  *
945                  * But if there was a read error, we do not test the data for
946                  * 0xFFs. Even if it does contain all 0xFFs, this error
947                  * indicates that something is still wrong with this physical
948                  * eraseblock and it cannot be regarded as free.
949                  */
950                 if (read_err != -EBADMSG &&
951                     check_pattern(vid_hdr, 0xFF, UBI_VID_HDR_SIZE)) {
952                         /* The physical eraseblock is supposedly free */
953
954                         /*
955                          * The below is just a paranoid check, it has to be
956                          * compiled out if paranoid checks are disabled.
957                          */
958                         err = paranoid_check_all_ff(ubi, pnum, ubi->leb_start,
959                                                     ubi->leb_size);
960                         if (err)
961                                 return err > 0 ? UBI_IO_BAD_VID_HDR : err;
962
963                         if (verbose)
964                                 ubi_warn("no VID header found at PEB %d, "
965                                          "only 0xFF bytes", pnum);
966                         else if (UBI_IO_DEBUG)
967                                 dbg_msg("no VID header found at PEB %d, "
968                                         "only 0xFF bytes", pnum);
969                         return UBI_IO_PEB_FREE;
970                 }
971
972                 /*
973                  * This is not a valid VID header, and these are not 0xFF
974                  * bytes. Report that the header is corrupted.
975                  */
976                 if (verbose) {
977                         ubi_warn("bad magic number at PEB %d: %08x instead of "
978                                  "%08x", pnum, magic, UBI_VID_HDR_MAGIC);
979                         ubi_dbg_dump_vid_hdr(vid_hdr);
980                 } else if (UBI_IO_DEBUG)
981                         dbg_msg("bad magic number at PEB %d: %08x instead of "
982                                 "%08x", pnum, magic, UBI_VID_HDR_MAGIC);
983                 return UBI_IO_BAD_VID_HDR;
984         }
985
986         crc = crc32(UBI_CRC32_INIT, vid_hdr, UBI_VID_HDR_SIZE_CRC);
987         hdr_crc = be32_to_cpu(vid_hdr->hdr_crc);
988
989         if (hdr_crc != crc) {
990                 if (verbose) {
991                         ubi_warn("bad CRC at PEB %d, calculated %#08x, "
992                                  "read %#08x", pnum, crc, hdr_crc);
993                         ubi_dbg_dump_vid_hdr(vid_hdr);
994                 } else if (UBI_IO_DEBUG)
995                         dbg_msg("bad CRC at PEB %d, calculated %#08x, "
996                                 "read %#08x", pnum, crc, hdr_crc);
997                 return UBI_IO_BAD_VID_HDR;
998         }
999
1000         /* Validate the VID header that we have just read */
1001         err = validate_vid_hdr(ubi, vid_hdr);
1002         if (err) {
1003                 ubi_err("validation failed for PEB %d", pnum);
1004                 return -EINVAL;
1005         }
1006
1007         return read_err ? UBI_IO_BITFLIPS : 0;
1008 }
1009
1010 /**
1011  * ubi_io_write_vid_hdr - write a volume identifier header.
1012  * @ubi: UBI device description object
1013  * @pnum: the physical eraseblock number to write to
1014  * @vid_hdr: the volume identifier header to write
1015  *
1016  * This function writes the volume identifier header described by @vid_hdr to
1017  * physical eraseblock @pnum. This function automatically fills the
1018  * @vid_hdr->magic and the @vid_hdr->version fields, as well as calculates
1019  * header CRC checksum and stores it at vid_hdr->hdr_crc.
1020  *
1021  * This function returns zero in case of success and a negative error code in
1022  * case of failure. If %-EIO is returned, the physical eraseblock probably went
1023  * bad.
1024  */
1025 int ubi_io_write_vid_hdr(struct ubi_device *ubi, int pnum,
1026                          struct ubi_vid_hdr *vid_hdr)
1027 {
1028         int err;
1029         uint32_t crc;
1030         void *p;
1031
1032         dbg_io("write VID header to PEB %d", pnum);
1033         ubi_assert(pnum >= 0 &&  pnum < ubi->peb_count);
1034
1035         err = paranoid_check_peb_ec_hdr(ubi, pnum);
1036         if (err)
1037                 return err > 0 ? -EINVAL : err;
1038
1039         vid_hdr->magic = cpu_to_be32(UBI_VID_HDR_MAGIC);
1040         vid_hdr->version = UBI_VERSION;
1041         crc = crc32(UBI_CRC32_INIT, vid_hdr, UBI_VID_HDR_SIZE_CRC);
1042         vid_hdr->hdr_crc = cpu_to_be32(crc);
1043
1044         err = paranoid_check_vid_hdr(ubi, pnum, vid_hdr);
1045         if (err)
1046                 return -EINVAL;
1047
1048         p = (char *)vid_hdr - ubi->vid_hdr_shift;
1049         err = ubi_io_write(ubi, p, pnum, ubi->vid_hdr_aloffset,
1050                            ubi->vid_hdr_alsize);
1051         return err;
1052 }
1053
1054 #ifdef CONFIG_MTD_UBI_DEBUG_PARANOID
1055
1056 /**
1057  * paranoid_check_not_bad - ensure that a physical eraseblock is not bad.
1058  * @ubi: UBI device description object
1059  * @pnum: physical eraseblock number to check
1060  *
1061  * This function returns zero if the physical eraseblock is good, a positive
1062  * number if it is bad and a negative error code if an error occurred.
1063  */
1064 static int paranoid_check_not_bad(const struct ubi_device *ubi, int pnum)
1065 {
1066         int err;
1067
1068         err = ubi_io_is_bad(ubi, pnum);
1069         if (!err)
1070                 return err;
1071
1072         ubi_err("paranoid check failed for PEB %d", pnum);
1073         ubi_dbg_dump_stack();
1074         return err;
1075 }
1076
1077 /**
1078  * paranoid_check_ec_hdr - check if an erase counter header is all right.
1079  * @ubi: UBI device description object
1080  * @pnum: physical eraseblock number the erase counter header belongs to
1081  * @ec_hdr: the erase counter header to check
1082  *
1083  * This function returns zero if the erase counter header contains valid
1084  * values, and %1 if not.
1085  */
1086 static int paranoid_check_ec_hdr(const struct ubi_device *ubi, int pnum,
1087                                  const struct ubi_ec_hdr *ec_hdr)
1088 {
1089         int err;
1090         uint32_t magic;
1091
1092         magic = be32_to_cpu(ec_hdr->magic);
1093         if (magic != UBI_EC_HDR_MAGIC) {
1094                 ubi_err("bad magic %#08x, must be %#08x",
1095                         magic, UBI_EC_HDR_MAGIC);
1096                 goto fail;
1097         }
1098
1099         err = validate_ec_hdr(ubi, ec_hdr);
1100         if (err) {
1101                 ubi_err("paranoid check failed for PEB %d", pnum);
1102                 goto fail;
1103         }
1104
1105         return 0;
1106
1107 fail:
1108         ubi_dbg_dump_ec_hdr(ec_hdr);
1109         ubi_dbg_dump_stack();
1110         return 1;
1111 }
1112
1113 /**
1114  * paranoid_check_peb_ec_hdr - check erase counter header.
1115  * @ubi: UBI device description object
1116  * @pnum: the physical eraseblock number to check
1117  *
1118  * This function returns zero if the erase counter header is all right, %1 if
1119  * not, and a negative error code if an error occurred.
1120  */
1121 static int paranoid_check_peb_ec_hdr(const struct ubi_device *ubi, int pnum)
1122 {
1123         int err;
1124         uint32_t crc, hdr_crc;
1125         struct ubi_ec_hdr *ec_hdr;
1126
1127         ec_hdr = kzalloc(ubi->ec_hdr_alsize, GFP_NOFS);
1128         if (!ec_hdr)
1129                 return -ENOMEM;
1130
1131         err = ubi_io_read(ubi, ec_hdr, pnum, 0, UBI_EC_HDR_SIZE);
1132         if (err && err != UBI_IO_BITFLIPS && err != -EBADMSG)
1133                 goto exit;
1134
1135         crc = crc32(UBI_CRC32_INIT, ec_hdr, UBI_EC_HDR_SIZE_CRC);
1136         hdr_crc = be32_to_cpu(ec_hdr->hdr_crc);
1137         if (hdr_crc != crc) {
1138                 ubi_err("bad CRC, calculated %#08x, read %#08x", crc, hdr_crc);
1139                 ubi_err("paranoid check failed for PEB %d", pnum);
1140                 ubi_dbg_dump_ec_hdr(ec_hdr);
1141                 ubi_dbg_dump_stack();
1142                 err = 1;
1143                 goto exit;
1144         }
1145
1146         err = paranoid_check_ec_hdr(ubi, pnum, ec_hdr);
1147
1148 exit:
1149         kfree(ec_hdr);
1150         return err;
1151 }
1152
1153 /**
1154  * paranoid_check_vid_hdr - check that a volume identifier header is all right.
1155  * @ubi: UBI device description object
1156  * @pnum: physical eraseblock number the volume identifier header belongs to
1157  * @vid_hdr: the volume identifier header to check
1158  *
1159  * This function returns zero if the volume identifier header is all right, and
1160  * %1 if not.
1161  */
1162 static int paranoid_check_vid_hdr(const struct ubi_device *ubi, int pnum,
1163                                   const struct ubi_vid_hdr *vid_hdr)
1164 {
1165         int err;
1166         uint32_t magic;
1167
1168         magic = be32_to_cpu(vid_hdr->magic);
1169         if (magic != UBI_VID_HDR_MAGIC) {
1170                 ubi_err("bad VID header magic %#08x at PEB %d, must be %#08x",
1171                         magic, pnum, UBI_VID_HDR_MAGIC);
1172                 goto fail;
1173         }
1174
1175         err = validate_vid_hdr(ubi, vid_hdr);
1176         if (err) {
1177                 ubi_err("paranoid check failed for PEB %d", pnum);
1178                 goto fail;
1179         }
1180
1181         return err;
1182
1183 fail:
1184         ubi_err("paranoid check failed for PEB %d", pnum);
1185         ubi_dbg_dump_vid_hdr(vid_hdr);
1186         ubi_dbg_dump_stack();
1187         return 1;
1188
1189 }
1190
1191 /**
1192  * paranoid_check_peb_vid_hdr - check volume identifier header.
1193  * @ubi: UBI device description object
1194  * @pnum: the physical eraseblock number to check
1195  *
1196  * This function returns zero if the volume identifier header is all right,
1197  * %1 if not, and a negative error code if an error occurred.
1198  */
1199 static int paranoid_check_peb_vid_hdr(const struct ubi_device *ubi, int pnum)
1200 {
1201         int err;
1202         uint32_t crc, hdr_crc;
1203         struct ubi_vid_hdr *vid_hdr;
1204         void *p;
1205
1206         vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS);
1207         if (!vid_hdr)
1208                 return -ENOMEM;
1209
1210         p = (char *)vid_hdr - ubi->vid_hdr_shift;
1211         err = ubi_io_read(ubi, p, pnum, ubi->vid_hdr_aloffset,
1212                           ubi->vid_hdr_alsize);
1213         if (err && err != UBI_IO_BITFLIPS && err != -EBADMSG)
1214                 goto exit;
1215
1216         crc = crc32(UBI_CRC32_INIT, vid_hdr, UBI_EC_HDR_SIZE_CRC);
1217         hdr_crc = be32_to_cpu(vid_hdr->hdr_crc);
1218         if (hdr_crc != crc) {
1219                 ubi_err("bad VID header CRC at PEB %d, calculated %#08x, "
1220                         "read %#08x", pnum, crc, hdr_crc);
1221                 ubi_err("paranoid check failed for PEB %d", pnum);
1222                 ubi_dbg_dump_vid_hdr(vid_hdr);
1223                 ubi_dbg_dump_stack();
1224                 err = 1;
1225                 goto exit;
1226         }
1227
1228         err = paranoid_check_vid_hdr(ubi, pnum, vid_hdr);
1229
1230 exit:
1231         ubi_free_vid_hdr(ubi, vid_hdr);
1232         return err;
1233 }
1234
1235 /**
1236  * paranoid_check_all_ff - check that a region of flash is empty.
1237  * @ubi: UBI device description object
1238  * @pnum: the physical eraseblock number to check
1239  * @offset: the starting offset within the physical eraseblock to check
1240  * @len: the length of the region to check
1241  *
1242  * This function returns zero if only 0xFF bytes are present at offset
1243  * @offset of the physical eraseblock @pnum, %1 if not, and a negative error
1244  * code if an error occurred.
1245  */
1246 static int paranoid_check_all_ff(struct ubi_device *ubi, int pnum, int offset,
1247                                  int len)
1248 {
1249         size_t read;
1250         int err;
1251         loff_t addr = (loff_t)pnum * ubi->peb_size + offset;
1252
1253         mutex_lock(&ubi->dbg_buf_mutex);
1254         err = ubi->mtd->read(ubi->mtd, addr, len, &read, ubi->dbg_peb_buf);
1255         if (err && err != -EUCLEAN) {
1256                 ubi_err("error %d while reading %d bytes from PEB %d:%d, "
1257                         "read %zd bytes", err, len, pnum, offset, read);
1258                 goto error;
1259         }
1260
1261         err = check_pattern(ubi->dbg_peb_buf, 0xFF, len);
1262         if (err == 0) {
1263                 ubi_err("flash region at PEB %d:%d, length %d does not "
1264                         "contain all 0xFF bytes", pnum, offset, len);
1265                 goto fail;
1266         }
1267         mutex_unlock(&ubi->dbg_buf_mutex);
1268
1269         return 0;
1270
1271 fail:
1272         ubi_err("paranoid check failed for PEB %d", pnum);
1273         ubi_msg("hex dump of the %d-%d region", offset, offset + len);
1274         print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1,
1275                        ubi->dbg_peb_buf, len, 1);
1276         err = 1;
1277 error:
1278         ubi_dbg_dump_stack();
1279         mutex_unlock(&ubi->dbg_buf_mutex);
1280         return err;
1281 }
1282
1283 #endif /* CONFIG_MTD_UBI_DEBUG_PARANOID */