drivers/mtd/ubi/io.c

   1 /*
   2  * Copyright (c) International Business Machines Corp., 2006
   3  * Copyright (c) Nokia Corporation, 2006, 2007
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
  13  * the GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  18  *
  19  * Author: Artem Bityutskiy (Битюцкий Артём)
  20  */
  21
  22 /*
  23  * UBI input/output sub-system.
  24  *
  25  * This sub-system provides a uniform way to work with all kinds of the
  26  * underlying MTD devices. It also implements handy functions for reading and
  27  * writing UBI headers.
  28  *
  29  * We are trying to have a paranoid mindset and not to trust to what we read
  30  * from the flash media in order to be more secure and robust. So this
  31  * sub-system validates every single header it reads from the flash media.
  32  *
  33  * Some words about how the eraseblock headers are stored.
  34  *
  35  * The erase counter header is always stored at offset zero. By default, the
  36  * VID header is stored after the EC header at the closest aligned offset
  37  * (i.e. aligned to the minimum I/O unit size). Data starts next to the VID
  38  * header at the closest aligned offset. But this default layout may be
  39  * changed. For example, for different reasons (e.g., optimization) UBI may be
  40  * asked to put the VID header at further offset, and even at an unaligned
  41  * offset. Of course, if the offset of the VID header is unaligned, UBI adds
  42  * proper padding in front of it. Data offset may also be changed but it has to
  43  * be aligned.
  44  *
  45  * About minimal I/O units. In general, UBI assumes flash device model where
  46  * there is only one minimal I/O unit size. E.g., in case of NOR flash it is 1,
  47  * in case of NAND flash it is a NAND page, etc. This is reported by MTD in the
  48  * @ubi->mtd->writesize field. But as an exception, UBI admits of using another
  49  * (smaller) minimal I/O unit size for EC and VID headers to make it possible
  50  * to do different optimizations.
  51  *
  52  * This is extremely useful in case of NAND flashes which admit of several
  53  * write operations to one NAND page. In this case UBI can fit EC and VID
  54  * headers at one NAND page. Thus, UBI may use "sub-page" size as the minimal
  55  * I/O unit for the headers (the @ubi->hdrs_min_io_size field). But it still
  56  * reports NAND page size (@ubi->min_io_size) as a minimal I/O unit for the UBI
  57  * users.
  58  *
  59  * Example: some Samsung NANDs with 2KiB pages allow 4x 512-byte writes, so
  60  * although the minimal I/O unit is 2K, UBI uses 512 bytes for EC and VID
  61  * headers.
  62  *
  63  * Q: why not just to treat sub-page as a minimal I/O unit of this flash
  64  * device, e.g., make @ubi->min_io_size = 512 in the example above?
  65  *
  66  * A: because when writing a sub-page, MTD still writes a full 2K page but the
  67  * bytes which are 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
  95 static int paranoid_check_not_bad(const struct ubi_device *ubi, int pnum);
  96 static int paranoid_check_peb_ec_hdr(const struct ubi_device *ubi, int pnum);
  97 static int paranoid_check_ec_hdr(const struct ubi_device *ubi, int pnum,
  98                                  const struct ubi_ec_hdr *ec_hdr);
  99 static int paranoid_check_peb_vid_hdr(const struct ubi_device *ubi, int pnum);
 100 static 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  */
 132 int 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;
 172 retry:
 173         err = mtd_read(ubi->mtd, addr, len, &read, buf);
 174         if (err) {
 175                 const char *errstr = mtd_is_eccerr(err) ? " (ECC error)" : "";
 176
 177                 if (mtd_is_bitflip(err)) {
 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 && mtd_is_eccerr(err)) {
 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  */
 241 int 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 = 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  */
 326 static 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  */
 340 static 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
 354 retry:
 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 = 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 */
 408 static 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  */
 419 static 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
 470 out:
 471         mutex_unlock(&ubi->buf_mutex);
 472         if (err == UBI_IO_BITFLIPS || mtd_is_eccerr(err)) {
 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  */
 505 static 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 = mtd_write(ubi->mtd, addr, 4, &written, (void *)&data);
 529         if (!err) {
 530                 addr += ubi->vid_hdr_aloffset;
 531                 err = mtd_write(ubi->mtd, addr, 4, &written, (void *)&data);
 532                 if (!err)
 533                         return 0;
 534         }
 535
 536         /*
 537          * We failed to write to the media. This was observed with Spansion
 538          * S29GL512N NOR flash. Most probably the previously eraseblock erasure
 539          * was interrupted at a very inappropriate moment, so it became
 540          * unwritable. In this case we probably anyway have garbage in this
 541          * PEB.
 542          */
 543         err1 = ubi_io_read_vid_hdr(ubi, pnum, &vid_hdr, 0);
 544         if (err1 == UBI_IO_BAD_HDR_EBADMSG || err1 == UBI_IO_BAD_HDR ||
 545             err1 == UBI_IO_FF) {
 546                 struct ubi_ec_hdr ec_hdr;
 547
 548                 err1 = ubi_io_read_ec_hdr(ubi, pnum, &ec_hdr, 0);
 549                 if (err1 == UBI_IO_BAD_HDR_EBADMSG || err1 == UBI_IO_BAD_HDR ||
 550                     err1 == UBI_IO_FF)
 551                         /*
 552                          * Both VID and EC headers are corrupted, so we can
 553                          * safely erase this PEB and not afraid that it will be
 554                          * treated as a valid PEB in case of an unclean reboot.
 555                          */
 556                         return 0;
 557         }
 558
 559         /*
 560          * The PEB contains a valid VID header, but we cannot invalidate it.
 561          * Supposedly the flash media or the driver is screwed up, so return an
 562          * error.
 563          */
 564         ubi_err("cannot invalidate PEB %d, write returned %d read returned %d",
 565                 pnum, err, err1);
 566         ubi_dbg_dump_flash(ubi, pnum, 0, ubi->peb_size);
 567         return -EIO;
 568 }
 569
 570 /**
 571  * ubi_io_sync_erase - synchronously erase a physical eraseblock.
 572  * @ubi: UBI device description object
 573  * @pnum: physical eraseblock number to erase
 574  * @torture: if this physical eraseblock has to be tortured
 575  *
 576  * This function synchronously erases physical eraseblock @pnum. If @torture
 577  * flag is not zero, the physical eraseblock is checked by means of writing
 578  * different patterns to it and reading them back. If the torturing is enabled,
 579  * the physical eraseblock is erased more than once.
 580  *
 581  * This function returns the number of erasures made in case of success, %-EIO
 582  * if the erasure failed or the torturing test failed, and other negative error
 583  * codes in case of other errors. Note, %-EIO means that the physical
 584  * eraseblock is bad.
 585  */
 586 int ubi_io_sync_erase(struct ubi_device *ubi, int pnum, int torture)
 587 {
 588         int err, ret = 0;
 589
 590         ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
 591
 592         err = paranoid_check_not_bad(ubi, pnum);
 593         if (err != 0)
 594                 return err;
 595
 596         if (ubi->ro_mode) {
 597                 ubi_err("read-only mode");
 598                 return -EROFS;
 599         }
 600
 601         if (ubi->nor_flash) {
 602                 err = nor_erase_prepare(ubi, pnum);
 603                 if (err)
 604                         return err;
 605         }
 606
 607         if (torture) {
 608                 ret = torture_peb(ubi, pnum);
 609                 if (ret < 0)
 610                         return ret;
 611         }
 612
 613         err = do_sync_erase(ubi, pnum);
 614         if (err)
 615                 return err;
 616
 617         return ret + 1;
 618 }
 619
 620 /**
 621  * ubi_io_is_bad - check if a physical eraseblock is bad.
 622  * @ubi: UBI device description object
 623  * @pnum: the physical eraseblock number to check
 624  *
 625  * This function returns a positive number if the physical eraseblock is bad,
 626  * zero if not, and a negative error code if an error occurred.
 627  */
 628 int ubi_io_is_bad(const struct ubi_device *ubi, int pnum)
 629 {
 630         struct mtd_info *mtd = ubi->mtd;
 631
 632         ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
 633
 634         if (ubi->bad_allowed) {
 635                 int ret;
 636
 637                 ret = mtd->block_isbad(mtd, (loff_t)pnum * ubi->peb_size);
 638                 if (ret < 0)
 639                         ubi_err("error %d while checking if PEB %d is bad",
 640                                 ret, pnum);
 641                 else if (ret)
 642                         dbg_io("PEB %d is bad", pnum);
 643                 return ret;
 644         }
 645
 646         return 0;
 647 }
 648
 649 /**
 650  * ubi_io_mark_bad - mark a physical eraseblock as bad.
 651  * @ubi: UBI device description object
 652  * @pnum: the physical eraseblock number to mark
 653  *
 654  * This function returns zero in case of success and a negative error code in
 655  * case of failure.
 656  */
 657 int ubi_io_mark_bad(const struct ubi_device *ubi, int pnum)
 658 {
 659         int err;
 660         struct mtd_info *mtd = ubi->mtd;
 661
 662         ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
 663
 664         if (ubi->ro_mode) {
 665                 ubi_err("read-only mode");
 666                 return -EROFS;
 667         }
 668
 669         if (!ubi->bad_allowed)
 670                 return 0;
 671
 672         err = mtd->block_markbad(mtd, (loff_t)pnum * ubi->peb_size);
 673         if (err)
 674                 ubi_err("cannot mark PEB %d bad, error %d", pnum, err);
 675         return err;
 676 }
 677
 678 /**
 679  * validate_ec_hdr - validate an erase counter header.
 680  * @ubi: UBI device description object
 681  * @ec_hdr: the erase counter header to check
 682  *
 683  * This function returns zero if the erase counter header is OK, and %1 if
 684  * not.
 685  */
 686 static int validate_ec_hdr(const struct ubi_device *ubi,
 687                            const struct ubi_ec_hdr *ec_hdr)
 688 {
 689         long long ec;
 690         int vid_hdr_offset, leb_start;
 691
 692         ec = be64_to_cpu(ec_hdr->ec);
 693         vid_hdr_offset = be32_to_cpu(ec_hdr->vid_hdr_offset);
 694         leb_start = be32_to_cpu(ec_hdr->data_offset);
 695
 696         if (ec_hdr->version != UBI_VERSION) {
 697                 ubi_err("node with incompatible UBI version found: "
 698                         "this UBI version is %d, image version is %d",
 699                         UBI_VERSION, (int)ec_hdr->version);
 700                 goto bad;
 701         }
 702
 703         if (vid_hdr_offset != ubi->vid_hdr_offset) {
 704                 ubi_err("bad VID header offset %d, expected %d",
 705                         vid_hdr_offset, ubi->vid_hdr_offset);
 706                 goto bad;
 707         }
 708
 709         if (leb_start != ubi->leb_start) {
 710                 ubi_err("bad data offset %d, expected %d",
 711                         leb_start, ubi->leb_start);
 712                 goto bad;
 713         }
 714
 715         if (ec < 0 || ec > UBI_MAX_ERASECOUNTER) {
 716                 ubi_err("bad erase counter %lld", ec);
 717                 goto bad;
 718         }
 719
 720         return 0;
 721
 722 bad:
 723         ubi_err("bad EC header");
 724         ubi_dbg_dump_ec_hdr(ec_hdr);
 725         ubi_dbg_dump_stack();
 726         return 1;
 727 }
 728
 729 /**
 730  * ubi_io_read_ec_hdr - read and check an erase counter header.
 731  * @ubi: UBI device description object
 732  * @pnum: physical eraseblock to read from
 733  * @ec_hdr: a &struct ubi_ec_hdr object where to store the read erase counter
 734  * header
 735  * @verbose: be verbose if the header is corrupted or was not found
 736  *
 737  * This function reads erase counter header from physical eraseblock @pnum and
 738  * stores it in @ec_hdr. This function also checks CRC checksum of the read
 739  * erase counter header. The following codes may be returned:
 740  *
 741  * o %0 if the CRC checksum is correct and the header was successfully read;
 742  * o %UBI_IO_BITFLIPS if the CRC is correct, but bit-flips were detected
 743  *   and corrected by the flash driver; this is harmless but may indicate that
 744  *   this eraseblock may become bad soon (but may be not);
 745  * o %UBI_IO_BAD_HDR if the erase counter header is corrupted (a CRC error);
 746  * o %UBI_IO_BAD_HDR_EBADMSG is the same as %UBI_IO_BAD_HDR, but there also was
 747  *   a data integrity error (uncorrectable ECC error in case of NAND);
 748  * o %UBI_IO_FF if only 0xFF bytes were read (the PEB is supposedly empty)
 749  * o a negative error code in case of failure.
 750  */
 751 int ubi_io_read_ec_hdr(struct ubi_device *ubi, int pnum,
 752                        struct ubi_ec_hdr *ec_hdr, int verbose)
 753 {
 754         int err, read_err;
 755         uint32_t crc, magic, hdr_crc;
 756
 757         dbg_io("read EC header from PEB %d", pnum);
 758         ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
 759
 760         read_err = ubi_io_read(ubi, ec_hdr, pnum, 0, UBI_EC_HDR_SIZE);
 761         if (read_err) {
 762                 if (read_err != UBI_IO_BITFLIPS && !mtd_is_eccerr(read_err))
 763                         return read_err;
 764
 765                 /*
 766                  * We read all the data, but either a correctable bit-flip
 767                  * occurred, or MTD reported a data integrity error
 768                  * (uncorrectable ECC error in case of NAND). The former is
 769                  * harmless, the later may mean that the read data is
 770                  * corrupted. But we have a CRC check-sum and we will detect
 771                  * this. If the EC header is still OK, we just report this as
 772                  * there was a bit-flip, to force scrubbing.
 773                  */
 774         }
 775
 776         magic = be32_to_cpu(ec_hdr->magic);
 777         if (magic != UBI_EC_HDR_MAGIC) {
 778                 if (mtd_is_eccerr(read_err))
 779                         return UBI_IO_BAD_HDR_EBADMSG;
 780
 781                 /*
 782                  * The magic field is wrong. Let's check if we have read all
 783                  * 0xFF. If yes, this physical eraseblock is assumed to be
 784                  * empty.
 785                  */
 786                 if (ubi_check_pattern(ec_hdr, 0xFF, UBI_EC_HDR_SIZE)) {
 787                         /* The physical eraseblock is supposedly empty */
 788                         if (verbose)
 789                                 ubi_warn("no EC header found at PEB %d, "
 790                                          "only 0xFF bytes", pnum);
 791                         dbg_bld("no EC header found at PEB %d, "
 792                                 "only 0xFF bytes", pnum);
 793                         if (!read_err)
 794                                 return UBI_IO_FF;
 795                         else
 796                                 return UBI_IO_FF_BITFLIPS;
 797                 }
 798
 799                 /*
 800                  * This is not a valid erase counter header, and these are not
 801                  * 0xFF bytes. Report that the header is corrupted.
 802                  */
 803                 if (verbose) {
 804                         ubi_warn("bad magic number at PEB %d: %08x instead of "
 805                                  "%08x", pnum, magic, UBI_EC_HDR_MAGIC);
 806                         ubi_dbg_dump_ec_hdr(ec_hdr);
 807                 }
 808                 dbg_bld("bad magic number at PEB %d: %08x instead of "
 809                         "%08x", pnum, magic, UBI_EC_HDR_MAGIC);
 810                 return UBI_IO_BAD_HDR;
 811         }
 812
 813         crc = crc32(UBI_CRC32_INIT, ec_hdr, UBI_EC_HDR_SIZE_CRC);
 814         hdr_crc = be32_to_cpu(ec_hdr->hdr_crc);
 815
 816         if (hdr_crc != crc) {
 817                 if (verbose) {
 818                         ubi_warn("bad EC header CRC at PEB %d, calculated "
 819                                  "%#08x, read %#08x", pnum, crc, hdr_crc);
 820                         ubi_dbg_dump_ec_hdr(ec_hdr);
 821                 }
 822                 dbg_bld("bad EC header CRC at PEB %d, calculated "
 823                         "%#08x, read %#08x", pnum, crc, hdr_crc);
 824
 825                 if (!read_err)
 826                         return UBI_IO_BAD_HDR;
 827                 else
 828                         return UBI_IO_BAD_HDR_EBADMSG;
 829         }
 830
 831         /* And of course validate what has just been read from the media */
 832         err = validate_ec_hdr(ubi, ec_hdr);
 833         if (err) {
 834                 ubi_err("validation failed for PEB %d", pnum);
 835                 return -EINVAL;
 836         }
 837
 838         /*
 839          * If there was %-EBADMSG, but the header CRC is still OK, report about
 840          * a bit-flip to force scrubbing on this PEB.
 841          */
 842         return read_err ? UBI_IO_BITFLIPS : 0;
 843 }
 844
 845 /**
 846  * ubi_io_write_ec_hdr - write an erase counter header.
 847  * @ubi: UBI device description object
 848  * @pnum: physical eraseblock to write to
 849  * @ec_hdr: the erase counter header to write
 850  *
 851  * This function writes erase counter header described by @ec_hdr to physical
 852  * eraseblock @pnum. It also fills most fields of @ec_hdr before writing, so
 853  * the caller do not have to fill them. Callers must only fill the @ec_hdr->ec
 854  * field.
 855  *
 856  * This function returns zero in case of success and a negative error code in
 857  * case of failure. If %-EIO is returned, the physical eraseblock most probably
 858  * went bad.
 859  */
 860 int ubi_io_write_ec_hdr(struct ubi_device *ubi, int pnum,
 861                         struct ubi_ec_hdr *ec_hdr)
 862 {
 863         int err;
 864         uint32_t crc;
 865
 866         dbg_io("write EC header to PEB %d", pnum);
 867         ubi_assert(pnum >= 0 &&  pnum < ubi->peb_count);
 868
 869         ec_hdr->magic = cpu_to_be32(UBI_EC_HDR_MAGIC);
 870         ec_hdr->version = UBI_VERSION;
 871         ec_hdr->vid_hdr_offset = cpu_to_be32(ubi->vid_hdr_offset);
 872         ec_hdr->data_offset = cpu_to_be32(ubi->leb_start);
 873         ec_hdr->image_seq = cpu_to_be32(ubi->image_seq);
 874         crc = crc32(UBI_CRC32_INIT, ec_hdr, UBI_EC_HDR_SIZE_CRC);
 875         ec_hdr->hdr_crc = cpu_to_be32(crc);
 876
 877         err = paranoid_check_ec_hdr(ubi, pnum, ec_hdr);
 878         if (err)
 879                 return err;
 880
 881         err = ubi_io_write(ubi, ec_hdr, pnum, 0, ubi->ec_hdr_alsize);
 882         return err;
 883 }
 884
 885 /**
 886  * validate_vid_hdr - validate a volume identifier header.
 887  * @ubi: UBI device description object
 888  * @vid_hdr: the volume identifier header to check
 889  *
 890  * This function checks that data stored in the volume identifier header
 891  * @vid_hdr. Returns zero if the VID header is OK and %1 if not.
 892  */
 893 static int validate_vid_hdr(const struct ubi_device *ubi,
 894                             const struct ubi_vid_hdr *vid_hdr)
 895 {
 896         int vol_type = vid_hdr->vol_type;
 897         int copy_flag = vid_hdr->copy_flag;
 898         int vol_id = be32_to_cpu(vid_hdr->vol_id);
 899         int lnum = be32_to_cpu(vid_hdr->lnum);
 900         int compat = vid_hdr->compat;
 901         int data_size = be32_to_cpu(vid_hdr->data_size);
 902         int used_ebs = be32_to_cpu(vid_hdr->used_ebs);
 903         int data_pad = be32_to_cpu(vid_hdr->data_pad);
 904         int data_crc = be32_to_cpu(vid_hdr->data_crc);
 905         int usable_leb_size = ubi->leb_size - data_pad;
 906
 907         if (copy_flag != 0 && copy_flag != 1) {
 908                 dbg_err("bad copy_flag");
 909                 goto bad;
 910         }
 911
 912         if (vol_id < 0 || lnum < 0 || data_size < 0 || used_ebs < 0 ||
 913             data_pad < 0) {
 914                 dbg_err("negative values");
 915                 goto bad;
 916         }
 917
 918         if (vol_id >= UBI_MAX_VOLUMES && vol_id < UBI_INTERNAL_VOL_START) {
 919                 dbg_err("bad vol_id");
 920                 goto bad;
 921         }
 922
 923         if (vol_id < UBI_INTERNAL_VOL_START && compat != 0) {
 924                 dbg_err("bad compat");
 925                 goto bad;
 926         }
 927
 928         if (vol_id >= UBI_INTERNAL_VOL_START && compat != UBI_COMPAT_DELETE &&
 929             compat != UBI_COMPAT_RO && compat != UBI_COMPAT_PRESERVE &&
 930             compat != UBI_COMPAT_REJECT) {
 931                 dbg_err("bad compat");
 932                 goto bad;
 933         }
 934
 935         if (vol_type != UBI_VID_DYNAMIC && vol_type != UBI_VID_STATIC) {
 936                 dbg_err("bad vol_type");
 937                 goto bad;
 938         }
 939
 940         if (data_pad >= ubi->leb_size / 2) {
 941                 dbg_err("bad data_pad");
 942                 goto bad;
 943         }
 944
 945         if (vol_type == UBI_VID_STATIC) {
 946                 /*
 947                  * Although from high-level point of view static volumes may
 948                  * contain zero bytes of data, but no VID headers can contain
 949                  * zero at these fields, because they empty volumes do not have
 950                  * mapped logical eraseblocks.
 951                  */
 952                 if (used_ebs == 0) {
 953                         dbg_err("zero used_ebs");
 954                         goto bad;
 955                 }
 956                 if (data_size == 0) {
 957                         dbg_err("zero data_size");
 958                         goto bad;
 959                 }
 960                 if (lnum < used_ebs - 1) {
 961                         if (data_size != usable_leb_size) {
 962                                 dbg_err("bad data_size");
 963                                 goto bad;
 964                         }
 965                 } else if (lnum == used_ebs - 1) {
 966                         if (data_size == 0) {
 967                                 dbg_err("bad data_size at last LEB");
 968                                 goto bad;
 969                         }
 970                 } else {
 971                         dbg_err("too high lnum");
 972                         goto bad;
 973                 }
 974         } else {
 975                 if (copy_flag == 0) {
 976                         if (data_crc != 0) {
 977                                 dbg_err("non-zero data CRC");
 978                                 goto bad;
 979                         }
 980                         if (data_size != 0) {
 981                                 dbg_err("non-zero data_size");
 982                                 goto bad;
 983                         }
 984                 } else {
 985                         if (data_size == 0) {
 986                                 dbg_err("zero data_size of copy");
 987                                 goto bad;
 988                         }
 989                 }
 990                 if (used_ebs != 0) {
 991                         dbg_err("bad used_ebs");
 992                         goto bad;
 993                 }
 994         }
 995
 996         return 0;
 997
 998 bad:
 999         ubi_err("bad VID header");
1000         ubi_dbg_dump_vid_hdr(vid_hdr);
1001         ubi_dbg_dump_stack();
1002         return 1;
1003 }
1004
1005 /**
1006  * ubi_io_read_vid_hdr - read and check a volume identifier header.
1007  * @ubi: UBI device description object
1008  * @pnum: physical eraseblock number to read from
1009  * @vid_hdr: &struct ubi_vid_hdr object where to store the read volume
1010  * identifier header
1011  * @verbose: be verbose if the header is corrupted or wasn't found
1012  *
1013  * This function reads the volume identifier header from physical eraseblock
1014  * @pnum and stores it in @vid_hdr. It also checks CRC checksum of the read
1015  * volume identifier header. The error codes are the same as in
1016  * 'ubi_io_read_ec_hdr()'.
1017  *
1018  * Note, the implementation of this function is also very similar to
1019  * 'ubi_io_read_ec_hdr()', so refer commentaries in 'ubi_io_read_ec_hdr()'.
1020  */
1021 int ubi_io_read_vid_hdr(struct ubi_device *ubi, int pnum,
1022                         struct ubi_vid_hdr *vid_hdr, int verbose)
1023 {
1024         int err, read_err;
1025         uint32_t crc, magic, hdr_crc;
1026         void *p;
1027
1028         dbg_io("read VID header from PEB %d", pnum);
1029         ubi_assert(pnum >= 0 &&  pnum < ubi->peb_count);
1030
1031         p = (char *)vid_hdr - ubi->vid_hdr_shift;
1032         read_err = ubi_io_read(ubi, p, pnum, ubi->vid_hdr_aloffset,
1033                           ubi->vid_hdr_alsize);
1034         if (read_err && read_err != UBI_IO_BITFLIPS && !mtd_is_eccerr(read_err))
1035                 return read_err;
1036
1037         magic = be32_to_cpu(vid_hdr->magic);
1038         if (magic != UBI_VID_HDR_MAGIC) {
1039                 if (mtd_is_eccerr(read_err))
1040                         return UBI_IO_BAD_HDR_EBADMSG;
1041
1042                 if (ubi_check_pattern(vid_hdr, 0xFF, UBI_VID_HDR_SIZE)) {
1043                         if (verbose)
1044                                 ubi_warn("no VID header found at PEB %d, "
1045                                          "only 0xFF bytes", pnum);
1046                         dbg_bld("no VID header found at PEB %d, "
1047                                 "only 0xFF bytes", pnum);
1048                         if (!read_err)
1049                                 return UBI_IO_FF;
1050                         else
1051                                 return UBI_IO_FF_BITFLIPS;
1052                 }
1053
1054                 if (verbose) {
1055                         ubi_warn("bad magic number at PEB %d: %08x instead of "
1056                                  "%08x", pnum, magic, UBI_VID_HDR_MAGIC);
1057                         ubi_dbg_dump_vid_hdr(vid_hdr);
1058                 }
1059                 dbg_bld("bad magic number at PEB %d: %08x instead of "
1060                         "%08x", pnum, magic, UBI_VID_HDR_MAGIC);
1061                 return UBI_IO_BAD_HDR;
1062         }
1063
1064         crc = crc32(UBI_CRC32_INIT, vid_hdr, UBI_VID_HDR_SIZE_CRC);
1065         hdr_crc = be32_to_cpu(vid_hdr->hdr_crc);
1066
1067         if (hdr_crc != crc) {
1068                 if (verbose) {
1069                         ubi_warn("bad CRC at PEB %d, calculated %#08x, "
1070                                  "read %#08x", pnum, crc, hdr_crc);
1071                         ubi_dbg_dump_vid_hdr(vid_hdr);
1072                 }
1073                 dbg_bld("bad CRC at PEB %d, calculated %#08x, "
1074                         "read %#08x", pnum, crc, hdr_crc);
1075                 if (!read_err)
1076                         return UBI_IO_BAD_HDR;
1077                 else
1078                         return UBI_IO_BAD_HDR_EBADMSG;
1079         }
1080
1081         err = validate_vid_hdr(ubi, vid_hdr);
1082         if (err) {
1083                 ubi_err("validation failed for PEB %d", pnum);
1084                 return -EINVAL;
1085         }
1086
1087         return read_err ? UBI_IO_BITFLIPS : 0;
1088 }
1089
1090 /**
1091  * ubi_io_write_vid_hdr - write a volume identifier header.
1092  * @ubi: UBI device description object
1093  * @pnum: the physical eraseblock number to write to
1094  * @vid_hdr: the volume identifier header to write
1095  *
1096  * This function writes the volume identifier header described by @vid_hdr to
1097  * physical eraseblock @pnum. This function automatically fills the
1098  * @vid_hdr->magic and the @vid_hdr->version fields, as well as calculates
1099  * header CRC checksum and stores it at vid_hdr->hdr_crc.
1100  *
1101  * This function returns zero in case of success and a negative error code in
1102  * case of failure. If %-EIO is returned, the physical eraseblock probably went
1103  * bad.
1104  */
1105 int ubi_io_write_vid_hdr(struct ubi_device *ubi, int pnum,
1106                          struct ubi_vid_hdr *vid_hdr)
1107 {
1108         int err;
1109         uint32_t crc;
1110         void *p;
1111
1112         dbg_io("write VID header to PEB %d", pnum);
1113         ubi_assert(pnum >= 0 &&  pnum < ubi->peb_count);
1114
1115         err = paranoid_check_peb_ec_hdr(ubi, pnum);
1116         if (err)
1117                 return err;
1118
1119         vid_hdr->magic = cpu_to_be32(UBI_VID_HDR_MAGIC);
1120         vid_hdr->version = UBI_VERSION;
1121         crc = crc32(UBI_CRC32_INIT, vid_hdr, UBI_VID_HDR_SIZE_CRC);
1122         vid_hdr->hdr_crc = cpu_to_be32(crc);
1123
1124         err = paranoid_check_vid_hdr(ubi, pnum, vid_hdr);
1125         if (err)
1126                 return err;
1127
1128         p = (char *)vid_hdr - ubi->vid_hdr_shift;
1129         err = ubi_io_write(ubi, p, pnum, ubi->vid_hdr_aloffset,
1130                            ubi->vid_hdr_alsize);
1131         return err;
1132 }
1133
1134 #ifdef CONFIG_MTD_UBI_DEBUG
1135
1136 /**
1137  * paranoid_check_not_bad - ensure that a physical eraseblock is not bad.
1138  * @ubi: UBI device description object
1139  * @pnum: physical eraseblock number to check
1140  *
1141  * This function returns zero if the physical eraseblock is good, %-EINVAL if
1142  * it is bad and a negative error code if an error occurred.
1143  */
1144 static int paranoid_check_not_bad(const struct ubi_device *ubi, int pnum)
1145 {
1146         int err;
1147
1148         if (!ubi->dbg->chk_io)
1149                 return 0;
1150
1151         err = ubi_io_is_bad(ubi, pnum);
1152         if (!err)
1153                 return err;
1154
1155         ubi_err("paranoid check failed for PEB %d", pnum);
1156         ubi_dbg_dump_stack();
1157         return err > 0 ? -EINVAL : err;
1158 }
1159
1160 /**
1161  * paranoid_check_ec_hdr - check if an erase counter header is all right.
1162  * @ubi: UBI device description object
1163  * @pnum: physical eraseblock number the erase counter header belongs to
1164  * @ec_hdr: the erase counter header to check
1165  *
1166  * This function returns zero if the erase counter header contains valid
1167  * values, and %-EINVAL if not.
1168  */
1169 static int paranoid_check_ec_hdr(const struct ubi_device *ubi, int pnum,
1170                                  const struct ubi_ec_hdr *ec_hdr)
1171 {
1172         int err;
1173         uint32_t magic;
1174
1175         if (!ubi->dbg->chk_io)
1176                 return 0;
1177
1178         magic = be32_to_cpu(ec_hdr->magic);
1179         if (magic != UBI_EC_HDR_MAGIC) {
1180                 ubi_err("bad magic %#08x, must be %#08x",
1181                         magic, UBI_EC_HDR_MAGIC);
1182                 goto fail;
1183         }
1184
1185         err = validate_ec_hdr(ubi, ec_hdr);
1186         if (err) {
1187                 ubi_err("paranoid check failed for PEB %d", pnum);
1188                 goto fail;
1189         }
1190
1191         return 0;
1192
1193 fail:
1194         ubi_dbg_dump_ec_hdr(ec_hdr);
1195         ubi_dbg_dump_stack();
1196         return -EINVAL;
1197 }
1198
1199 /**
1200  * paranoid_check_peb_ec_hdr - check erase counter header.
1201  * @ubi: UBI device description object
1202  * @pnum: the physical eraseblock number to check
1203  *
1204  * This function returns zero if the erase counter header is all right and and
1205  * a negative error code if not or if an error occurred.
1206  */
1207 static int paranoid_check_peb_ec_hdr(const struct ubi_device *ubi, int pnum)
1208 {
1209         int err;
1210         uint32_t crc, hdr_crc;
1211         struct ubi_ec_hdr *ec_hdr;
1212
1213         if (!ubi->dbg->chk_io)
1214                 return 0;
1215
1216         ec_hdr = kzalloc(ubi->ec_hdr_alsize, GFP_NOFS);
1217         if (!ec_hdr)
1218                 return -ENOMEM;
1219
1220         err = ubi_io_read(ubi, ec_hdr, pnum, 0, UBI_EC_HDR_SIZE);
1221         if (err && err != UBI_IO_BITFLIPS && !mtd_is_eccerr(err))
1222                 goto exit;
1223
1224         crc = crc32(UBI_CRC32_INIT, ec_hdr, UBI_EC_HDR_SIZE_CRC);
1225         hdr_crc = be32_to_cpu(ec_hdr->hdr_crc);
1226         if (hdr_crc != crc) {
1227                 ubi_err("bad CRC, calculated %#08x, read %#08x", crc, hdr_crc);
1228                 ubi_err("paranoid check failed for PEB %d", pnum);
1229                 ubi_dbg_dump_ec_hdr(ec_hdr);
1230                 ubi_dbg_dump_stack();
1231                 err = -EINVAL;
1232                 goto exit;
1233         }
1234
1235         err = paranoid_check_ec_hdr(ubi, pnum, ec_hdr);
1236
1237 exit:
1238         kfree(ec_hdr);
1239         return err;
1240 }
1241
1242 /**
1243  * paranoid_check_vid_hdr - check that a volume identifier header is all right.
1244  * @ubi: UBI device description object
1245  * @pnum: physical eraseblock number the volume identifier header belongs to
1246  * @vid_hdr: the volume identifier header to check
1247  *
1248  * This function returns zero if the volume identifier header is all right, and
1249  * %-EINVAL if not.
1250  */
1251 static int paranoid_check_vid_hdr(const struct ubi_device *ubi, int pnum,
1252                                   const struct ubi_vid_hdr *vid_hdr)
1253 {
1254         int err;
1255         uint32_t magic;
1256
1257         if (!ubi->dbg->chk_io)
1258                 return 0;
1259
1260         magic = be32_to_cpu(vid_hdr->magic);
1261         if (magic != UBI_VID_HDR_MAGIC) {
1262                 ubi_err("bad VID header magic %#08x at PEB %d, must be %#08x",
1263                         magic, pnum, UBI_VID_HDR_MAGIC);
1264                 goto fail;
1265         }
1266
1267         err = validate_vid_hdr(ubi, vid_hdr);
1268         if (err) {
1269                 ubi_err("paranoid check failed for PEB %d", pnum);
1270                 goto fail;
1271         }
1272
1273         return err;
1274
1275 fail:
1276         ubi_err("paranoid check failed for PEB %d", pnum);
1277         ubi_dbg_dump_vid_hdr(vid_hdr);
1278         ubi_dbg_dump_stack();
1279         return -EINVAL;
1280
1281 }
1282
1283 /**
1284  * paranoid_check_peb_vid_hdr - check volume identifier header.
1285  * @ubi: UBI device description object
1286  * @pnum: the physical eraseblock number to check
1287  *
1288  * This function returns zero if the volume identifier header is all right,
1289  * and a negative error code if not or if an error occurred.
1290  */
1291 static int paranoid_check_peb_vid_hdr(const struct ubi_device *ubi, int pnum)
1292 {
1293         int err;
1294         uint32_t crc, hdr_crc;
1295         struct ubi_vid_hdr *vid_hdr;
1296         void *p;
1297
1298         if (!ubi->dbg->chk_io)
1299                 return 0;
1300
1301         vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS);
1302         if (!vid_hdr)
1303                 return -ENOMEM;
1304
1305         p = (char *)vid_hdr - ubi->vid_hdr_shift;
1306         err = ubi_io_read(ubi, p, pnum, ubi->vid_hdr_aloffset,
1307                           ubi->vid_hdr_alsize);
1308         if (err && err != UBI_IO_BITFLIPS && !mtd_is_eccerr(err))
1309                 goto exit;
1310
1311         crc = crc32(UBI_CRC32_INIT, vid_hdr, UBI_EC_HDR_SIZE_CRC);
1312         hdr_crc = be32_to_cpu(vid_hdr->hdr_crc);
1313         if (hdr_crc != crc) {
1314                 ubi_err("bad VID header CRC at PEB %d, calculated %#08x, "
1315                         "read %#08x", pnum, crc, hdr_crc);
1316                 ubi_err("paranoid check failed for PEB %d", pnum);
1317                 ubi_dbg_dump_vid_hdr(vid_hdr);
1318                 ubi_dbg_dump_stack();
1319                 err = -EINVAL;
1320                 goto exit;
1321         }
1322
1323         err = paranoid_check_vid_hdr(ubi, pnum, vid_hdr);
1324
1325 exit:
1326         ubi_free_vid_hdr(ubi, vid_hdr);
1327         return err;
1328 }
1329
1330 /**
1331  * ubi_dbg_check_write - make sure write succeeded.
1332  * @ubi: UBI device description object
1333  * @buf: buffer with data which were written
1334  * @pnum: physical eraseblock number the data were written to
1335  * @offset: offset within the physical eraseblock the data were written to
1336  * @len: how many bytes were written
1337  *
1338  * This functions reads data which were recently written and compares it with
1339  * the original data buffer - the data have to match. Returns zero if the data
1340  * match and a negative error code if not or in case of failure.
1341  */
1342 int ubi_dbg_check_write(struct ubi_device *ubi, const void *buf, int pnum,
1343                         int offset, int len)
1344 {
1345         int err, i;
1346         size_t read;
1347         void *buf1;
1348         loff_t addr = (loff_t)pnum * ubi->peb_size + offset;
1349
1350         if (!ubi->dbg->chk_io)
1351                 return 0;
1352
1353         buf1 = __vmalloc(len, GFP_NOFS, PAGE_KERNEL);
1354         if (!buf1) {
1355                 ubi_err("cannot allocate memory to check writes");
1356                 return 0;
1357         }
1358
1359         err = mtd_read(ubi->mtd, addr, len, &read, buf1);
1360         if (err && !mtd_is_bitflip(err))
1361                 goto out_free;
1362
1363         for (i = 0; i < len; i++) {
1364                 uint8_t c = ((uint8_t *)buf)[i];
1365                 uint8_t c1 = ((uint8_t *)buf1)[i];
1366                 int dump_len;
1367
1368                 if (c == c1)
1369                         continue;
1370
1371                 ubi_err("paranoid check failed for PEB %d:%d, len %d",
1372                         pnum, offset, len);
1373                 ubi_msg("data differ at position %d", i);
1374                 dump_len = max_t(int, 128, len - i);
1375                 ubi_msg("hex dump of the original buffer from %d to %d",
1376                         i, i + dump_len);
1377                 print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1,
1378                                buf + i, dump_len, 1);
1379                 ubi_msg("hex dump of the read buffer from %d to %d",
1380                         i, i + dump_len);
1381                 print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1,
1382                                buf1 + i, dump_len, 1);
1383                 ubi_dbg_dump_stack();
1384                 err = -EINVAL;
1385                 goto out_free;
1386         }
1387
1388         vfree(buf1);
1389         return 0;
1390
1391 out_free:
1392         vfree(buf1);
1393         return err;
1394 }
1395
1396 /**
1397  * ubi_dbg_check_all_ff - check that a region of flash is empty.
1398  * @ubi: UBI device description object
1399  * @pnum: the physical eraseblock number to check
1400  * @offset: the starting offset within the physical eraseblock to check
1401  * @len: the length of the region to check
1402  *
1403  * This function returns zero if only 0xFF bytes are present at offset
1404  * @offset of the physical eraseblock @pnum, and a negative error code if not
1405  * or if an error occurred.
1406  */
1407 int ubi_dbg_check_all_ff(struct ubi_device *ubi, int pnum, int offset, int len)
1408 {
1409         size_t read;
1410         int err;
1411         void *buf;
1412         loff_t addr = (loff_t)pnum * ubi->peb_size + offset;
1413
1414         if (!ubi->dbg->chk_io)
1415                 return 0;
1416
1417         buf = __vmalloc(len, GFP_NOFS, PAGE_KERNEL);
1418         if (!buf) {
1419                 ubi_err("cannot allocate memory to check for 0xFFs");
1420                 return 0;
1421         }
1422
1423         err = mtd_read(ubi->mtd, addr, len, &read, buf);
1424         if (err && !mtd_is_bitflip(err)) {
1425                 ubi_err("error %d while reading %d bytes from PEB %d:%d, "
1426                         "read %zd bytes", err, len, pnum, offset, read);
1427                 goto error;
1428         }
1429
1430         err = ubi_check_pattern(buf, 0xFF, len);
1431         if (err == 0) {
1432                 ubi_err("flash region at PEB %d:%d, length %d does not "
1433                         "contain all 0xFF bytes", pnum, offset, len);
1434                 goto fail;
1435         }
1436
1437         vfree(buf);
1438         return 0;
1439
1440 fail:
1441         ubi_err("paranoid check failed for PEB %d", pnum);
1442         ubi_msg("hex dump of the %d-%d region", offset, offset + len);
1443         print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1, buf, len, 1);
1444         err = -EINVAL;
1445 error:
1446         ubi_dbg_dump_stack();
1447         vfree(buf);
1448         return err;
1449 }
1450
1451 #endif /* CONFIG_MTD_UBI_DEBUG */