Loading...
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 not relevant to the sub-page are 0xFF. So, basically,
68 * writing 4x512 sub-pages is 4 times slower than writing one 2KiB NAND page.
69 * Thus, we prefer to use sub-pages only for EC 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 <linux/slab.h>
92#include "ubi.h"
93
94#ifdef CONFIG_MTD_UBI_DEBUG
95static int paranoid_check_not_bad(const struct ubi_device *ubi, int pnum);
96static int paranoid_check_peb_ec_hdr(const struct ubi_device *ubi, int pnum);
97static int paranoid_check_ec_hdr(const struct ubi_device *ubi, int pnum,
98 const struct ubi_ec_hdr *ec_hdr);
99static int paranoid_check_peb_vid_hdr(const struct ubi_device *ubi, int pnum);
100static int paranoid_check_vid_hdr(const struct ubi_device *ubi, int pnum,
101 const struct ubi_vid_hdr *vid_hdr);
102#else
103#define paranoid_check_not_bad(ubi, pnum) 0
104#define paranoid_check_peb_ec_hdr(ubi, pnum) 0
105#define paranoid_check_ec_hdr(ubi, pnum, ec_hdr) 0
106#define paranoid_check_peb_vid_hdr(ubi, pnum) 0
107#define paranoid_check_vid_hdr(ubi, pnum, vid_hdr) 0
108#endif
109
110/**
111 * ubi_io_read - read data from a physical eraseblock.
112 * @ubi: UBI device description object
113 * @buf: buffer where to store the read data
114 * @pnum: physical eraseblock number to read from
115 * @offset: offset within the physical eraseblock from where to read
116 * @len: how many bytes to read
117 *
118 * This function reads data from offset @offset of physical eraseblock @pnum
119 * and stores the read data in the @buf buffer. The following return codes are
120 * possible:
121 *
122 * o %0 if all the requested data were successfully read;
123 * o %UBI_IO_BITFLIPS if all the requested data were successfully read, but
124 * correctable bit-flips were detected; this is harmless but may indicate
125 * that this eraseblock may become bad soon (but do not have to);
126 * o %-EBADMSG if the MTD subsystem reported about data integrity problems, for
127 * example it can be an ECC error in case of NAND; this most probably means
128 * that the data is corrupted;
129 * o %-EIO if some I/O error occurred;
130 * o other negative error codes in case of other errors.
131 */
132int ubi_io_read(const struct ubi_device *ubi, void *buf, int pnum, int offset,
133 int len)
134{
135 int err, retries = 0;
136 size_t read;
137 loff_t addr;
138
139 dbg_io("read %d bytes from PEB %d:%d", len, pnum, offset);
140
141 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
142 ubi_assert(offset >= 0 && offset + len <= ubi->peb_size);
143 ubi_assert(len > 0);
144
145 err = paranoid_check_not_bad(ubi, pnum);
146 if (err)
147 return err;
148
149 /*
150 * Deliberately corrupt the buffer to improve robustness. Indeed, if we
151 * do not do this, the following may happen:
152 * 1. The buffer contains data from previous operation, e.g., read from
153 * another PEB previously. The data looks like expected, e.g., if we
154 * just do not read anything and return - the caller would not
155 * notice this. E.g., if we are reading a VID header, the buffer may
156 * contain a valid VID header from another PEB.
157 * 2. The driver is buggy and returns us success or -EBADMSG or
158 * -EUCLEAN, but it does not actually put any data to the buffer.
159 *
160 * This may confuse UBI or upper layers - they may think the buffer
161 * contains valid data while in fact it is just old data. This is
162 * especially possible because UBI (and UBIFS) relies on CRC, and
163 * treats data as correct even in case of ECC errors if the CRC is
164 * correct.
165 *
166 * Try to prevent this situation by changing the first byte of the
167 * buffer.
168 */
169 *((uint8_t *)buf) ^= 0xFF;
170
171 addr = (loff_t)pnum * ubi->peb_size + offset;
172retry:
173 err = ubi->mtd->read(ubi->mtd, addr, len, &read, buf);
174 if (err) {
175 const char *errstr = (err == -EBADMSG) ? " (ECC error)" : "";
176
177 if (err == -EUCLEAN) {
178 /*
179 * -EUCLEAN is reported if there was a bit-flip which
180 * was corrected, so this is harmless.
181 *
182 * We do not report about it here unless debugging is
183 * enabled. A corresponding message will be printed
184 * later, when it is has been scrubbed.
185 */
186 dbg_msg("fixable bit-flip detected at PEB %d", pnum);
187 ubi_assert(len == read);
188 return UBI_IO_BITFLIPS;
189 }
190
191 if (retries++ < UBI_IO_RETRIES) {
192 dbg_io("error %d%s while reading %d bytes from PEB "
193 "%d:%d, read only %zd bytes, retry",
194 err, errstr, len, pnum, offset, read);
195 yield();
196 goto retry;
197 }
198
199 ubi_err("error %d%s while reading %d bytes from PEB %d:%d, "
200 "read %zd bytes", err, errstr, len, pnum, offset, read);
201 ubi_dbg_dump_stack();
202
203 /*
204 * The driver should never return -EBADMSG if it failed to read
205 * all the requested data. But some buggy drivers might do
206 * this, so we change it to -EIO.
207 */
208 if (read != len && err == -EBADMSG) {
209 ubi_assert(0);
210 err = -EIO;
211 }
212 } else {
213 ubi_assert(len == read);
214
215 if (ubi_dbg_is_bitflip(ubi)) {
216 dbg_gen("bit-flip (emulated)");
217 err = UBI_IO_BITFLIPS;
218 }
219 }
220
221 return err;
222}
223
224/**
225 * ubi_io_write - write data to a physical eraseblock.
226 * @ubi: UBI device description object
227 * @buf: buffer with the data to write
228 * @pnum: physical eraseblock number to write to
229 * @offset: offset within the physical eraseblock where to write
230 * @len: how many bytes to write
231 *
232 * This function writes @len bytes of data from buffer @buf to offset @offset
233 * of physical eraseblock @pnum. If all the data were successfully written,
234 * zero is returned. If an error occurred, this function returns a negative
235 * error code. If %-EIO is returned, the physical eraseblock most probably went
236 * bad.
237 *
238 * Note, in case of an error, it is possible that something was still written
239 * to the flash media, but may be some garbage.
240 */
241int ubi_io_write(struct ubi_device *ubi, const void *buf, int pnum, int offset,
242 int len)
243{
244 int err;
245 size_t written;
246 loff_t addr;
247
248 dbg_io("write %d bytes to PEB %d:%d", len, pnum, offset);
249
250 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
251 ubi_assert(offset >= 0 && offset + len <= ubi->peb_size);
252 ubi_assert(offset % ubi->hdrs_min_io_size == 0);
253 ubi_assert(len > 0 && len % ubi->hdrs_min_io_size == 0);
254
255 if (ubi->ro_mode) {
256 ubi_err("read-only mode");
257 return -EROFS;
258 }
259
260 /* The below has to be compiled out if paranoid checks are disabled */
261
262 err = paranoid_check_not_bad(ubi, pnum);
263 if (err)
264 return err;
265
266 /* The area we are writing to has to contain all 0xFF bytes */
267 err = ubi_dbg_check_all_ff(ubi, pnum, offset, len);
268 if (err)
269 return err;
270
271 if (offset >= ubi->leb_start) {
272 /*
273 * We write to the data area of the physical eraseblock. Make
274 * sure it has valid EC and VID headers.
275 */
276 err = paranoid_check_peb_ec_hdr(ubi, pnum);
277 if (err)
278 return err;
279 err = paranoid_check_peb_vid_hdr(ubi, pnum);
280 if (err)
281 return err;
282 }
283
284 if (ubi_dbg_is_write_failure(ubi)) {
285 dbg_err("cannot write %d bytes to PEB %d:%d "
286 "(emulated)", len, pnum, offset);
287 ubi_dbg_dump_stack();
288 return -EIO;
289 }
290
291 addr = (loff_t)pnum * ubi->peb_size + offset;
292 err = ubi->mtd->write(ubi->mtd, addr, len, &written, buf);
293 if (err) {
294 ubi_err("error %d while writing %d bytes to PEB %d:%d, written "
295 "%zd bytes", err, len, pnum, offset, written);
296 ubi_dbg_dump_stack();
297 ubi_dbg_dump_flash(ubi, pnum, offset, len);
298 } else
299 ubi_assert(written == len);
300
301 if (!err) {
302 err = ubi_dbg_check_write(ubi, buf, pnum, offset, len);
303 if (err)
304 return err;
305
306 /*
307 * Since we always write sequentially, the rest of the PEB has
308 * to contain only 0xFF bytes.
309 */
310 offset += len;
311 len = ubi->peb_size - offset;
312 if (len)
313 err = ubi_dbg_check_all_ff(ubi, pnum, offset, len);
314 }
315
316 return err;
317}
318
319/**
320 * erase_callback - MTD erasure call-back.
321 * @ei: MTD erase information object.
322 *
323 * Note, even though MTD erase interface is asynchronous, all the current
324 * implementations are synchronous anyway.
325 */
326static void erase_callback(struct erase_info *ei)
327{
328 wake_up_interruptible((wait_queue_head_t *)ei->priv);
329}
330
331/**
332 * do_sync_erase - synchronously erase a physical eraseblock.
333 * @ubi: UBI device description object
334 * @pnum: the physical eraseblock number to erase
335 *
336 * This function synchronously erases physical eraseblock @pnum and returns
337 * zero in case of success and a negative error code in case of failure. If
338 * %-EIO is returned, the physical eraseblock most probably went bad.
339 */
340static int do_sync_erase(struct ubi_device *ubi, int pnum)
341{
342 int err, retries = 0;
343 struct erase_info ei;
344 wait_queue_head_t wq;
345
346 dbg_io("erase PEB %d", pnum);
347 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
348
349 if (ubi->ro_mode) {
350 ubi_err("read-only mode");
351 return -EROFS;
352 }
353
354retry:
355 init_waitqueue_head(&wq);
356 memset(&ei, 0, sizeof(struct erase_info));
357
358 ei.mtd = ubi->mtd;
359 ei.addr = (loff_t)pnum * ubi->peb_size;
360 ei.len = ubi->peb_size;
361 ei.callback = erase_callback;
362 ei.priv = (unsigned long)&wq;
363
364 err = ubi->mtd->erase(ubi->mtd, &ei);
365 if (err) {
366 if (retries++ < UBI_IO_RETRIES) {
367 dbg_io("error %d while erasing PEB %d, retry",
368 err, pnum);
369 yield();
370 goto retry;
371 }
372 ubi_err("cannot erase PEB %d, error %d", pnum, err);
373 ubi_dbg_dump_stack();
374 return err;
375 }
376
377 err = wait_event_interruptible(wq, ei.state == MTD_ERASE_DONE ||
378 ei.state == MTD_ERASE_FAILED);
379 if (err) {
380 ubi_err("interrupted PEB %d erasure", pnum);
381 return -EINTR;
382 }
383
384 if (ei.state == MTD_ERASE_FAILED) {
385 if (retries++ < UBI_IO_RETRIES) {
386 dbg_io("error while erasing PEB %d, retry", pnum);
387 yield();
388 goto retry;
389 }
390 ubi_err("cannot erase PEB %d", pnum);
391 ubi_dbg_dump_stack();
392 return -EIO;
393 }
394
395 err = ubi_dbg_check_all_ff(ubi, pnum, 0, ubi->peb_size);
396 if (err)
397 return err;
398
399 if (ubi_dbg_is_erase_failure(ubi)) {
400 dbg_err("cannot erase PEB %d (emulated)", pnum);
401 return -EIO;
402 }
403
404 return 0;
405}
406
407/* Patterns to write to a physical eraseblock when torturing it */
408static uint8_t patterns[] = {0xa5, 0x5a, 0x0};
409
410/**
411 * torture_peb - test a supposedly bad physical eraseblock.
412 * @ubi: UBI device description object
413 * @pnum: the physical eraseblock number to test
414 *
415 * This function returns %-EIO if the physical eraseblock did not pass the
416 * test, a positive number of erase operations done if the test was
417 * successfully passed, and other negative error codes in case of other errors.
418 */
419static int torture_peb(struct ubi_device *ubi, int pnum)
420{
421 int err, i, patt_count;
422
423 ubi_msg("run torture test for PEB %d", pnum);
424 patt_count = ARRAY_SIZE(patterns);
425 ubi_assert(patt_count > 0);
426
427 mutex_lock(&ubi->buf_mutex);
428 for (i = 0; i < patt_count; i++) {
429 err = do_sync_erase(ubi, pnum);
430 if (err)
431 goto out;
432
433 /* Make sure the PEB contains only 0xFF bytes */
434 err = ubi_io_read(ubi, ubi->peb_buf1, pnum, 0, ubi->peb_size);
435 if (err)
436 goto out;
437
438 err = ubi_check_pattern(ubi->peb_buf1, 0xFF, ubi->peb_size);
439 if (err == 0) {
440 ubi_err("erased PEB %d, but a non-0xFF byte found",
441 pnum);
442 err = -EIO;
443 goto out;
444 }
445
446 /* Write a pattern and check it */
447 memset(ubi->peb_buf1, patterns[i], ubi->peb_size);
448 err = ubi_io_write(ubi, ubi->peb_buf1, pnum, 0, ubi->peb_size);
449 if (err)
450 goto out;
451
452 memset(ubi->peb_buf1, ~patterns[i], ubi->peb_size);
453 err = ubi_io_read(ubi, ubi->peb_buf1, pnum, 0, ubi->peb_size);
454 if (err)
455 goto out;
456
457 err = ubi_check_pattern(ubi->peb_buf1, patterns[i],
458 ubi->peb_size);
459 if (err == 0) {
460 ubi_err("pattern %x checking failed for PEB %d",
461 patterns[i], pnum);
462 err = -EIO;
463 goto out;
464 }
465 }
466
467 err = patt_count;
468 ubi_msg("PEB %d passed torture test, do not mark it as bad", pnum);
469
470out:
471 mutex_unlock(&ubi->buf_mutex);
472 if (err == UBI_IO_BITFLIPS || err == -EBADMSG) {
473 /*
474 * If a bit-flip or data integrity error was detected, the test
475 * has not passed because it happened on a freshly erased
476 * physical eraseblock which means something is wrong with it.
477 */
478 ubi_err("read problems on freshly erased PEB %d, must be bad",
479 pnum);
480 err = -EIO;
481 }
482 return err;
483}
484
485/**
486 * nor_erase_prepare - prepare a NOR flash PEB for erasure.
487 * @ubi: UBI device description object
488 * @pnum: physical eraseblock number to prepare
489 *
490 * NOR flash, or at least some of them, have peculiar embedded PEB erasure
491 * algorithm: the PEB is first filled with zeroes, then it is erased. And
492 * filling with zeroes starts from the end of the PEB. This was observed with
493 * Spansion S29GL512N NOR flash.
494 *
495 * This means that in case of a power cut we may end up with intact data at the
496 * beginning of the PEB, and all zeroes at the end of PEB. In other words, the
497 * EC and VID headers are OK, but a large chunk of data at the end of PEB is
498 * zeroed. This makes UBI mistakenly treat this PEB as used and associate it
499 * with an LEB, which leads to subsequent failures (e.g., UBIFS fails).
500 *
501 * This function is called before erasing NOR PEBs and it zeroes out EC and VID
502 * magic numbers in order to invalidate them and prevent the failures. Returns
503 * zero in case of success and a negative error code in case of failure.
504 */
505static int nor_erase_prepare(struct ubi_device *ubi, int pnum)
506{
507 int err, err1;
508 size_t written;
509 loff_t addr;
510 uint32_t data = 0;
511 /*
512 * Note, we cannot generally define VID header buffers on stack,
513 * because of the way we deal with these buffers (see the header
514 * comment in this file). But we know this is a NOR-specific piece of
515 * code, so we can do this. But yes, this is error-prone and we should
516 * (pre-)allocate VID header buffer instead.
517 */
518 struct ubi_vid_hdr vid_hdr;
519
520 /*
521 * It is important to first invalidate the EC header, and then the VID
522 * header. Otherwise a power cut may lead to valid EC header and
523 * invalid VID header, in which case UBI will treat this PEB as
524 * corrupted and will try to preserve it, and print scary warnings (see
525 * the header comment in scan.c for more information).
526 */
527 addr = (loff_t)pnum * ubi->peb_size;
528 err = ubi->mtd->write(ubi->mtd, addr, 4, &written, (void *)&data);
529 if (!err) {
530 addr += ubi->vid_hdr_aloffset;
531 err = ubi->mtd->write(ubi->mtd, addr, 4, &written,
532 (void *)&data);
533 if (!err)
534 return 0;
535 }
536
537 /*
538 * We failed to write to the media. This was observed with Spansion
539 * S29GL512N NOR flash. Most probably the previously eraseblock erasure
540 * was interrupted at a very inappropriate moment, so it became
541 * unwritable. In this case we probably anyway have garbage in this
542 * PEB.
543 */
544 err1 = ubi_io_read_vid_hdr(ubi, pnum, &vid_hdr, 0);
545 if (err1 == UBI_IO_BAD_HDR_EBADMSG || err1 == UBI_IO_BAD_HDR ||
546 err1 == UBI_IO_FF) {
547 struct ubi_ec_hdr ec_hdr;
548
549 err1 = ubi_io_read_ec_hdr(ubi, pnum, &ec_hdr, 0);
550 if (err1 == UBI_IO_BAD_HDR_EBADMSG || err1 == UBI_IO_BAD_HDR ||
551 err1 == UBI_IO_FF)
552 /*
553 * Both VID and EC headers are corrupted, so we can
554 * safely erase this PEB and not afraid that it will be
555 * treated as a valid PEB in case of an unclean reboot.
556 */
557 return 0;
558 }
559
560 /*
561 * The PEB contains a valid VID header, but we cannot invalidate it.
562 * Supposedly the flash media or the driver is screwed up, so return an
563 * error.
564 */
565 ubi_err("cannot invalidate PEB %d, write returned %d read returned %d",
566 pnum, err, err1);
567 ubi_dbg_dump_flash(ubi, pnum, 0, ubi->peb_size);
568 return -EIO;
569}
570
571/**
572 * ubi_io_sync_erase - synchronously erase a physical eraseblock.
573 * @ubi: UBI device description object
574 * @pnum: physical eraseblock number to erase
575 * @torture: if this physical eraseblock has to be tortured
576 *
577 * This function synchronously erases physical eraseblock @pnum. If @torture
578 * flag is not zero, the physical eraseblock is checked by means of writing
579 * different patterns to it and reading them back. If the torturing is enabled,
580 * the physical eraseblock is erased more than once.
581 *
582 * This function returns the number of erasures made in case of success, %-EIO
583 * if the erasure failed or the torturing test failed, and other negative error
584 * codes in case of other errors. Note, %-EIO means that the physical
585 * eraseblock is bad.
586 */
587int ubi_io_sync_erase(struct ubi_device *ubi, int pnum, int torture)
588{
589 int err, ret = 0;
590
591 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
592
593 err = paranoid_check_not_bad(ubi, pnum);
594 if (err != 0)
595 return err;
596
597 if (ubi->ro_mode) {
598 ubi_err("read-only mode");
599 return -EROFS;
600 }
601
602 if (ubi->nor_flash) {
603 err = nor_erase_prepare(ubi, pnum);
604 if (err)
605 return err;
606 }
607
608 if (torture) {
609 ret = torture_peb(ubi, pnum);
610 if (ret < 0)
611 return ret;
612 }
613
614 err = do_sync_erase(ubi, pnum);
615 if (err)
616 return err;
617
618 return ret + 1;
619}
620
621/**
622 * ubi_io_is_bad - check if a physical eraseblock is bad.
623 * @ubi: UBI device description object
624 * @pnum: the physical eraseblock number to check
625 *
626 * This function returns a positive number if the physical eraseblock is bad,
627 * zero if not, and a negative error code if an error occurred.
628 */
629int ubi_io_is_bad(const struct ubi_device *ubi, int pnum)
630{
631 struct mtd_info *mtd = ubi->mtd;
632
633 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
634
635 if (ubi->bad_allowed) {
636 int ret;
637
638 ret = mtd->block_isbad(mtd, (loff_t)pnum * ubi->peb_size);
639 if (ret < 0)
640 ubi_err("error %d while checking if PEB %d is bad",
641 ret, pnum);
642 else if (ret)
643 dbg_io("PEB %d is bad", pnum);
644 return ret;
645 }
646
647 return 0;
648}
649
650/**
651 * ubi_io_mark_bad - mark a physical eraseblock as bad.
652 * @ubi: UBI device description object
653 * @pnum: the physical eraseblock number to mark
654 *
655 * This function returns zero in case of success and a negative error code in
656 * case of failure.
657 */
658int ubi_io_mark_bad(const struct ubi_device *ubi, int pnum)
659{
660 int err;
661 struct mtd_info *mtd = ubi->mtd;
662
663 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
664
665 if (ubi->ro_mode) {
666 ubi_err("read-only mode");
667 return -EROFS;
668 }
669
670 if (!ubi->bad_allowed)
671 return 0;
672
673 err = mtd->block_markbad(mtd, (loff_t)pnum * ubi->peb_size);
674 if (err)
675 ubi_err("cannot mark PEB %d bad, error %d", pnum, err);
676 return err;
677}
678
679/**
680 * validate_ec_hdr - validate an erase counter header.
681 * @ubi: UBI device description object
682 * @ec_hdr: the erase counter header to check
683 *
684 * This function returns zero if the erase counter header is OK, and %1 if
685 * not.
686 */
687static int validate_ec_hdr(const struct ubi_device *ubi,
688 const struct ubi_ec_hdr *ec_hdr)
689{
690 long long ec;
691 int vid_hdr_offset, leb_start;
692
693 ec = be64_to_cpu(ec_hdr->ec);
694 vid_hdr_offset = be32_to_cpu(ec_hdr->vid_hdr_offset);
695 leb_start = be32_to_cpu(ec_hdr->data_offset);
696
697 if (ec_hdr->version != UBI_VERSION) {
698 ubi_err("node with incompatible UBI version found: "
699 "this UBI version is %d, image version is %d",
700 UBI_VERSION, (int)ec_hdr->version);
701 goto bad;
702 }
703
704 if (vid_hdr_offset != ubi->vid_hdr_offset) {
705 ubi_err("bad VID header offset %d, expected %d",
706 vid_hdr_offset, ubi->vid_hdr_offset);
707 goto bad;
708 }
709
710 if (leb_start != ubi->leb_start) {
711 ubi_err("bad data offset %d, expected %d",
712 leb_start, ubi->leb_start);
713 goto bad;
714 }
715
716 if (ec < 0 || ec > UBI_MAX_ERASECOUNTER) {
717 ubi_err("bad erase counter %lld", ec);
718 goto bad;
719 }
720
721 return 0;
722
723bad:
724 ubi_err("bad EC header");
725 ubi_dbg_dump_ec_hdr(ec_hdr);
726 ubi_dbg_dump_stack();
727 return 1;
728}
729
730/**
731 * ubi_io_read_ec_hdr - read and check an erase counter header.
732 * @ubi: UBI device description object
733 * @pnum: physical eraseblock to read from
734 * @ec_hdr: a &struct ubi_ec_hdr object where to store the read erase counter
735 * header
736 * @verbose: be verbose if the header is corrupted or was not found
737 *
738 * This function reads erase counter header from physical eraseblock @pnum and
739 * stores it in @ec_hdr. This function also checks CRC checksum of the read
740 * erase counter header. The following codes may be returned:
741 *
742 * o %0 if the CRC checksum is correct and the header was successfully read;
743 * o %UBI_IO_BITFLIPS if the CRC is correct, but bit-flips were detected
744 * and corrected by the flash driver; this is harmless but may indicate that
745 * this eraseblock may become bad soon (but may be not);
746 * o %UBI_IO_BAD_HDR if the erase counter header is corrupted (a CRC error);
747 * o %UBI_IO_BAD_HDR_EBADMSG is the same as %UBI_IO_BAD_HDR, but there also was
748 * a data integrity error (uncorrectable ECC error in case of NAND);
749 * o %UBI_IO_FF if only 0xFF bytes were read (the PEB is supposedly empty)
750 * o a negative error code in case of failure.
751 */
752int ubi_io_read_ec_hdr(struct ubi_device *ubi, int pnum,
753 struct ubi_ec_hdr *ec_hdr, int verbose)
754{
755 int err, read_err;
756 uint32_t crc, magic, hdr_crc;
757
758 dbg_io("read EC header from PEB %d", pnum);
759 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
760
761 read_err = ubi_io_read(ubi, ec_hdr, pnum, 0, UBI_EC_HDR_SIZE);
762 if (read_err) {
763 if (read_err != UBI_IO_BITFLIPS && read_err != -EBADMSG)
764 return read_err;
765
766 /*
767 * We read all the data, but either a correctable bit-flip
768 * occurred, or MTD reported a data integrity error
769 * (uncorrectable ECC error in case of NAND). The former is
770 * harmless, the later may mean that the read data is
771 * corrupted. But we have a CRC check-sum and we will detect
772 * this. If the EC header is still OK, we just report this as
773 * there was a bit-flip, to force scrubbing.
774 */
775 }
776
777 magic = be32_to_cpu(ec_hdr->magic);
778 if (magic != UBI_EC_HDR_MAGIC) {
779 if (read_err == -EBADMSG)
780 return UBI_IO_BAD_HDR_EBADMSG;
781
782 /*
783 * The magic field is wrong. Let's check if we have read all
784 * 0xFF. If yes, this physical eraseblock is assumed to be
785 * empty.
786 */
787 if (ubi_check_pattern(ec_hdr, 0xFF, UBI_EC_HDR_SIZE)) {
788 /* The physical eraseblock is supposedly empty */
789 if (verbose)
790 ubi_warn("no EC header found at PEB %d, "
791 "only 0xFF bytes", pnum);
792 dbg_bld("no EC header found at PEB %d, "
793 "only 0xFF bytes", pnum);
794 if (!read_err)
795 return UBI_IO_FF;
796 else
797 return UBI_IO_FF_BITFLIPS;
798 }
799
800 /*
801 * This is not a valid erase counter header, and these are not
802 * 0xFF bytes. Report that the header is corrupted.
803 */
804 if (verbose) {
805 ubi_warn("bad magic number at PEB %d: %08x instead of "
806 "%08x", pnum, magic, UBI_EC_HDR_MAGIC);
807 ubi_dbg_dump_ec_hdr(ec_hdr);
808 }
809 dbg_bld("bad magic number at PEB %d: %08x instead of "
810 "%08x", pnum, magic, UBI_EC_HDR_MAGIC);
811 return UBI_IO_BAD_HDR;
812 }
813
814 crc = crc32(UBI_CRC32_INIT, ec_hdr, UBI_EC_HDR_SIZE_CRC);
815 hdr_crc = be32_to_cpu(ec_hdr->hdr_crc);
816
817 if (hdr_crc != crc) {
818 if (verbose) {
819 ubi_warn("bad EC header CRC at PEB %d, calculated "
820 "%#08x, read %#08x", pnum, crc, hdr_crc);
821 ubi_dbg_dump_ec_hdr(ec_hdr);
822 }
823 dbg_bld("bad EC header CRC at PEB %d, calculated "
824 "%#08x, read %#08x", pnum, crc, hdr_crc);
825
826 if (!read_err)
827 return UBI_IO_BAD_HDR;
828 else
829 return UBI_IO_BAD_HDR_EBADMSG;
830 }
831
832 /* And of course validate what has just been read from the media */
833 err = validate_ec_hdr(ubi, ec_hdr);
834 if (err) {
835 ubi_err("validation failed for PEB %d", pnum);
836 return -EINVAL;
837 }
838
839 /*
840 * If there was %-EBADMSG, but the header CRC is still OK, report about
841 * a bit-flip to force scrubbing on this PEB.
842 */
843 return read_err ? UBI_IO_BITFLIPS : 0;
844}
845
846/**
847 * ubi_io_write_ec_hdr - write an erase counter header.
848 * @ubi: UBI device description object
849 * @pnum: physical eraseblock to write to
850 * @ec_hdr: the erase counter header to write
851 *
852 * This function writes erase counter header described by @ec_hdr to physical
853 * eraseblock @pnum. It also fills most fields of @ec_hdr before writing, so
854 * the caller do not have to fill them. Callers must only fill the @ec_hdr->ec
855 * field.
856 *
857 * This function returns zero in case of success and a negative error code in
858 * case of failure. If %-EIO is returned, the physical eraseblock most probably
859 * went bad.
860 */
861int ubi_io_write_ec_hdr(struct ubi_device *ubi, int pnum,
862 struct ubi_ec_hdr *ec_hdr)
863{
864 int err;
865 uint32_t crc;
866
867 dbg_io("write EC header to PEB %d", pnum);
868 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
869
870 ec_hdr->magic = cpu_to_be32(UBI_EC_HDR_MAGIC);
871 ec_hdr->version = UBI_VERSION;
872 ec_hdr->vid_hdr_offset = cpu_to_be32(ubi->vid_hdr_offset);
873 ec_hdr->data_offset = cpu_to_be32(ubi->leb_start);
874 ec_hdr->image_seq = cpu_to_be32(ubi->image_seq);
875 crc = crc32(UBI_CRC32_INIT, ec_hdr, UBI_EC_HDR_SIZE_CRC);
876 ec_hdr->hdr_crc = cpu_to_be32(crc);
877
878 err = paranoid_check_ec_hdr(ubi, pnum, ec_hdr);
879 if (err)
880 return err;
881
882 err = ubi_io_write(ubi, ec_hdr, pnum, 0, ubi->ec_hdr_alsize);
883 return err;
884}
885
886/**
887 * validate_vid_hdr - validate a volume identifier header.
888 * @ubi: UBI device description object
889 * @vid_hdr: the volume identifier header to check
890 *
891 * This function checks that data stored in the volume identifier header
892 * @vid_hdr. Returns zero if the VID header is OK and %1 if not.
893 */
894static int validate_vid_hdr(const struct ubi_device *ubi,
895 const struct ubi_vid_hdr *vid_hdr)
896{
897 int vol_type = vid_hdr->vol_type;
898 int copy_flag = vid_hdr->copy_flag;
899 int vol_id = be32_to_cpu(vid_hdr->vol_id);
900 int lnum = be32_to_cpu(vid_hdr->lnum);
901 int compat = vid_hdr->compat;
902 int data_size = be32_to_cpu(vid_hdr->data_size);
903 int used_ebs = be32_to_cpu(vid_hdr->used_ebs);
904 int data_pad = be32_to_cpu(vid_hdr->data_pad);
905 int data_crc = be32_to_cpu(vid_hdr->data_crc);
906 int usable_leb_size = ubi->leb_size - data_pad;
907
908 if (copy_flag != 0 && copy_flag != 1) {
909 dbg_err("bad copy_flag");
910 goto bad;
911 }
912
913 if (vol_id < 0 || lnum < 0 || data_size < 0 || used_ebs < 0 ||
914 data_pad < 0) {
915 dbg_err("negative values");
916 goto bad;
917 }
918
919 if (vol_id >= UBI_MAX_VOLUMES && vol_id < UBI_INTERNAL_VOL_START) {
920 dbg_err("bad vol_id");
921 goto bad;
922 }
923
924 if (vol_id < UBI_INTERNAL_VOL_START && compat != 0) {
925 dbg_err("bad compat");
926 goto bad;
927 }
928
929 if (vol_id >= UBI_INTERNAL_VOL_START && compat != UBI_COMPAT_DELETE &&
930 compat != UBI_COMPAT_RO && compat != UBI_COMPAT_PRESERVE &&
931 compat != UBI_COMPAT_REJECT) {
932 dbg_err("bad compat");
933 goto bad;
934 }
935
936 if (vol_type != UBI_VID_DYNAMIC && vol_type != UBI_VID_STATIC) {
937 dbg_err("bad vol_type");
938 goto bad;
939 }
940
941 if (data_pad >= ubi->leb_size / 2) {
942 dbg_err("bad data_pad");
943 goto bad;
944 }
945
946 if (vol_type == UBI_VID_STATIC) {
947 /*
948 * Although from high-level point of view static volumes may
949 * contain zero bytes of data, but no VID headers can contain
950 * zero at these fields, because they empty volumes do not have
951 * mapped logical eraseblocks.
952 */
953 if (used_ebs == 0) {
954 dbg_err("zero used_ebs");
955 goto bad;
956 }
957 if (data_size == 0) {
958 dbg_err("zero data_size");
959 goto bad;
960 }
961 if (lnum < used_ebs - 1) {
962 if (data_size != usable_leb_size) {
963 dbg_err("bad data_size");
964 goto bad;
965 }
966 } else if (lnum == used_ebs - 1) {
967 if (data_size == 0) {
968 dbg_err("bad data_size at last LEB");
969 goto bad;
970 }
971 } else {
972 dbg_err("too high lnum");
973 goto bad;
974 }
975 } else {
976 if (copy_flag == 0) {
977 if (data_crc != 0) {
978 dbg_err("non-zero data CRC");
979 goto bad;
980 }
981 if (data_size != 0) {
982 dbg_err("non-zero data_size");
983 goto bad;
984 }
985 } else {
986 if (data_size == 0) {
987 dbg_err("zero data_size of copy");
988 goto bad;
989 }
990 }
991 if (used_ebs != 0) {
992 dbg_err("bad used_ebs");
993 goto bad;
994 }
995 }
996
997 return 0;
998
999bad:
1000 ubi_err("bad VID header");
1001 ubi_dbg_dump_vid_hdr(vid_hdr);
1002 ubi_dbg_dump_stack();
1003 return 1;
1004}
1005
1006/**
1007 * ubi_io_read_vid_hdr - read and check a volume identifier header.
1008 * @ubi: UBI device description object
1009 * @pnum: physical eraseblock number to read from
1010 * @vid_hdr: &struct ubi_vid_hdr object where to store the read volume
1011 * identifier header
1012 * @verbose: be verbose if the header is corrupted or wasn't found
1013 *
1014 * This function reads the volume identifier header from physical eraseblock
1015 * @pnum and stores it in @vid_hdr. It also checks CRC checksum of the read
1016 * volume identifier header. The error codes are the same as in
1017 * 'ubi_io_read_ec_hdr()'.
1018 *
1019 * Note, the implementation of this function is also very similar to
1020 * 'ubi_io_read_ec_hdr()', so refer commentaries in 'ubi_io_read_ec_hdr()'.
1021 */
1022int ubi_io_read_vid_hdr(struct ubi_device *ubi, int pnum,
1023 struct ubi_vid_hdr *vid_hdr, int verbose)
1024{
1025 int err, read_err;
1026 uint32_t crc, magic, hdr_crc;
1027 void *p;
1028
1029 dbg_io("read VID header from PEB %d", pnum);
1030 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
1031
1032 p = (char *)vid_hdr - ubi->vid_hdr_shift;
1033 read_err = ubi_io_read(ubi, p, pnum, ubi->vid_hdr_aloffset,
1034 ubi->vid_hdr_alsize);
1035 if (read_err && read_err != UBI_IO_BITFLIPS && read_err != -EBADMSG)
1036 return read_err;
1037
1038 magic = be32_to_cpu(vid_hdr->magic);
1039 if (magic != UBI_VID_HDR_MAGIC) {
1040 if (read_err == -EBADMSG)
1041 return UBI_IO_BAD_HDR_EBADMSG;
1042
1043 if (ubi_check_pattern(vid_hdr, 0xFF, UBI_VID_HDR_SIZE)) {
1044 if (verbose)
1045 ubi_warn("no VID header found at PEB %d, "
1046 "only 0xFF bytes", pnum);
1047 dbg_bld("no VID header found at PEB %d, "
1048 "only 0xFF bytes", pnum);
1049 if (!read_err)
1050 return UBI_IO_FF;
1051 else
1052 return UBI_IO_FF_BITFLIPS;
1053 }
1054
1055 if (verbose) {
1056 ubi_warn("bad magic number at PEB %d: %08x instead of "
1057 "%08x", pnum, magic, UBI_VID_HDR_MAGIC);
1058 ubi_dbg_dump_vid_hdr(vid_hdr);
1059 }
1060 dbg_bld("bad magic number at PEB %d: %08x instead of "
1061 "%08x", pnum, magic, UBI_VID_HDR_MAGIC);
1062 return UBI_IO_BAD_HDR;
1063 }
1064
1065 crc = crc32(UBI_CRC32_INIT, vid_hdr, UBI_VID_HDR_SIZE_CRC);
1066 hdr_crc = be32_to_cpu(vid_hdr->hdr_crc);
1067
1068 if (hdr_crc != crc) {
1069 if (verbose) {
1070 ubi_warn("bad CRC at PEB %d, calculated %#08x, "
1071 "read %#08x", pnum, crc, hdr_crc);
1072 ubi_dbg_dump_vid_hdr(vid_hdr);
1073 }
1074 dbg_bld("bad CRC at PEB %d, calculated %#08x, "
1075 "read %#08x", pnum, crc, hdr_crc);
1076 if (!read_err)
1077 return UBI_IO_BAD_HDR;
1078 else
1079 return UBI_IO_BAD_HDR_EBADMSG;
1080 }
1081
1082 err = validate_vid_hdr(ubi, vid_hdr);
1083 if (err) {
1084 ubi_err("validation failed for PEB %d", pnum);
1085 return -EINVAL;
1086 }
1087
1088 return read_err ? UBI_IO_BITFLIPS : 0;
1089}
1090
1091/**
1092 * ubi_io_write_vid_hdr - write a volume identifier header.
1093 * @ubi: UBI device description object
1094 * @pnum: the physical eraseblock number to write to
1095 * @vid_hdr: the volume identifier header to write
1096 *
1097 * This function writes the volume identifier header described by @vid_hdr to
1098 * physical eraseblock @pnum. This function automatically fills the
1099 * @vid_hdr->magic and the @vid_hdr->version fields, as well as calculates
1100 * header CRC checksum and stores it at vid_hdr->hdr_crc.
1101 *
1102 * This function returns zero in case of success and a negative error code in
1103 * case of failure. If %-EIO is returned, the physical eraseblock probably went
1104 * bad.
1105 */
1106int ubi_io_write_vid_hdr(struct ubi_device *ubi, int pnum,
1107 struct ubi_vid_hdr *vid_hdr)
1108{
1109 int err;
1110 uint32_t crc;
1111 void *p;
1112
1113 dbg_io("write VID header to PEB %d", pnum);
1114 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
1115
1116 err = paranoid_check_peb_ec_hdr(ubi, pnum);
1117 if (err)
1118 return err;
1119
1120 vid_hdr->magic = cpu_to_be32(UBI_VID_HDR_MAGIC);
1121 vid_hdr->version = UBI_VERSION;
1122 crc = crc32(UBI_CRC32_INIT, vid_hdr, UBI_VID_HDR_SIZE_CRC);
1123 vid_hdr->hdr_crc = cpu_to_be32(crc);
1124
1125 err = paranoid_check_vid_hdr(ubi, pnum, vid_hdr);
1126 if (err)
1127 return err;
1128
1129 p = (char *)vid_hdr - ubi->vid_hdr_shift;
1130 err = ubi_io_write(ubi, p, pnum, ubi->vid_hdr_aloffset,
1131 ubi->vid_hdr_alsize);
1132 return err;
1133}
1134
1135#ifdef CONFIG_MTD_UBI_DEBUG
1136
1137/**
1138 * paranoid_check_not_bad - ensure that a physical eraseblock is not bad.
1139 * @ubi: UBI device description object
1140 * @pnum: physical eraseblock number to check
1141 *
1142 * This function returns zero if the physical eraseblock is good, %-EINVAL if
1143 * it is bad and a negative error code if an error occurred.
1144 */
1145static int paranoid_check_not_bad(const struct ubi_device *ubi, int pnum)
1146{
1147 int err;
1148
1149 if (!ubi->dbg->chk_io)
1150 return 0;
1151
1152 err = ubi_io_is_bad(ubi, pnum);
1153 if (!err)
1154 return err;
1155
1156 ubi_err("paranoid check failed for PEB %d", pnum);
1157 ubi_dbg_dump_stack();
1158 return err > 0 ? -EINVAL : err;
1159}
1160
1161/**
1162 * paranoid_check_ec_hdr - check if an erase counter header is all right.
1163 * @ubi: UBI device description object
1164 * @pnum: physical eraseblock number the erase counter header belongs to
1165 * @ec_hdr: the erase counter header to check
1166 *
1167 * This function returns zero if the erase counter header contains valid
1168 * values, and %-EINVAL if not.
1169 */
1170static int paranoid_check_ec_hdr(const struct ubi_device *ubi, int pnum,
1171 const struct ubi_ec_hdr *ec_hdr)
1172{
1173 int err;
1174 uint32_t magic;
1175
1176 if (!ubi->dbg->chk_io)
1177 return 0;
1178
1179 magic = be32_to_cpu(ec_hdr->magic);
1180 if (magic != UBI_EC_HDR_MAGIC) {
1181 ubi_err("bad magic %#08x, must be %#08x",
1182 magic, UBI_EC_HDR_MAGIC);
1183 goto fail;
1184 }
1185
1186 err = validate_ec_hdr(ubi, ec_hdr);
1187 if (err) {
1188 ubi_err("paranoid check failed for PEB %d", pnum);
1189 goto fail;
1190 }
1191
1192 return 0;
1193
1194fail:
1195 ubi_dbg_dump_ec_hdr(ec_hdr);
1196 ubi_dbg_dump_stack();
1197 return -EINVAL;
1198}
1199
1200/**
1201 * paranoid_check_peb_ec_hdr - check erase counter header.
1202 * @ubi: UBI device description object
1203 * @pnum: the physical eraseblock number to check
1204 *
1205 * This function returns zero if the erase counter header is all right and and
1206 * a negative error code if not or if an error occurred.
1207 */
1208static int paranoid_check_peb_ec_hdr(const struct ubi_device *ubi, int pnum)
1209{
1210 int err;
1211 uint32_t crc, hdr_crc;
1212 struct ubi_ec_hdr *ec_hdr;
1213
1214 if (!ubi->dbg->chk_io)
1215 return 0;
1216
1217 ec_hdr = kzalloc(ubi->ec_hdr_alsize, GFP_NOFS);
1218 if (!ec_hdr)
1219 return -ENOMEM;
1220
1221 err = ubi_io_read(ubi, ec_hdr, pnum, 0, UBI_EC_HDR_SIZE);
1222 if (err && err != UBI_IO_BITFLIPS && err != -EBADMSG)
1223 goto exit;
1224
1225 crc = crc32(UBI_CRC32_INIT, ec_hdr, UBI_EC_HDR_SIZE_CRC);
1226 hdr_crc = be32_to_cpu(ec_hdr->hdr_crc);
1227 if (hdr_crc != crc) {
1228 ubi_err("bad CRC, calculated %#08x, read %#08x", crc, hdr_crc);
1229 ubi_err("paranoid check failed for PEB %d", pnum);
1230 ubi_dbg_dump_ec_hdr(ec_hdr);
1231 ubi_dbg_dump_stack();
1232 err = -EINVAL;
1233 goto exit;
1234 }
1235
1236 err = paranoid_check_ec_hdr(ubi, pnum, ec_hdr);
1237
1238exit:
1239 kfree(ec_hdr);
1240 return err;
1241}
1242
1243/**
1244 * paranoid_check_vid_hdr - check that a volume identifier header is all right.
1245 * @ubi: UBI device description object
1246 * @pnum: physical eraseblock number the volume identifier header belongs to
1247 * @vid_hdr: the volume identifier header to check
1248 *
1249 * This function returns zero if the volume identifier header is all right, and
1250 * %-EINVAL if not.
1251 */
1252static int paranoid_check_vid_hdr(const struct ubi_device *ubi, int pnum,
1253 const struct ubi_vid_hdr *vid_hdr)
1254{
1255 int err;
1256 uint32_t magic;
1257
1258 if (!ubi->dbg->chk_io)
1259 return 0;
1260
1261 magic = be32_to_cpu(vid_hdr->magic);
1262 if (magic != UBI_VID_HDR_MAGIC) {
1263 ubi_err("bad VID header magic %#08x at PEB %d, must be %#08x",
1264 magic, pnum, UBI_VID_HDR_MAGIC);
1265 goto fail;
1266 }
1267
1268 err = validate_vid_hdr(ubi, vid_hdr);
1269 if (err) {
1270 ubi_err("paranoid check failed for PEB %d", pnum);
1271 goto fail;
1272 }
1273
1274 return err;
1275
1276fail:
1277 ubi_err("paranoid check failed for PEB %d", pnum);
1278 ubi_dbg_dump_vid_hdr(vid_hdr);
1279 ubi_dbg_dump_stack();
1280 return -EINVAL;
1281
1282}
1283
1284/**
1285 * paranoid_check_peb_vid_hdr - check volume identifier header.
1286 * @ubi: UBI device description object
1287 * @pnum: the physical eraseblock number to check
1288 *
1289 * This function returns zero if the volume identifier header is all right,
1290 * and a negative error code if not or if an error occurred.
1291 */
1292static int paranoid_check_peb_vid_hdr(const struct ubi_device *ubi, int pnum)
1293{
1294 int err;
1295 uint32_t crc, hdr_crc;
1296 struct ubi_vid_hdr *vid_hdr;
1297 void *p;
1298
1299 if (!ubi->dbg->chk_io)
1300 return 0;
1301
1302 vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS);
1303 if (!vid_hdr)
1304 return -ENOMEM;
1305
1306 p = (char *)vid_hdr - ubi->vid_hdr_shift;
1307 err = ubi_io_read(ubi, p, pnum, ubi->vid_hdr_aloffset,
1308 ubi->vid_hdr_alsize);
1309 if (err && err != UBI_IO_BITFLIPS && err != -EBADMSG)
1310 goto exit;
1311
1312 crc = crc32(UBI_CRC32_INIT, vid_hdr, UBI_EC_HDR_SIZE_CRC);
1313 hdr_crc = be32_to_cpu(vid_hdr->hdr_crc);
1314 if (hdr_crc != crc) {
1315 ubi_err("bad VID header CRC at PEB %d, calculated %#08x, "
1316 "read %#08x", pnum, crc, hdr_crc);
1317 ubi_err("paranoid check failed for PEB %d", pnum);
1318 ubi_dbg_dump_vid_hdr(vid_hdr);
1319 ubi_dbg_dump_stack();
1320 err = -EINVAL;
1321 goto exit;
1322 }
1323
1324 err = paranoid_check_vid_hdr(ubi, pnum, vid_hdr);
1325
1326exit:
1327 ubi_free_vid_hdr(ubi, vid_hdr);
1328 return err;
1329}
1330
1331/**
1332 * ubi_dbg_check_write - make sure write succeeded.
1333 * @ubi: UBI device description object
1334 * @buf: buffer with data which were written
1335 * @pnum: physical eraseblock number the data were written to
1336 * @offset: offset within the physical eraseblock the data were written to
1337 * @len: how many bytes were written
1338 *
1339 * This functions reads data which were recently written and compares it with
1340 * the original data buffer - the data have to match. Returns zero if the data
1341 * match and a negative error code if not or in case of failure.
1342 */
1343int ubi_dbg_check_write(struct ubi_device *ubi, const void *buf, int pnum,
1344 int offset, int len)
1345{
1346 int err, i;
1347 size_t read;
1348 void *buf1;
1349 loff_t addr = (loff_t)pnum * ubi->peb_size + offset;
1350
1351 if (!ubi->dbg->chk_io)
1352 return 0;
1353
1354 buf1 = __vmalloc(len, GFP_NOFS, PAGE_KERNEL);
1355 if (!buf1) {
1356 ubi_err("cannot allocate memory to check writes");
1357 return 0;
1358 }
1359
1360 err = ubi->mtd->read(ubi->mtd, addr, len, &read, buf1);
1361 if (err && err != -EUCLEAN)
1362 goto out_free;
1363
1364 for (i = 0; i < len; i++) {
1365 uint8_t c = ((uint8_t *)buf)[i];
1366 uint8_t c1 = ((uint8_t *)buf1)[i];
1367 int dump_len;
1368
1369 if (c == c1)
1370 continue;
1371
1372 ubi_err("paranoid check failed for PEB %d:%d, len %d",
1373 pnum, offset, len);
1374 ubi_msg("data differ at position %d", i);
1375 dump_len = max_t(int, 128, len - i);
1376 ubi_msg("hex dump of the original buffer from %d to %d",
1377 i, i + dump_len);
1378 print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1,
1379 buf + i, dump_len, 1);
1380 ubi_msg("hex dump of the read buffer from %d to %d",
1381 i, i + dump_len);
1382 print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1,
1383 buf1 + i, dump_len, 1);
1384 ubi_dbg_dump_stack();
1385 err = -EINVAL;
1386 goto out_free;
1387 }
1388
1389 vfree(buf1);
1390 return 0;
1391
1392out_free:
1393 vfree(buf1);
1394 return err;
1395}
1396
1397/**
1398 * ubi_dbg_check_all_ff - check that a region of flash is empty.
1399 * @ubi: UBI device description object
1400 * @pnum: the physical eraseblock number to check
1401 * @offset: the starting offset within the physical eraseblock to check
1402 * @len: the length of the region to check
1403 *
1404 * This function returns zero if only 0xFF bytes are present at offset
1405 * @offset of the physical eraseblock @pnum, and a negative error code if not
1406 * or if an error occurred.
1407 */
1408int ubi_dbg_check_all_ff(struct ubi_device *ubi, int pnum, int offset, int len)
1409{
1410 size_t read;
1411 int err;
1412 void *buf;
1413 loff_t addr = (loff_t)pnum * ubi->peb_size + offset;
1414
1415 if (!ubi->dbg->chk_io)
1416 return 0;
1417
1418 buf = __vmalloc(len, GFP_NOFS, PAGE_KERNEL);
1419 if (!buf) {
1420 ubi_err("cannot allocate memory to check for 0xFFs");
1421 return 0;
1422 }
1423
1424 err = ubi->mtd->read(ubi->mtd, addr, len, &read, buf);
1425 if (err && err != -EUCLEAN) {
1426 ubi_err("error %d while reading %d bytes from PEB %d:%d, "
1427 "read %zd bytes", err, len, pnum, offset, read);
1428 goto error;
1429 }
1430
1431 err = ubi_check_pattern(buf, 0xFF, len);
1432 if (err == 0) {
1433 ubi_err("flash region at PEB %d:%d, length %d does not "
1434 "contain all 0xFF bytes", pnum, offset, len);
1435 goto fail;
1436 }
1437
1438 vfree(buf);
1439 return 0;
1440
1441fail:
1442 ubi_err("paranoid check failed for PEB %d", pnum);
1443 ubi_msg("hex dump of the %d-%d region", offset, offset + len);
1444 print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1, buf, len, 1);
1445 err = -EINVAL;
1446error:
1447 ubi_dbg_dump_stack();
1448 vfree(buf);
1449 return err;
1450}
1451
1452#endif /* CONFIG_MTD_UBI_DEBUG */
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 not relevant to the sub-page are 0xFF. So, basically,
68 * writing 4x512 sub-pages is 4 times slower than writing one 2KiB NAND page.
69 * Thus, we prefer to use sub-pages only for EC 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 <linux/slab.h>
92#include "ubi.h"
93
94static int self_check_not_bad(const struct ubi_device *ubi, int pnum);
95static int self_check_peb_ec_hdr(const struct ubi_device *ubi, int pnum);
96static int self_check_ec_hdr(const struct ubi_device *ubi, int pnum,
97 const struct ubi_ec_hdr *ec_hdr);
98static int self_check_peb_vid_hdr(const struct ubi_device *ubi, int pnum);
99static int self_check_vid_hdr(const struct ubi_device *ubi, int pnum,
100 const struct ubi_vid_hdr *vid_hdr);
101static int self_check_write(struct ubi_device *ubi, const void *buf, int pnum,
102 int offset, int len);
103
104/**
105 * ubi_io_read - read data from a physical eraseblock.
106 * @ubi: UBI device description object
107 * @buf: buffer where to store the read data
108 * @pnum: physical eraseblock number to read from
109 * @offset: offset within the physical eraseblock from where to read
110 * @len: how many bytes to read
111 *
112 * This function reads data from offset @offset of physical eraseblock @pnum
113 * and stores the read data in the @buf buffer. The following return codes are
114 * possible:
115 *
116 * o %0 if all the requested data were successfully read;
117 * o %UBI_IO_BITFLIPS if all the requested data were successfully read, but
118 * correctable bit-flips were detected; this is harmless but may indicate
119 * that this eraseblock may become bad soon (but do not have to);
120 * o %-EBADMSG if the MTD subsystem reported about data integrity problems, for
121 * example it can be an ECC error in case of NAND; this most probably means
122 * that the data is corrupted;
123 * o %-EIO if some I/O error occurred;
124 * o other negative error codes in case of other errors.
125 */
126int ubi_io_read(const struct ubi_device *ubi, void *buf, int pnum, int offset,
127 int len)
128{
129 int err, retries = 0;
130 size_t read;
131 loff_t addr;
132
133 dbg_io("read %d bytes from PEB %d:%d", len, pnum, offset);
134
135 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
136 ubi_assert(offset >= 0 && offset + len <= ubi->peb_size);
137 ubi_assert(len > 0);
138
139 err = self_check_not_bad(ubi, pnum);
140 if (err)
141 return err;
142
143 /*
144 * Deliberately corrupt the buffer to improve robustness. Indeed, if we
145 * do not do this, the following may happen:
146 * 1. The buffer contains data from previous operation, e.g., read from
147 * another PEB previously. The data looks like expected, e.g., if we
148 * just do not read anything and return - the caller would not
149 * notice this. E.g., if we are reading a VID header, the buffer may
150 * contain a valid VID header from another PEB.
151 * 2. The driver is buggy and returns us success or -EBADMSG or
152 * -EUCLEAN, but it does not actually put any data to the buffer.
153 *
154 * This may confuse UBI or upper layers - they may think the buffer
155 * contains valid data while in fact it is just old data. This is
156 * especially possible because UBI (and UBIFS) relies on CRC, and
157 * treats data as correct even in case of ECC errors if the CRC is
158 * correct.
159 *
160 * Try to prevent this situation by changing the first byte of the
161 * buffer.
162 */
163 *((uint8_t *)buf) ^= 0xFF;
164
165 addr = (loff_t)pnum * ubi->peb_size + offset;
166retry:
167 err = mtd_read(ubi->mtd, addr, len, &read, buf);
168 if (err) {
169 const char *errstr = mtd_is_eccerr(err) ? " (ECC error)" : "";
170
171 if (mtd_is_bitflip(err)) {
172 /*
173 * -EUCLEAN is reported if there was a bit-flip which
174 * was corrected, so this is harmless.
175 *
176 * We do not report about it here unless debugging is
177 * enabled. A corresponding message will be printed
178 * later, when it is has been scrubbed.
179 */
180 dbg_msg("fixable bit-flip detected at PEB %d", pnum);
181 ubi_assert(len == read);
182 return UBI_IO_BITFLIPS;
183 }
184
185 if (retries++ < UBI_IO_RETRIES) {
186 ubi_warn("error %d%s while reading %d bytes from PEB "
187 "%d:%d, read only %zd bytes, retry",
188 err, errstr, len, pnum, offset, read);
189 yield();
190 goto retry;
191 }
192
193 ubi_err("error %d%s while reading %d bytes from PEB %d:%d, "
194 "read %zd bytes", err, errstr, len, pnum, offset, read);
195 dump_stack();
196
197 /*
198 * The driver should never return -EBADMSG if it failed to read
199 * all the requested data. But some buggy drivers might do
200 * this, so we change it to -EIO.
201 */
202 if (read != len && mtd_is_eccerr(err)) {
203 ubi_assert(0);
204 err = -EIO;
205 }
206 } else {
207 ubi_assert(len == read);
208
209 if (ubi_dbg_is_bitflip(ubi)) {
210 dbg_gen("bit-flip (emulated)");
211 err = UBI_IO_BITFLIPS;
212 }
213 }
214
215 return err;
216}
217
218/**
219 * ubi_io_write - write data to a physical eraseblock.
220 * @ubi: UBI device description object
221 * @buf: buffer with the data to write
222 * @pnum: physical eraseblock number to write to
223 * @offset: offset within the physical eraseblock where to write
224 * @len: how many bytes to write
225 *
226 * This function writes @len bytes of data from buffer @buf to offset @offset
227 * of physical eraseblock @pnum. If all the data were successfully written,
228 * zero is returned. If an error occurred, this function returns a negative
229 * error code. If %-EIO is returned, the physical eraseblock most probably went
230 * bad.
231 *
232 * Note, in case of an error, it is possible that something was still written
233 * to the flash media, but may be some garbage.
234 */
235int ubi_io_write(struct ubi_device *ubi, const void *buf, int pnum, int offset,
236 int len)
237{
238 int err;
239 size_t written;
240 loff_t addr;
241
242 dbg_io("write %d bytes to PEB %d:%d", len, pnum, offset);
243
244 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
245 ubi_assert(offset >= 0 && offset + len <= ubi->peb_size);
246 ubi_assert(offset % ubi->hdrs_min_io_size == 0);
247 ubi_assert(len > 0 && len % ubi->hdrs_min_io_size == 0);
248
249 if (ubi->ro_mode) {
250 ubi_err("read-only mode");
251 return -EROFS;
252 }
253
254 err = self_check_not_bad(ubi, pnum);
255 if (err)
256 return err;
257
258 /* The area we are writing to has to contain all 0xFF bytes */
259 err = ubi_self_check_all_ff(ubi, pnum, offset, len);
260 if (err)
261 return err;
262
263 if (offset >= ubi->leb_start) {
264 /*
265 * We write to the data area of the physical eraseblock. Make
266 * sure it has valid EC and VID headers.
267 */
268 err = self_check_peb_ec_hdr(ubi, pnum);
269 if (err)
270 return err;
271 err = self_check_peb_vid_hdr(ubi, pnum);
272 if (err)
273 return err;
274 }
275
276 if (ubi_dbg_is_write_failure(ubi)) {
277 ubi_err("cannot write %d bytes to PEB %d:%d "
278 "(emulated)", len, pnum, offset);
279 dump_stack();
280 return -EIO;
281 }
282
283 addr = (loff_t)pnum * ubi->peb_size + offset;
284 err = mtd_write(ubi->mtd, addr, len, &written, buf);
285 if (err) {
286 ubi_err("error %d while writing %d bytes to PEB %d:%d, written "
287 "%zd bytes", err, len, pnum, offset, written);
288 dump_stack();
289 ubi_dump_flash(ubi, pnum, offset, len);
290 } else
291 ubi_assert(written == len);
292
293 if (!err) {
294 err = self_check_write(ubi, buf, pnum, offset, len);
295 if (err)
296 return err;
297
298 /*
299 * Since we always write sequentially, the rest of the PEB has
300 * to contain only 0xFF bytes.
301 */
302 offset += len;
303 len = ubi->peb_size - offset;
304 if (len)
305 err = ubi_self_check_all_ff(ubi, pnum, offset, len);
306 }
307
308 return err;
309}
310
311/**
312 * erase_callback - MTD erasure call-back.
313 * @ei: MTD erase information object.
314 *
315 * Note, even though MTD erase interface is asynchronous, all the current
316 * implementations are synchronous anyway.
317 */
318static void erase_callback(struct erase_info *ei)
319{
320 wake_up_interruptible((wait_queue_head_t *)ei->priv);
321}
322
323/**
324 * do_sync_erase - synchronously erase a physical eraseblock.
325 * @ubi: UBI device description object
326 * @pnum: the physical eraseblock number to erase
327 *
328 * This function synchronously erases physical eraseblock @pnum and returns
329 * zero in case of success and a negative error code in case of failure. If
330 * %-EIO is returned, the physical eraseblock most probably went bad.
331 */
332static int do_sync_erase(struct ubi_device *ubi, int pnum)
333{
334 int err, retries = 0;
335 struct erase_info ei;
336 wait_queue_head_t wq;
337
338 dbg_io("erase PEB %d", pnum);
339 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
340
341 if (ubi->ro_mode) {
342 ubi_err("read-only mode");
343 return -EROFS;
344 }
345
346retry:
347 init_waitqueue_head(&wq);
348 memset(&ei, 0, sizeof(struct erase_info));
349
350 ei.mtd = ubi->mtd;
351 ei.addr = (loff_t)pnum * ubi->peb_size;
352 ei.len = ubi->peb_size;
353 ei.callback = erase_callback;
354 ei.priv = (unsigned long)&wq;
355
356 err = mtd_erase(ubi->mtd, &ei);
357 if (err) {
358 if (retries++ < UBI_IO_RETRIES) {
359 ubi_warn("error %d while erasing PEB %d, retry",
360 err, pnum);
361 yield();
362 goto retry;
363 }
364 ubi_err("cannot erase PEB %d, error %d", pnum, err);
365 dump_stack();
366 return err;
367 }
368
369 err = wait_event_interruptible(wq, ei.state == MTD_ERASE_DONE ||
370 ei.state == MTD_ERASE_FAILED);
371 if (err) {
372 ubi_err("interrupted PEB %d erasure", pnum);
373 return -EINTR;
374 }
375
376 if (ei.state == MTD_ERASE_FAILED) {
377 if (retries++ < UBI_IO_RETRIES) {
378 ubi_warn("error while erasing PEB %d, retry", pnum);
379 yield();
380 goto retry;
381 }
382 ubi_err("cannot erase PEB %d", pnum);
383 dump_stack();
384 return -EIO;
385 }
386
387 err = ubi_self_check_all_ff(ubi, pnum, 0, ubi->peb_size);
388 if (err)
389 return err;
390
391 if (ubi_dbg_is_erase_failure(ubi)) {
392 ubi_err("cannot erase PEB %d (emulated)", pnum);
393 return -EIO;
394 }
395
396 return 0;
397}
398
399/* Patterns to write to a physical eraseblock when torturing it */
400static uint8_t patterns[] = {0xa5, 0x5a, 0x0};
401
402/**
403 * torture_peb - test a supposedly bad physical eraseblock.
404 * @ubi: UBI device description object
405 * @pnum: the physical eraseblock number to test
406 *
407 * This function returns %-EIO if the physical eraseblock did not pass the
408 * test, a positive number of erase operations done if the test was
409 * successfully passed, and other negative error codes in case of other errors.
410 */
411static int torture_peb(struct ubi_device *ubi, int pnum)
412{
413 int err, i, patt_count;
414
415 ubi_msg("run torture test for PEB %d", pnum);
416 patt_count = ARRAY_SIZE(patterns);
417 ubi_assert(patt_count > 0);
418
419 mutex_lock(&ubi->buf_mutex);
420 for (i = 0; i < patt_count; i++) {
421 err = do_sync_erase(ubi, pnum);
422 if (err)
423 goto out;
424
425 /* Make sure the PEB contains only 0xFF bytes */
426 err = ubi_io_read(ubi, ubi->peb_buf, pnum, 0, ubi->peb_size);
427 if (err)
428 goto out;
429
430 err = ubi_check_pattern(ubi->peb_buf, 0xFF, ubi->peb_size);
431 if (err == 0) {
432 ubi_err("erased PEB %d, but a non-0xFF byte found",
433 pnum);
434 err = -EIO;
435 goto out;
436 }
437
438 /* Write a pattern and check it */
439 memset(ubi->peb_buf, patterns[i], ubi->peb_size);
440 err = ubi_io_write(ubi, ubi->peb_buf, pnum, 0, ubi->peb_size);
441 if (err)
442 goto out;
443
444 memset(ubi->peb_buf, ~patterns[i], ubi->peb_size);
445 err = ubi_io_read(ubi, ubi->peb_buf, pnum, 0, ubi->peb_size);
446 if (err)
447 goto out;
448
449 err = ubi_check_pattern(ubi->peb_buf, patterns[i],
450 ubi->peb_size);
451 if (err == 0) {
452 ubi_err("pattern %x checking failed for PEB %d",
453 patterns[i], pnum);
454 err = -EIO;
455 goto out;
456 }
457 }
458
459 err = patt_count;
460 ubi_msg("PEB %d passed torture test, do not mark it as bad", pnum);
461
462out:
463 mutex_unlock(&ubi->buf_mutex);
464 if (err == UBI_IO_BITFLIPS || mtd_is_eccerr(err)) {
465 /*
466 * If a bit-flip or data integrity error was detected, the test
467 * has not passed because it happened on a freshly erased
468 * physical eraseblock which means something is wrong with it.
469 */
470 ubi_err("read problems on freshly erased PEB %d, must be bad",
471 pnum);
472 err = -EIO;
473 }
474 return err;
475}
476
477/**
478 * nor_erase_prepare - prepare a NOR flash PEB for erasure.
479 * @ubi: UBI device description object
480 * @pnum: physical eraseblock number to prepare
481 *
482 * NOR flash, or at least some of them, have peculiar embedded PEB erasure
483 * algorithm: the PEB is first filled with zeroes, then it is erased. And
484 * filling with zeroes starts from the end of the PEB. This was observed with
485 * Spansion S29GL512N NOR flash.
486 *
487 * This means that in case of a power cut we may end up with intact data at the
488 * beginning of the PEB, and all zeroes at the end of PEB. In other words, the
489 * EC and VID headers are OK, but a large chunk of data at the end of PEB is
490 * zeroed. This makes UBI mistakenly treat this PEB as used and associate it
491 * with an LEB, which leads to subsequent failures (e.g., UBIFS fails).
492 *
493 * This function is called before erasing NOR PEBs and it zeroes out EC and VID
494 * magic numbers in order to invalidate them and prevent the failures. Returns
495 * zero in case of success and a negative error code in case of failure.
496 */
497static int nor_erase_prepare(struct ubi_device *ubi, int pnum)
498{
499 int err, err1;
500 size_t written;
501 loff_t addr;
502 uint32_t data = 0;
503 /*
504 * Note, we cannot generally define VID header buffers on stack,
505 * because of the way we deal with these buffers (see the header
506 * comment in this file). But we know this is a NOR-specific piece of
507 * code, so we can do this. But yes, this is error-prone and we should
508 * (pre-)allocate VID header buffer instead.
509 */
510 struct ubi_vid_hdr vid_hdr;
511
512 /*
513 * It is important to first invalidate the EC header, and then the VID
514 * header. Otherwise a power cut may lead to valid EC header and
515 * invalid VID header, in which case UBI will treat this PEB as
516 * corrupted and will try to preserve it, and print scary warnings.
517 */
518 addr = (loff_t)pnum * ubi->peb_size;
519 err = mtd_write(ubi->mtd, addr, 4, &written, (void *)&data);
520 if (!err) {
521 addr += ubi->vid_hdr_aloffset;
522 err = mtd_write(ubi->mtd, addr, 4, &written, (void *)&data);
523 if (!err)
524 return 0;
525 }
526
527 /*
528 * We failed to write to the media. This was observed with Spansion
529 * S29GL512N NOR flash. Most probably the previously eraseblock erasure
530 * was interrupted at a very inappropriate moment, so it became
531 * unwritable. In this case we probably anyway have garbage in this
532 * PEB.
533 */
534 err1 = ubi_io_read_vid_hdr(ubi, pnum, &vid_hdr, 0);
535 if (err1 == UBI_IO_BAD_HDR_EBADMSG || err1 == UBI_IO_BAD_HDR ||
536 err1 == UBI_IO_FF) {
537 struct ubi_ec_hdr ec_hdr;
538
539 err1 = ubi_io_read_ec_hdr(ubi, pnum, &ec_hdr, 0);
540 if (err1 == UBI_IO_BAD_HDR_EBADMSG || err1 == UBI_IO_BAD_HDR ||
541 err1 == UBI_IO_FF)
542 /*
543 * Both VID and EC headers are corrupted, so we can
544 * safely erase this PEB and not afraid that it will be
545 * treated as a valid PEB in case of an unclean reboot.
546 */
547 return 0;
548 }
549
550 /*
551 * The PEB contains a valid VID header, but we cannot invalidate it.
552 * Supposedly the flash media or the driver is screwed up, so return an
553 * error.
554 */
555 ubi_err("cannot invalidate PEB %d, write returned %d read returned %d",
556 pnum, err, err1);
557 ubi_dump_flash(ubi, pnum, 0, ubi->peb_size);
558 return -EIO;
559}
560
561/**
562 * ubi_io_sync_erase - synchronously erase a physical eraseblock.
563 * @ubi: UBI device description object
564 * @pnum: physical eraseblock number to erase
565 * @torture: if this physical eraseblock has to be tortured
566 *
567 * This function synchronously erases physical eraseblock @pnum. If @torture
568 * flag is not zero, the physical eraseblock is checked by means of writing
569 * different patterns to it and reading them back. If the torturing is enabled,
570 * the physical eraseblock is erased more than once.
571 *
572 * This function returns the number of erasures made in case of success, %-EIO
573 * if the erasure failed or the torturing test failed, and other negative error
574 * codes in case of other errors. Note, %-EIO means that the physical
575 * eraseblock is bad.
576 */
577int ubi_io_sync_erase(struct ubi_device *ubi, int pnum, int torture)
578{
579 int err, ret = 0;
580
581 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
582
583 err = self_check_not_bad(ubi, pnum);
584 if (err != 0)
585 return err;
586
587 if (ubi->ro_mode) {
588 ubi_err("read-only mode");
589 return -EROFS;
590 }
591
592 if (ubi->nor_flash) {
593 err = nor_erase_prepare(ubi, pnum);
594 if (err)
595 return err;
596 }
597
598 if (torture) {
599 ret = torture_peb(ubi, pnum);
600 if (ret < 0)
601 return ret;
602 }
603
604 err = do_sync_erase(ubi, pnum);
605 if (err)
606 return err;
607
608 return ret + 1;
609}
610
611/**
612 * ubi_io_is_bad - check if a physical eraseblock is bad.
613 * @ubi: UBI device description object
614 * @pnum: the physical eraseblock number to check
615 *
616 * This function returns a positive number if the physical eraseblock is bad,
617 * zero if not, and a negative error code if an error occurred.
618 */
619int ubi_io_is_bad(const struct ubi_device *ubi, int pnum)
620{
621 struct mtd_info *mtd = ubi->mtd;
622
623 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
624
625 if (ubi->bad_allowed) {
626 int ret;
627
628 ret = mtd_block_isbad(mtd, (loff_t)pnum * ubi->peb_size);
629 if (ret < 0)
630 ubi_err("error %d while checking if PEB %d is bad",
631 ret, pnum);
632 else if (ret)
633 dbg_io("PEB %d is bad", pnum);
634 return ret;
635 }
636
637 return 0;
638}
639
640/**
641 * ubi_io_mark_bad - mark a physical eraseblock as bad.
642 * @ubi: UBI device description object
643 * @pnum: the physical eraseblock number to mark
644 *
645 * This function returns zero in case of success and a negative error code in
646 * case of failure.
647 */
648int ubi_io_mark_bad(const struct ubi_device *ubi, int pnum)
649{
650 int err;
651 struct mtd_info *mtd = ubi->mtd;
652
653 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
654
655 if (ubi->ro_mode) {
656 ubi_err("read-only mode");
657 return -EROFS;
658 }
659
660 if (!ubi->bad_allowed)
661 return 0;
662
663 err = mtd_block_markbad(mtd, (loff_t)pnum * ubi->peb_size);
664 if (err)
665 ubi_err("cannot mark PEB %d bad, error %d", pnum, err);
666 return err;
667}
668
669/**
670 * validate_ec_hdr - validate an erase counter header.
671 * @ubi: UBI device description object
672 * @ec_hdr: the erase counter header to check
673 *
674 * This function returns zero if the erase counter header is OK, and %1 if
675 * not.
676 */
677static int validate_ec_hdr(const struct ubi_device *ubi,
678 const struct ubi_ec_hdr *ec_hdr)
679{
680 long long ec;
681 int vid_hdr_offset, leb_start;
682
683 ec = be64_to_cpu(ec_hdr->ec);
684 vid_hdr_offset = be32_to_cpu(ec_hdr->vid_hdr_offset);
685 leb_start = be32_to_cpu(ec_hdr->data_offset);
686
687 if (ec_hdr->version != UBI_VERSION) {
688 ubi_err("node with incompatible UBI version found: "
689 "this UBI version is %d, image version is %d",
690 UBI_VERSION, (int)ec_hdr->version);
691 goto bad;
692 }
693
694 if (vid_hdr_offset != ubi->vid_hdr_offset) {
695 ubi_err("bad VID header offset %d, expected %d",
696 vid_hdr_offset, ubi->vid_hdr_offset);
697 goto bad;
698 }
699
700 if (leb_start != ubi->leb_start) {
701 ubi_err("bad data offset %d, expected %d",
702 leb_start, ubi->leb_start);
703 goto bad;
704 }
705
706 if (ec < 0 || ec > UBI_MAX_ERASECOUNTER) {
707 ubi_err("bad erase counter %lld", ec);
708 goto bad;
709 }
710
711 return 0;
712
713bad:
714 ubi_err("bad EC header");
715 ubi_dump_ec_hdr(ec_hdr);
716 dump_stack();
717 return 1;
718}
719
720/**
721 * ubi_io_read_ec_hdr - read and check an erase counter header.
722 * @ubi: UBI device description object
723 * @pnum: physical eraseblock to read from
724 * @ec_hdr: a &struct ubi_ec_hdr object where to store the read erase counter
725 * header
726 * @verbose: be verbose if the header is corrupted or was not found
727 *
728 * This function reads erase counter header from physical eraseblock @pnum and
729 * stores it in @ec_hdr. This function also checks CRC checksum of the read
730 * erase counter header. The following codes may be returned:
731 *
732 * o %0 if the CRC checksum is correct and the header was successfully read;
733 * o %UBI_IO_BITFLIPS if the CRC is correct, but bit-flips were detected
734 * and corrected by the flash driver; this is harmless but may indicate that
735 * this eraseblock may become bad soon (but may be not);
736 * o %UBI_IO_BAD_HDR if the erase counter header is corrupted (a CRC error);
737 * o %UBI_IO_BAD_HDR_EBADMSG is the same as %UBI_IO_BAD_HDR, but there also was
738 * a data integrity error (uncorrectable ECC error in case of NAND);
739 * o %UBI_IO_FF if only 0xFF bytes were read (the PEB is supposedly empty)
740 * o a negative error code in case of failure.
741 */
742int ubi_io_read_ec_hdr(struct ubi_device *ubi, int pnum,
743 struct ubi_ec_hdr *ec_hdr, int verbose)
744{
745 int err, read_err;
746 uint32_t crc, magic, hdr_crc;
747
748 dbg_io("read EC header from PEB %d", pnum);
749 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
750
751 read_err = ubi_io_read(ubi, ec_hdr, pnum, 0, UBI_EC_HDR_SIZE);
752 if (read_err) {
753 if (read_err != UBI_IO_BITFLIPS && !mtd_is_eccerr(read_err))
754 return read_err;
755
756 /*
757 * We read all the data, but either a correctable bit-flip
758 * occurred, or MTD reported a data integrity error
759 * (uncorrectable ECC error in case of NAND). The former is
760 * harmless, the later may mean that the read data is
761 * corrupted. But we have a CRC check-sum and we will detect
762 * this. If the EC header is still OK, we just report this as
763 * there was a bit-flip, to force scrubbing.
764 */
765 }
766
767 magic = be32_to_cpu(ec_hdr->magic);
768 if (magic != UBI_EC_HDR_MAGIC) {
769 if (mtd_is_eccerr(read_err))
770 return UBI_IO_BAD_HDR_EBADMSG;
771
772 /*
773 * The magic field is wrong. Let's check if we have read all
774 * 0xFF. If yes, this physical eraseblock is assumed to be
775 * empty.
776 */
777 if (ubi_check_pattern(ec_hdr, 0xFF, UBI_EC_HDR_SIZE)) {
778 /* The physical eraseblock is supposedly empty */
779 if (verbose)
780 ubi_warn("no EC header found at PEB %d, "
781 "only 0xFF bytes", pnum);
782 dbg_bld("no EC header found at PEB %d, "
783 "only 0xFF bytes", pnum);
784 if (!read_err)
785 return UBI_IO_FF;
786 else
787 return UBI_IO_FF_BITFLIPS;
788 }
789
790 /*
791 * This is not a valid erase counter header, and these are not
792 * 0xFF bytes. Report that the header is corrupted.
793 */
794 if (verbose) {
795 ubi_warn("bad magic number at PEB %d: %08x instead of "
796 "%08x", pnum, magic, UBI_EC_HDR_MAGIC);
797 ubi_dump_ec_hdr(ec_hdr);
798 }
799 dbg_bld("bad magic number at PEB %d: %08x instead of "
800 "%08x", pnum, magic, UBI_EC_HDR_MAGIC);
801 return UBI_IO_BAD_HDR;
802 }
803
804 crc = crc32(UBI_CRC32_INIT, ec_hdr, UBI_EC_HDR_SIZE_CRC);
805 hdr_crc = be32_to_cpu(ec_hdr->hdr_crc);
806
807 if (hdr_crc != crc) {
808 if (verbose) {
809 ubi_warn("bad EC header CRC at PEB %d, calculated "
810 "%#08x, read %#08x", pnum, crc, hdr_crc);
811 ubi_dump_ec_hdr(ec_hdr);
812 }
813 dbg_bld("bad EC header CRC at PEB %d, calculated "
814 "%#08x, read %#08x", pnum, crc, hdr_crc);
815
816 if (!read_err)
817 return UBI_IO_BAD_HDR;
818 else
819 return UBI_IO_BAD_HDR_EBADMSG;
820 }
821
822 /* And of course validate what has just been read from the media */
823 err = validate_ec_hdr(ubi, ec_hdr);
824 if (err) {
825 ubi_err("validation failed for PEB %d", pnum);
826 return -EINVAL;
827 }
828
829 /*
830 * If there was %-EBADMSG, but the header CRC is still OK, report about
831 * a bit-flip to force scrubbing on this PEB.
832 */
833 return read_err ? UBI_IO_BITFLIPS : 0;
834}
835
836/**
837 * ubi_io_write_ec_hdr - write an erase counter header.
838 * @ubi: UBI device description object
839 * @pnum: physical eraseblock to write to
840 * @ec_hdr: the erase counter header to write
841 *
842 * This function writes erase counter header described by @ec_hdr to physical
843 * eraseblock @pnum. It also fills most fields of @ec_hdr before writing, so
844 * the caller do not have to fill them. Callers must only fill the @ec_hdr->ec
845 * field.
846 *
847 * This function returns zero in case of success and a negative error code in
848 * case of failure. If %-EIO is returned, the physical eraseblock most probably
849 * went bad.
850 */
851int ubi_io_write_ec_hdr(struct ubi_device *ubi, int pnum,
852 struct ubi_ec_hdr *ec_hdr)
853{
854 int err;
855 uint32_t crc;
856
857 dbg_io("write EC header to PEB %d", pnum);
858 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
859
860 ec_hdr->magic = cpu_to_be32(UBI_EC_HDR_MAGIC);
861 ec_hdr->version = UBI_VERSION;
862 ec_hdr->vid_hdr_offset = cpu_to_be32(ubi->vid_hdr_offset);
863 ec_hdr->data_offset = cpu_to_be32(ubi->leb_start);
864 ec_hdr->image_seq = cpu_to_be32(ubi->image_seq);
865 crc = crc32(UBI_CRC32_INIT, ec_hdr, UBI_EC_HDR_SIZE_CRC);
866 ec_hdr->hdr_crc = cpu_to_be32(crc);
867
868 err = self_check_ec_hdr(ubi, pnum, ec_hdr);
869 if (err)
870 return err;
871
872 err = ubi_io_write(ubi, ec_hdr, pnum, 0, ubi->ec_hdr_alsize);
873 return err;
874}
875
876/**
877 * validate_vid_hdr - validate a volume identifier header.
878 * @ubi: UBI device description object
879 * @vid_hdr: the volume identifier header to check
880 *
881 * This function checks that data stored in the volume identifier header
882 * @vid_hdr. Returns zero if the VID header is OK and %1 if not.
883 */
884static int validate_vid_hdr(const struct ubi_device *ubi,
885 const struct ubi_vid_hdr *vid_hdr)
886{
887 int vol_type = vid_hdr->vol_type;
888 int copy_flag = vid_hdr->copy_flag;
889 int vol_id = be32_to_cpu(vid_hdr->vol_id);
890 int lnum = be32_to_cpu(vid_hdr->lnum);
891 int compat = vid_hdr->compat;
892 int data_size = be32_to_cpu(vid_hdr->data_size);
893 int used_ebs = be32_to_cpu(vid_hdr->used_ebs);
894 int data_pad = be32_to_cpu(vid_hdr->data_pad);
895 int data_crc = be32_to_cpu(vid_hdr->data_crc);
896 int usable_leb_size = ubi->leb_size - data_pad;
897
898 if (copy_flag != 0 && copy_flag != 1) {
899 ubi_err("bad copy_flag");
900 goto bad;
901 }
902
903 if (vol_id < 0 || lnum < 0 || data_size < 0 || used_ebs < 0 ||
904 data_pad < 0) {
905 ubi_err("negative values");
906 goto bad;
907 }
908
909 if (vol_id >= UBI_MAX_VOLUMES && vol_id < UBI_INTERNAL_VOL_START) {
910 ubi_err("bad vol_id");
911 goto bad;
912 }
913
914 if (vol_id < UBI_INTERNAL_VOL_START && compat != 0) {
915 ubi_err("bad compat");
916 goto bad;
917 }
918
919 if (vol_id >= UBI_INTERNAL_VOL_START && compat != UBI_COMPAT_DELETE &&
920 compat != UBI_COMPAT_RO && compat != UBI_COMPAT_PRESERVE &&
921 compat != UBI_COMPAT_REJECT) {
922 ubi_err("bad compat");
923 goto bad;
924 }
925
926 if (vol_type != UBI_VID_DYNAMIC && vol_type != UBI_VID_STATIC) {
927 ubi_err("bad vol_type");
928 goto bad;
929 }
930
931 if (data_pad >= ubi->leb_size / 2) {
932 ubi_err("bad data_pad");
933 goto bad;
934 }
935
936 if (vol_type == UBI_VID_STATIC) {
937 /*
938 * Although from high-level point of view static volumes may
939 * contain zero bytes of data, but no VID headers can contain
940 * zero at these fields, because they empty volumes do not have
941 * mapped logical eraseblocks.
942 */
943 if (used_ebs == 0) {
944 ubi_err("zero used_ebs");
945 goto bad;
946 }
947 if (data_size == 0) {
948 ubi_err("zero data_size");
949 goto bad;
950 }
951 if (lnum < used_ebs - 1) {
952 if (data_size != usable_leb_size) {
953 ubi_err("bad data_size");
954 goto bad;
955 }
956 } else if (lnum == used_ebs - 1) {
957 if (data_size == 0) {
958 ubi_err("bad data_size at last LEB");
959 goto bad;
960 }
961 } else {
962 ubi_err("too high lnum");
963 goto bad;
964 }
965 } else {
966 if (copy_flag == 0) {
967 if (data_crc != 0) {
968 ubi_err("non-zero data CRC");
969 goto bad;
970 }
971 if (data_size != 0) {
972 ubi_err("non-zero data_size");
973 goto bad;
974 }
975 } else {
976 if (data_size == 0) {
977 ubi_err("zero data_size of copy");
978 goto bad;
979 }
980 }
981 if (used_ebs != 0) {
982 ubi_err("bad used_ebs");
983 goto bad;
984 }
985 }
986
987 return 0;
988
989bad:
990 ubi_err("bad VID header");
991 ubi_dump_vid_hdr(vid_hdr);
992 dump_stack();
993 return 1;
994}
995
996/**
997 * ubi_io_read_vid_hdr - read and check a volume identifier header.
998 * @ubi: UBI device description object
999 * @pnum: physical eraseblock number to read from
1000 * @vid_hdr: &struct ubi_vid_hdr object where to store the read volume
1001 * identifier header
1002 * @verbose: be verbose if the header is corrupted or wasn't found
1003 *
1004 * This function reads the volume identifier header from physical eraseblock
1005 * @pnum and stores it in @vid_hdr. It also checks CRC checksum of the read
1006 * volume identifier header. The error codes are the same as in
1007 * 'ubi_io_read_ec_hdr()'.
1008 *
1009 * Note, the implementation of this function is also very similar to
1010 * 'ubi_io_read_ec_hdr()', so refer commentaries in 'ubi_io_read_ec_hdr()'.
1011 */
1012int ubi_io_read_vid_hdr(struct ubi_device *ubi, int pnum,
1013 struct ubi_vid_hdr *vid_hdr, int verbose)
1014{
1015 int err, read_err;
1016 uint32_t crc, magic, hdr_crc;
1017 void *p;
1018
1019 dbg_io("read VID header from PEB %d", pnum);
1020 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
1021
1022 p = (char *)vid_hdr - ubi->vid_hdr_shift;
1023 read_err = ubi_io_read(ubi, p, pnum, ubi->vid_hdr_aloffset,
1024 ubi->vid_hdr_alsize);
1025 if (read_err && read_err != UBI_IO_BITFLIPS && !mtd_is_eccerr(read_err))
1026 return read_err;
1027
1028 magic = be32_to_cpu(vid_hdr->magic);
1029 if (magic != UBI_VID_HDR_MAGIC) {
1030 if (mtd_is_eccerr(read_err))
1031 return UBI_IO_BAD_HDR_EBADMSG;
1032
1033 if (ubi_check_pattern(vid_hdr, 0xFF, UBI_VID_HDR_SIZE)) {
1034 if (verbose)
1035 ubi_warn("no VID header found at PEB %d, "
1036 "only 0xFF bytes", pnum);
1037 dbg_bld("no VID header found at PEB %d, "
1038 "only 0xFF bytes", pnum);
1039 if (!read_err)
1040 return UBI_IO_FF;
1041 else
1042 return UBI_IO_FF_BITFLIPS;
1043 }
1044
1045 if (verbose) {
1046 ubi_warn("bad magic number at PEB %d: %08x instead of "
1047 "%08x", pnum, magic, UBI_VID_HDR_MAGIC);
1048 ubi_dump_vid_hdr(vid_hdr);
1049 }
1050 dbg_bld("bad magic number at PEB %d: %08x instead of "
1051 "%08x", pnum, magic, UBI_VID_HDR_MAGIC);
1052 return UBI_IO_BAD_HDR;
1053 }
1054
1055 crc = crc32(UBI_CRC32_INIT, vid_hdr, UBI_VID_HDR_SIZE_CRC);
1056 hdr_crc = be32_to_cpu(vid_hdr->hdr_crc);
1057
1058 if (hdr_crc != crc) {
1059 if (verbose) {
1060 ubi_warn("bad CRC at PEB %d, calculated %#08x, "
1061 "read %#08x", pnum, crc, hdr_crc);
1062 ubi_dump_vid_hdr(vid_hdr);
1063 }
1064 dbg_bld("bad CRC at PEB %d, calculated %#08x, "
1065 "read %#08x", pnum, crc, hdr_crc);
1066 if (!read_err)
1067 return UBI_IO_BAD_HDR;
1068 else
1069 return UBI_IO_BAD_HDR_EBADMSG;
1070 }
1071
1072 err = validate_vid_hdr(ubi, vid_hdr);
1073 if (err) {
1074 ubi_err("validation failed for PEB %d", pnum);
1075 return -EINVAL;
1076 }
1077
1078 return read_err ? UBI_IO_BITFLIPS : 0;
1079}
1080
1081/**
1082 * ubi_io_write_vid_hdr - write a volume identifier header.
1083 * @ubi: UBI device description object
1084 * @pnum: the physical eraseblock number to write to
1085 * @vid_hdr: the volume identifier header to write
1086 *
1087 * This function writes the volume identifier header described by @vid_hdr to
1088 * physical eraseblock @pnum. This function automatically fills the
1089 * @vid_hdr->magic and the @vid_hdr->version fields, as well as calculates
1090 * header CRC checksum and stores it at vid_hdr->hdr_crc.
1091 *
1092 * This function returns zero in case of success and a negative error code in
1093 * case of failure. If %-EIO is returned, the physical eraseblock probably went
1094 * bad.
1095 */
1096int ubi_io_write_vid_hdr(struct ubi_device *ubi, int pnum,
1097 struct ubi_vid_hdr *vid_hdr)
1098{
1099 int err;
1100 uint32_t crc;
1101 void *p;
1102
1103 dbg_io("write VID header to PEB %d", pnum);
1104 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
1105
1106 err = self_check_peb_ec_hdr(ubi, pnum);
1107 if (err)
1108 return err;
1109
1110 vid_hdr->magic = cpu_to_be32(UBI_VID_HDR_MAGIC);
1111 vid_hdr->version = UBI_VERSION;
1112 crc = crc32(UBI_CRC32_INIT, vid_hdr, UBI_VID_HDR_SIZE_CRC);
1113 vid_hdr->hdr_crc = cpu_to_be32(crc);
1114
1115 err = self_check_vid_hdr(ubi, pnum, vid_hdr);
1116 if (err)
1117 return err;
1118
1119 p = (char *)vid_hdr - ubi->vid_hdr_shift;
1120 err = ubi_io_write(ubi, p, pnum, ubi->vid_hdr_aloffset,
1121 ubi->vid_hdr_alsize);
1122 return err;
1123}
1124
1125/**
1126 * self_check_not_bad - ensure that a physical eraseblock is not bad.
1127 * @ubi: UBI device description object
1128 * @pnum: physical eraseblock number to check
1129 *
1130 * This function returns zero if the physical eraseblock is good, %-EINVAL if
1131 * it is bad and a negative error code if an error occurred.
1132 */
1133static int self_check_not_bad(const struct ubi_device *ubi, int pnum)
1134{
1135 int err;
1136
1137 if (!ubi->dbg->chk_io)
1138 return 0;
1139
1140 err = ubi_io_is_bad(ubi, pnum);
1141 if (!err)
1142 return err;
1143
1144 ubi_err("self-check failed for PEB %d", pnum);
1145 dump_stack();
1146 return err > 0 ? -EINVAL : err;
1147}
1148
1149/**
1150 * self_check_ec_hdr - check if an erase counter header is all right.
1151 * @ubi: UBI device description object
1152 * @pnum: physical eraseblock number the erase counter header belongs to
1153 * @ec_hdr: the erase counter header to check
1154 *
1155 * This function returns zero if the erase counter header contains valid
1156 * values, and %-EINVAL if not.
1157 */
1158static int self_check_ec_hdr(const struct ubi_device *ubi, int pnum,
1159 const struct ubi_ec_hdr *ec_hdr)
1160{
1161 int err;
1162 uint32_t magic;
1163
1164 if (!ubi->dbg->chk_io)
1165 return 0;
1166
1167 magic = be32_to_cpu(ec_hdr->magic);
1168 if (magic != UBI_EC_HDR_MAGIC) {
1169 ubi_err("bad magic %#08x, must be %#08x",
1170 magic, UBI_EC_HDR_MAGIC);
1171 goto fail;
1172 }
1173
1174 err = validate_ec_hdr(ubi, ec_hdr);
1175 if (err) {
1176 ubi_err("self-check failed for PEB %d", pnum);
1177 goto fail;
1178 }
1179
1180 return 0;
1181
1182fail:
1183 ubi_dump_ec_hdr(ec_hdr);
1184 dump_stack();
1185 return -EINVAL;
1186}
1187
1188/**
1189 * self_check_peb_ec_hdr - check erase counter header.
1190 * @ubi: UBI device description object
1191 * @pnum: the physical eraseblock number to check
1192 *
1193 * This function returns zero if the erase counter header is all right and and
1194 * a negative error code if not or if an error occurred.
1195 */
1196static int self_check_peb_ec_hdr(const struct ubi_device *ubi, int pnum)
1197{
1198 int err;
1199 uint32_t crc, hdr_crc;
1200 struct ubi_ec_hdr *ec_hdr;
1201
1202 if (!ubi->dbg->chk_io)
1203 return 0;
1204
1205 ec_hdr = kzalloc(ubi->ec_hdr_alsize, GFP_NOFS);
1206 if (!ec_hdr)
1207 return -ENOMEM;
1208
1209 err = ubi_io_read(ubi, ec_hdr, pnum, 0, UBI_EC_HDR_SIZE);
1210 if (err && err != UBI_IO_BITFLIPS && !mtd_is_eccerr(err))
1211 goto exit;
1212
1213 crc = crc32(UBI_CRC32_INIT, ec_hdr, UBI_EC_HDR_SIZE_CRC);
1214 hdr_crc = be32_to_cpu(ec_hdr->hdr_crc);
1215 if (hdr_crc != crc) {
1216 ubi_err("bad CRC, calculated %#08x, read %#08x", crc, hdr_crc);
1217 ubi_err("self-check failed for PEB %d", pnum);
1218 ubi_dump_ec_hdr(ec_hdr);
1219 dump_stack();
1220 err = -EINVAL;
1221 goto exit;
1222 }
1223
1224 err = self_check_ec_hdr(ubi, pnum, ec_hdr);
1225
1226exit:
1227 kfree(ec_hdr);
1228 return err;
1229}
1230
1231/**
1232 * self_check_vid_hdr - check that a volume identifier header is all right.
1233 * @ubi: UBI device description object
1234 * @pnum: physical eraseblock number the volume identifier header belongs to
1235 * @vid_hdr: the volume identifier header to check
1236 *
1237 * This function returns zero if the volume identifier header is all right, and
1238 * %-EINVAL if not.
1239 */
1240static int self_check_vid_hdr(const struct ubi_device *ubi, int pnum,
1241 const struct ubi_vid_hdr *vid_hdr)
1242{
1243 int err;
1244 uint32_t magic;
1245
1246 if (!ubi->dbg->chk_io)
1247 return 0;
1248
1249 magic = be32_to_cpu(vid_hdr->magic);
1250 if (magic != UBI_VID_HDR_MAGIC) {
1251 ubi_err("bad VID header magic %#08x at PEB %d, must be %#08x",
1252 magic, pnum, UBI_VID_HDR_MAGIC);
1253 goto fail;
1254 }
1255
1256 err = validate_vid_hdr(ubi, vid_hdr);
1257 if (err) {
1258 ubi_err("self-check failed for PEB %d", pnum);
1259 goto fail;
1260 }
1261
1262 return err;
1263
1264fail:
1265 ubi_err("self-check failed for PEB %d", pnum);
1266 ubi_dump_vid_hdr(vid_hdr);
1267 dump_stack();
1268 return -EINVAL;
1269
1270}
1271
1272/**
1273 * self_check_peb_vid_hdr - check volume identifier header.
1274 * @ubi: UBI device description object
1275 * @pnum: the physical eraseblock number to check
1276 *
1277 * This function returns zero if the volume identifier header is all right,
1278 * and a negative error code if not or if an error occurred.
1279 */
1280static int self_check_peb_vid_hdr(const struct ubi_device *ubi, int pnum)
1281{
1282 int err;
1283 uint32_t crc, hdr_crc;
1284 struct ubi_vid_hdr *vid_hdr;
1285 void *p;
1286
1287 if (!ubi->dbg->chk_io)
1288 return 0;
1289
1290 vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS);
1291 if (!vid_hdr)
1292 return -ENOMEM;
1293
1294 p = (char *)vid_hdr - ubi->vid_hdr_shift;
1295 err = ubi_io_read(ubi, p, pnum, ubi->vid_hdr_aloffset,
1296 ubi->vid_hdr_alsize);
1297 if (err && err != UBI_IO_BITFLIPS && !mtd_is_eccerr(err))
1298 goto exit;
1299
1300 crc = crc32(UBI_CRC32_INIT, vid_hdr, UBI_EC_HDR_SIZE_CRC);
1301 hdr_crc = be32_to_cpu(vid_hdr->hdr_crc);
1302 if (hdr_crc != crc) {
1303 ubi_err("bad VID header CRC at PEB %d, calculated %#08x, "
1304 "read %#08x", pnum, crc, hdr_crc);
1305 ubi_err("self-check failed for PEB %d", pnum);
1306 ubi_dump_vid_hdr(vid_hdr);
1307 dump_stack();
1308 err = -EINVAL;
1309 goto exit;
1310 }
1311
1312 err = self_check_vid_hdr(ubi, pnum, vid_hdr);
1313
1314exit:
1315 ubi_free_vid_hdr(ubi, vid_hdr);
1316 return err;
1317}
1318
1319/**
1320 * self_check_write - make sure write succeeded.
1321 * @ubi: UBI device description object
1322 * @buf: buffer with data which were written
1323 * @pnum: physical eraseblock number the data were written to
1324 * @offset: offset within the physical eraseblock the data were written to
1325 * @len: how many bytes were written
1326 *
1327 * This functions reads data which were recently written and compares it with
1328 * the original data buffer - the data have to match. Returns zero if the data
1329 * match and a negative error code if not or in case of failure.
1330 */
1331static int self_check_write(struct ubi_device *ubi, const void *buf, int pnum,
1332 int offset, int len)
1333{
1334 int err, i;
1335 size_t read;
1336 void *buf1;
1337 loff_t addr = (loff_t)pnum * ubi->peb_size + offset;
1338
1339 if (!ubi->dbg->chk_io)
1340 return 0;
1341
1342 buf1 = __vmalloc(len, GFP_NOFS, PAGE_KERNEL);
1343 if (!buf1) {
1344 ubi_err("cannot allocate memory to check writes");
1345 return 0;
1346 }
1347
1348 err = mtd_read(ubi->mtd, addr, len, &read, buf1);
1349 if (err && !mtd_is_bitflip(err))
1350 goto out_free;
1351
1352 for (i = 0; i < len; i++) {
1353 uint8_t c = ((uint8_t *)buf)[i];
1354 uint8_t c1 = ((uint8_t *)buf1)[i];
1355 int dump_len;
1356
1357 if (c == c1)
1358 continue;
1359
1360 ubi_err("self-check failed for PEB %d:%d, len %d",
1361 pnum, offset, len);
1362 ubi_msg("data differ at position %d", i);
1363 dump_len = max_t(int, 128, len - i);
1364 ubi_msg("hex dump of the original buffer from %d to %d",
1365 i, i + dump_len);
1366 print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1,
1367 buf + i, dump_len, 1);
1368 ubi_msg("hex dump of the read buffer from %d to %d",
1369 i, i + dump_len);
1370 print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1,
1371 buf1 + i, dump_len, 1);
1372 dump_stack();
1373 err = -EINVAL;
1374 goto out_free;
1375 }
1376
1377 vfree(buf1);
1378 return 0;
1379
1380out_free:
1381 vfree(buf1);
1382 return err;
1383}
1384
1385/**
1386 * ubi_self_check_all_ff - check that a region of flash is empty.
1387 * @ubi: UBI device description object
1388 * @pnum: the physical eraseblock number to check
1389 * @offset: the starting offset within the physical eraseblock to check
1390 * @len: the length of the region to check
1391 *
1392 * This function returns zero if only 0xFF bytes are present at offset
1393 * @offset of the physical eraseblock @pnum, and a negative error code if not
1394 * or if an error occurred.
1395 */
1396int ubi_self_check_all_ff(struct ubi_device *ubi, int pnum, int offset, int len)
1397{
1398 size_t read;
1399 int err;
1400 void *buf;
1401 loff_t addr = (loff_t)pnum * ubi->peb_size + offset;
1402
1403 if (!ubi->dbg->chk_io)
1404 return 0;
1405
1406 buf = __vmalloc(len, GFP_NOFS, PAGE_KERNEL);
1407 if (!buf) {
1408 ubi_err("cannot allocate memory to check for 0xFFs");
1409 return 0;
1410 }
1411
1412 err = mtd_read(ubi->mtd, addr, len, &read, buf);
1413 if (err && !mtd_is_bitflip(err)) {
1414 ubi_err("error %d while reading %d bytes from PEB %d:%d, "
1415 "read %zd bytes", err, len, pnum, offset, read);
1416 goto error;
1417 }
1418
1419 err = ubi_check_pattern(buf, 0xFF, len);
1420 if (err == 0) {
1421 ubi_err("flash region at PEB %d:%d, length %d does not "
1422 "contain all 0xFF bytes", pnum, offset, len);
1423 goto fail;
1424 }
1425
1426 vfree(buf);
1427 return 0;
1428
1429fail:
1430 ubi_err("self-check failed for PEB %d", pnum);
1431 ubi_msg("hex dump of the %d-%d region", offset, offset + len);
1432 print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1, buf, len, 1);
1433 err = -EINVAL;
1434error:
1435 dump_stack();
1436 vfree(buf);
1437 return err;
1438}