drivers/mtd/ubi/io.c

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