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