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