drivers/mtd/ubi/io.c

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