1 /* 2 * Copyright (c) Thomas Gleixner <tglx@linutronix.de> 3 * 4 * The parts taken from the kernel implementation are: 5 * 6 * Copyright (c) International Business Machines Corp., 2006 7 * 8 * SPDX-License-Identifier: GPL 2.0+ BSD-3-Clause 9 */ 10 11 #include <common.h> 12 #include <errno.h> 13 #include <ubispl.h> 14 15 #include <linux/crc32.h> 16 17 #include "ubispl.h" 18 19 /** 20 * ubi_calc_fm_size - calculates the fastmap size in bytes for an UBI device. 21 * @ubi: UBI device description object 22 */ 23 static size_t ubi_calc_fm_size(struct ubi_scan_info *ubi) 24 { 25 size_t size; 26 27 size = sizeof(struct ubi_fm_sb) + 28 sizeof(struct ubi_fm_hdr) + 29 sizeof(struct ubi_fm_scan_pool) + 30 sizeof(struct ubi_fm_scan_pool) + 31 (ubi->peb_count * sizeof(struct ubi_fm_ec)) + 32 (sizeof(struct ubi_fm_eba) + 33 (ubi->peb_count * sizeof(__be32))) + 34 sizeof(struct ubi_fm_volhdr) * UBI_MAX_VOLUMES; 35 return roundup(size, ubi->leb_size); 36 } 37 38 static int ubi_io_read(struct ubi_scan_info *ubi, void *buf, int pnum, 39 unsigned long from, unsigned long len) 40 { 41 return ubi->read(pnum + ubi->peb_offset, from, len, buf); 42 } 43 44 static int ubi_io_is_bad(struct ubi_scan_info *ubi, int peb) 45 { 46 return peb >= ubi->peb_count || peb < 0; 47 } 48 49 static int ubi_io_read_vid_hdr(struct ubi_scan_info *ubi, int pnum, 50 struct ubi_vid_hdr *vh, int unused) 51 { 52 u32 magic; 53 int res; 54 55 /* No point in rescanning a corrupt block */ 56 if (test_bit(pnum, ubi->corrupt)) 57 return UBI_IO_BAD_HDR; 58 /* 59 * If the block has been scanned already, no need to rescan 60 */ 61 if (test_and_set_bit(pnum, ubi->scanned)) 62 return 0; 63 64 res = ubi_io_read(ubi, vh, pnum, ubi->vid_offset, sizeof(*vh)); 65 66 /* 67 * Bad block, unrecoverable ECC error, skip the block 68 */ 69 if (res) { 70 ubi_dbg("Skipping bad or unreadable block %d", pnum); 71 vh->magic = 0; 72 generic_set_bit(pnum, ubi->corrupt); 73 return res; 74 } 75 76 /* Magic number available ? */ 77 magic = be32_to_cpu(vh->magic); 78 if (magic != UBI_VID_HDR_MAGIC) { 79 generic_set_bit(pnum, ubi->corrupt); 80 if (magic == 0xffffffff) 81 return UBI_IO_FF; 82 ubi_msg("Bad magic in block 0%d %08x", pnum, magic); 83 return UBI_IO_BAD_HDR; 84 } 85 86 /* Header CRC correct ? */ 87 if (crc32(UBI_CRC32_INIT, vh, UBI_VID_HDR_SIZE_CRC) != 88 be32_to_cpu(vh->hdr_crc)) { 89 ubi_msg("Bad CRC in block 0%d", pnum); 90 generic_set_bit(pnum, ubi->corrupt); 91 return UBI_IO_BAD_HDR; 92 } 93 94 ubi_dbg("RV: pnum: %i sqnum %llu", pnum, be64_to_cpu(vh->sqnum)); 95 96 return 0; 97 } 98 99 static int ubi_rescan_fm_vid_hdr(struct ubi_scan_info *ubi, 100 struct ubi_vid_hdr *vh, 101 u32 fm_pnum, u32 fm_vol_id, u32 fm_lnum) 102 { 103 int res; 104 105 if (ubi_io_is_bad(ubi, fm_pnum)) 106 return -EINVAL; 107 108 res = ubi_io_read_vid_hdr(ubi, fm_pnum, vh, 0); 109 if (!res) { 110 /* Check volume id, volume type and lnum */ 111 if (be32_to_cpu(vh->vol_id) == fm_vol_id && 112 vh->vol_type == UBI_VID_STATIC && 113 be32_to_cpu(vh->lnum) == fm_lnum) 114 return 0; 115 ubi_dbg("RS: PEB %u vol: %u : %u typ %u lnum %u %u", 116 fm_pnum, fm_vol_id, vh->vol_type, 117 be32_to_cpu(vh->vol_id), 118 fm_lnum, be32_to_cpu(vh->lnum)); 119 } 120 return res; 121 } 122 123 /* Insert the logic block into the volume info */ 124 static int ubi_add_peb_to_vol(struct ubi_scan_info *ubi, 125 struct ubi_vid_hdr *vh, u32 vol_id, 126 u32 pnum, u32 lnum) 127 { 128 struct ubi_vol_info *vi = ubi->volinfo + vol_id; 129 u32 *ltp; 130 131 /* 132 * If the volume is larger than expected, yell and give up :( 133 */ 134 if (lnum >= UBI_MAX_VOL_LEBS) { 135 ubi_warn("Vol: %u LEB %d > %d", vol_id, lnum, UBI_MAX_VOL_LEBS); 136 return -EINVAL; 137 } 138 139 ubi_dbg("SC: Add PEB %u to Vol %u as LEB %u fnd %d sc %d", 140 pnum, vol_id, lnum, !!test_bit(lnum, vi->found), 141 !!test_bit(pnum, ubi->scanned)); 142 143 /* Points to the translation entry */ 144 ltp = vi->lebs_to_pebs + lnum; 145 146 /* If the block is already assigned, check sqnum */ 147 if (__test_and_set_bit(lnum, vi->found)) { 148 u32 cur_pnum = *ltp; 149 struct ubi_vid_hdr *cur = ubi->blockinfo + cur_pnum; 150 151 /* 152 * If the current block hase not yet been scanned, we 153 * need to do that. The other block might be stale or 154 * the current block corrupted and the FM not yet 155 * updated. 156 */ 157 if (!test_bit(cur_pnum, ubi->scanned)) { 158 /* 159 * If the scan fails, we use the valid block 160 */ 161 if (ubi_rescan_fm_vid_hdr(ubi, cur, cur_pnum, vol_id, 162 lnum)) { 163 *ltp = pnum; 164 return 0; 165 } 166 } 167 168 /* 169 * Should not happen .... 170 */ 171 if (test_bit(cur_pnum, ubi->corrupt)) { 172 *ltp = pnum; 173 return 0; 174 } 175 176 ubi_dbg("Vol %u LEB %u PEB %u->sqnum %llu NPEB %u->sqnum %llu", 177 vol_id, lnum, cur_pnum, be64_to_cpu(cur->sqnum), pnum, 178 be64_to_cpu(vh->sqnum)); 179 180 /* 181 * Compare sqnum and take the newer one 182 */ 183 if (be64_to_cpu(cur->sqnum) < be64_to_cpu(vh->sqnum)) 184 *ltp = pnum; 185 } else { 186 *ltp = pnum; 187 if (lnum > vi->last_block) 188 vi->last_block = lnum; 189 } 190 191 return 0; 192 } 193 194 static int ubi_scan_vid_hdr(struct ubi_scan_info *ubi, struct ubi_vid_hdr *vh, 195 u32 pnum) 196 { 197 u32 vol_id, lnum; 198 int res; 199 200 if (ubi_io_is_bad(ubi, pnum)) 201 return -EINVAL; 202 203 res = ubi_io_read_vid_hdr(ubi, pnum, vh, 0); 204 if (res) 205 return res; 206 207 /* Get volume id */ 208 vol_id = be32_to_cpu(vh->vol_id); 209 210 /* If this is the fastmap anchor, return right away */ 211 if (vol_id == UBI_FM_SB_VOLUME_ID) 212 return ubi->fm_enabled ? UBI_FASTMAP_ANCHOR : 0; 213 214 /* We only care about static volumes with an id < UBI_SPL_VOL_IDS */ 215 if (vol_id >= UBI_SPL_VOL_IDS || vh->vol_type != UBI_VID_STATIC) 216 return 0; 217 218 /* We are only interested in the volumes to load */ 219 if (!test_bit(vol_id, ubi->toload)) 220 return 0; 221 222 lnum = be32_to_cpu(vh->lnum); 223 return ubi_add_peb_to_vol(ubi, vh, vol_id, pnum, lnum); 224 } 225 226 static int assign_aeb_to_av(struct ubi_scan_info *ubi, u32 pnum, u32 lnum, 227 u32 vol_id, u32 vol_type, u32 used) 228 { 229 struct ubi_vid_hdr *vh; 230 231 if (ubi_io_is_bad(ubi, pnum)) 232 return -EINVAL; 233 234 ubi->fastmap_pebs++; 235 236 if (vol_id >= UBI_SPL_VOL_IDS || vol_type != UBI_STATIC_VOLUME) 237 return 0; 238 239 /* We are only interested in the volumes to load */ 240 if (!test_bit(vol_id, ubi->toload)) 241 return 0; 242 243 vh = ubi->blockinfo + pnum; 244 245 return ubi_scan_vid_hdr(ubi, vh, pnum); 246 } 247 248 static int scan_pool(struct ubi_scan_info *ubi, __be32 *pebs, int pool_size) 249 { 250 struct ubi_vid_hdr *vh; 251 u32 pnum; 252 int i; 253 254 ubi_dbg("Scanning pool size: %d", pool_size); 255 256 for (i = 0; i < pool_size; i++) { 257 pnum = be32_to_cpu(pebs[i]); 258 259 if (ubi_io_is_bad(ubi, pnum)) { 260 ubi_err("FM: Bad PEB in fastmap pool! %u", pnum); 261 return UBI_BAD_FASTMAP; 262 } 263 264 vh = ubi->blockinfo + pnum; 265 /* 266 * We allow the scan to fail here. The loader will notice 267 * and look for a replacement. 268 */ 269 ubi_scan_vid_hdr(ubi, vh, pnum); 270 } 271 return 0; 272 } 273 274 /* 275 * Fastmap code is stolen from Linux kernel and this stub structure is used 276 * to make it happy. 277 */ 278 struct ubi_attach_info { 279 int i; 280 }; 281 282 static int ubi_attach_fastmap(struct ubi_scan_info *ubi, 283 struct ubi_attach_info *ai, 284 struct ubi_fastmap_layout *fm) 285 { 286 struct ubi_fm_hdr *fmhdr; 287 struct ubi_fm_scan_pool *fmpl1, *fmpl2; 288 struct ubi_fm_ec *fmec; 289 struct ubi_fm_volhdr *fmvhdr; 290 struct ubi_fm_eba *fm_eba; 291 int ret, i, j, pool_size, wl_pool_size; 292 size_t fm_pos = 0, fm_size = ubi->fm_size; 293 void *fm_raw = ubi->fm_buf; 294 295 memset(ubi->fm_used, 0, sizeof(ubi->fm_used)); 296 297 fm_pos += sizeof(struct ubi_fm_sb); 298 if (fm_pos >= fm_size) 299 goto fail_bad; 300 301 fmhdr = (struct ubi_fm_hdr *)(fm_raw + fm_pos); 302 fm_pos += sizeof(*fmhdr); 303 if (fm_pos >= fm_size) 304 goto fail_bad; 305 306 if (be32_to_cpu(fmhdr->magic) != UBI_FM_HDR_MAGIC) { 307 ubi_err("bad fastmap header magic: 0x%x, expected: 0x%x", 308 be32_to_cpu(fmhdr->magic), UBI_FM_HDR_MAGIC); 309 goto fail_bad; 310 } 311 312 fmpl1 = (struct ubi_fm_scan_pool *)(fm_raw + fm_pos); 313 fm_pos += sizeof(*fmpl1); 314 if (fm_pos >= fm_size) 315 goto fail_bad; 316 if (be32_to_cpu(fmpl1->magic) != UBI_FM_POOL_MAGIC) { 317 ubi_err("bad fastmap pool magic: 0x%x, expected: 0x%x", 318 be32_to_cpu(fmpl1->magic), UBI_FM_POOL_MAGIC); 319 goto fail_bad; 320 } 321 322 fmpl2 = (struct ubi_fm_scan_pool *)(fm_raw + fm_pos); 323 fm_pos += sizeof(*fmpl2); 324 if (fm_pos >= fm_size) 325 goto fail_bad; 326 if (be32_to_cpu(fmpl2->magic) != UBI_FM_POOL_MAGIC) { 327 ubi_err("bad fastmap pool magic: 0x%x, expected: 0x%x", 328 be32_to_cpu(fmpl2->magic), UBI_FM_POOL_MAGIC); 329 goto fail_bad; 330 } 331 332 pool_size = be16_to_cpu(fmpl1->size); 333 wl_pool_size = be16_to_cpu(fmpl2->size); 334 fm->max_pool_size = be16_to_cpu(fmpl1->max_size); 335 fm->max_wl_pool_size = be16_to_cpu(fmpl2->max_size); 336 337 if (pool_size > UBI_FM_MAX_POOL_SIZE || pool_size < 0) { 338 ubi_err("bad pool size: %i", pool_size); 339 goto fail_bad; 340 } 341 342 if (wl_pool_size > UBI_FM_MAX_POOL_SIZE || wl_pool_size < 0) { 343 ubi_err("bad WL pool size: %i", wl_pool_size); 344 goto fail_bad; 345 } 346 347 if (fm->max_pool_size > UBI_FM_MAX_POOL_SIZE || 348 fm->max_pool_size < 0) { 349 ubi_err("bad maximal pool size: %i", fm->max_pool_size); 350 goto fail_bad; 351 } 352 353 if (fm->max_wl_pool_size > UBI_FM_MAX_POOL_SIZE || 354 fm->max_wl_pool_size < 0) { 355 ubi_err("bad maximal WL pool size: %i", fm->max_wl_pool_size); 356 goto fail_bad; 357 } 358 359 /* read EC values from free list */ 360 for (i = 0; i < be32_to_cpu(fmhdr->free_peb_count); i++) { 361 fmec = (struct ubi_fm_ec *)(fm_raw + fm_pos); 362 fm_pos += sizeof(*fmec); 363 if (fm_pos >= fm_size) 364 goto fail_bad; 365 } 366 367 /* read EC values from used list */ 368 for (i = 0; i < be32_to_cpu(fmhdr->used_peb_count); i++) { 369 fmec = (struct ubi_fm_ec *)(fm_raw + fm_pos); 370 fm_pos += sizeof(*fmec); 371 if (fm_pos >= fm_size) 372 goto fail_bad; 373 374 generic_set_bit(be32_to_cpu(fmec->pnum), ubi->fm_used); 375 } 376 377 /* read EC values from scrub list */ 378 for (i = 0; i < be32_to_cpu(fmhdr->scrub_peb_count); i++) { 379 fmec = (struct ubi_fm_ec *)(fm_raw + fm_pos); 380 fm_pos += sizeof(*fmec); 381 if (fm_pos >= fm_size) 382 goto fail_bad; 383 } 384 385 /* read EC values from erase list */ 386 for (i = 0; i < be32_to_cpu(fmhdr->erase_peb_count); i++) { 387 fmec = (struct ubi_fm_ec *)(fm_raw + fm_pos); 388 fm_pos += sizeof(*fmec); 389 if (fm_pos >= fm_size) 390 goto fail_bad; 391 } 392 393 /* Iterate over all volumes and read their EBA table */ 394 for (i = 0; i < be32_to_cpu(fmhdr->vol_count); i++) { 395 u32 vol_id, vol_type, used, reserved; 396 397 fmvhdr = (struct ubi_fm_volhdr *)(fm_raw + fm_pos); 398 fm_pos += sizeof(*fmvhdr); 399 if (fm_pos >= fm_size) 400 goto fail_bad; 401 402 if (be32_to_cpu(fmvhdr->magic) != UBI_FM_VHDR_MAGIC) { 403 ubi_err("bad fastmap vol header magic: 0x%x, " \ 404 "expected: 0x%x", 405 be32_to_cpu(fmvhdr->magic), UBI_FM_VHDR_MAGIC); 406 goto fail_bad; 407 } 408 409 vol_id = be32_to_cpu(fmvhdr->vol_id); 410 vol_type = fmvhdr->vol_type; 411 used = be32_to_cpu(fmvhdr->used_ebs); 412 413 fm_eba = (struct ubi_fm_eba *)(fm_raw + fm_pos); 414 fm_pos += sizeof(*fm_eba); 415 fm_pos += (sizeof(__be32) * be32_to_cpu(fm_eba->reserved_pebs)); 416 if (fm_pos >= fm_size) 417 goto fail_bad; 418 419 if (be32_to_cpu(fm_eba->magic) != UBI_FM_EBA_MAGIC) { 420 ubi_err("bad fastmap EBA header magic: 0x%x, " \ 421 "expected: 0x%x", 422 be32_to_cpu(fm_eba->magic), UBI_FM_EBA_MAGIC); 423 goto fail_bad; 424 } 425 426 reserved = be32_to_cpu(fm_eba->reserved_pebs); 427 ubi_dbg("FA: vol %u used %u res: %u", vol_id, used, reserved); 428 for (j = 0; j < reserved; j++) { 429 int pnum = be32_to_cpu(fm_eba->pnum[j]); 430 431 if ((int)be32_to_cpu(fm_eba->pnum[j]) < 0) 432 continue; 433 434 if (!__test_and_clear_bit(pnum, ubi->fm_used)) 435 continue; 436 437 /* 438 * We only handle static volumes so used_ebs 439 * needs to be handed in. And we do not assign 440 * the reserved blocks 441 */ 442 if (j >= used) 443 continue; 444 445 ret = assign_aeb_to_av(ubi, pnum, j, vol_id, 446 vol_type, used); 447 if (!ret) 448 continue; 449 450 /* 451 * Nasty: The fastmap claims that the volume 452 * has one block more than it, but that block 453 * is always empty and the other blocks have 454 * the correct number of total LEBs in the 455 * headers. Deal with it. 456 */ 457 if (ret != UBI_IO_FF && j != used - 1) 458 goto fail_bad; 459 ubi_dbg("FA: Vol: %u Ignoring empty LEB %d of %d", 460 vol_id, j, used); 461 } 462 } 463 464 ret = scan_pool(ubi, fmpl1->pebs, pool_size); 465 if (ret) 466 goto fail; 467 468 ret = scan_pool(ubi, fmpl2->pebs, wl_pool_size); 469 if (ret) 470 goto fail; 471 472 #ifdef CHECKME 473 /* 474 * If fastmap is leaking PEBs (must not happen), raise a 475 * fat warning and fall back to scanning mode. 476 * We do this here because in ubi_wl_init() it's too late 477 * and we cannot fall back to scanning. 478 */ 479 if (WARN_ON(count_fastmap_pebs(ai) != ubi->peb_count - 480 ai->bad_peb_count - fm->used_blocks)) 481 goto fail_bad; 482 #endif 483 484 return 0; 485 486 fail_bad: 487 ret = UBI_BAD_FASTMAP; 488 fail: 489 return ret; 490 } 491 492 static int ubi_scan_fastmap(struct ubi_scan_info *ubi, 493 struct ubi_attach_info *ai, 494 int fm_anchor) 495 { 496 struct ubi_fm_sb *fmsb, *fmsb2; 497 struct ubi_vid_hdr *vh; 498 struct ubi_fastmap_layout *fm; 499 int i, used_blocks, pnum, ret = 0; 500 size_t fm_size; 501 __be32 crc, tmp_crc; 502 unsigned long long sqnum = 0; 503 504 fmsb = &ubi->fm_sb; 505 fm = &ubi->fm_layout; 506 507 ret = ubi_io_read(ubi, fmsb, fm_anchor, ubi->leb_start, sizeof(*fmsb)); 508 if (ret && ret != UBI_IO_BITFLIPS) 509 goto free_fm_sb; 510 else if (ret == UBI_IO_BITFLIPS) 511 fm->to_be_tortured[0] = 1; 512 513 if (be32_to_cpu(fmsb->magic) != UBI_FM_SB_MAGIC) { 514 ubi_err("bad super block magic: 0x%x, expected: 0x%x", 515 be32_to_cpu(fmsb->magic), UBI_FM_SB_MAGIC); 516 ret = UBI_BAD_FASTMAP; 517 goto free_fm_sb; 518 } 519 520 if (fmsb->version != UBI_FM_FMT_VERSION) { 521 ubi_err("bad fastmap version: %i, expected: %i", 522 fmsb->version, UBI_FM_FMT_VERSION); 523 ret = UBI_BAD_FASTMAP; 524 goto free_fm_sb; 525 } 526 527 used_blocks = be32_to_cpu(fmsb->used_blocks); 528 if (used_blocks > UBI_FM_MAX_BLOCKS || used_blocks < 1) { 529 ubi_err("number of fastmap blocks is invalid: %i", used_blocks); 530 ret = UBI_BAD_FASTMAP; 531 goto free_fm_sb; 532 } 533 534 fm_size = ubi->leb_size * used_blocks; 535 if (fm_size != ubi->fm_size) { 536 ubi_err("bad fastmap size: %zi, expected: %zi", fm_size, 537 ubi->fm_size); 538 ret = UBI_BAD_FASTMAP; 539 goto free_fm_sb; 540 } 541 542 vh = &ubi->fm_vh; 543 544 for (i = 0; i < used_blocks; i++) { 545 pnum = be32_to_cpu(fmsb->block_loc[i]); 546 547 if (ubi_io_is_bad(ubi, pnum)) { 548 ret = UBI_BAD_FASTMAP; 549 goto free_hdr; 550 } 551 552 #ifdef LATER 553 int image_seq; 554 ret = ubi_io_read_ec_hdr(ubi, pnum, ech, 0); 555 if (ret && ret != UBI_IO_BITFLIPS) { 556 ubi_err("unable to read fastmap block# %i EC (PEB: %i)", 557 i, pnum); 558 if (ret > 0) 559 ret = UBI_BAD_FASTMAP; 560 goto free_hdr; 561 } else if (ret == UBI_IO_BITFLIPS) 562 fm->to_be_tortured[i] = 1; 563 564 image_seq = be32_to_cpu(ech->image_seq); 565 if (!ubi->image_seq) 566 ubi->image_seq = image_seq; 567 /* 568 * Older UBI implementations have image_seq set to zero, so 569 * we shouldn't fail if image_seq == 0. 570 */ 571 if (image_seq && (image_seq != ubi->image_seq)) { 572 ubi_err("wrong image seq:%d instead of %d", 573 be32_to_cpu(ech->image_seq), ubi->image_seq); 574 ret = UBI_BAD_FASTMAP; 575 goto free_hdr; 576 } 577 #endif 578 ret = ubi_io_read_vid_hdr(ubi, pnum, vh, 0); 579 if (ret && ret != UBI_IO_BITFLIPS) { 580 ubi_err("unable to read fastmap block# %i (PEB: %i)", 581 i, pnum); 582 goto free_hdr; 583 } 584 585 /* 586 * Mainline code rescans the anchor header. We've done 587 * that already so we merily copy it over. 588 */ 589 if (pnum == fm_anchor) 590 memcpy(vh, ubi->blockinfo + pnum, sizeof(*fm)); 591 592 if (i == 0) { 593 if (be32_to_cpu(vh->vol_id) != UBI_FM_SB_VOLUME_ID) { 594 ubi_err("bad fastmap anchor vol_id: 0x%x," \ 595 " expected: 0x%x", 596 be32_to_cpu(vh->vol_id), 597 UBI_FM_SB_VOLUME_ID); 598 ret = UBI_BAD_FASTMAP; 599 goto free_hdr; 600 } 601 } else { 602 if (be32_to_cpu(vh->vol_id) != UBI_FM_DATA_VOLUME_ID) { 603 ubi_err("bad fastmap data vol_id: 0x%x," \ 604 " expected: 0x%x", 605 be32_to_cpu(vh->vol_id), 606 UBI_FM_DATA_VOLUME_ID); 607 ret = UBI_BAD_FASTMAP; 608 goto free_hdr; 609 } 610 } 611 612 if (sqnum < be64_to_cpu(vh->sqnum)) 613 sqnum = be64_to_cpu(vh->sqnum); 614 615 ret = ubi_io_read(ubi, ubi->fm_buf + (ubi->leb_size * i), pnum, 616 ubi->leb_start, ubi->leb_size); 617 if (ret && ret != UBI_IO_BITFLIPS) { 618 ubi_err("unable to read fastmap block# %i (PEB: %i, " \ 619 "err: %i)", i, pnum, ret); 620 goto free_hdr; 621 } 622 } 623 624 fmsb2 = (struct ubi_fm_sb *)(ubi->fm_buf); 625 tmp_crc = be32_to_cpu(fmsb2->data_crc); 626 fmsb2->data_crc = 0; 627 crc = crc32(UBI_CRC32_INIT, ubi->fm_buf, fm_size); 628 if (crc != tmp_crc) { 629 ubi_err("fastmap data CRC is invalid"); 630 ubi_err("CRC should be: 0x%x, calc: 0x%x", tmp_crc, crc); 631 ret = UBI_BAD_FASTMAP; 632 goto free_hdr; 633 } 634 635 fmsb2->sqnum = sqnum; 636 637 fm->used_blocks = used_blocks; 638 639 ret = ubi_attach_fastmap(ubi, ai, fm); 640 if (ret) { 641 if (ret > 0) 642 ret = UBI_BAD_FASTMAP; 643 goto free_hdr; 644 } 645 646 ubi->fm = fm; 647 ubi->fm_pool.max_size = ubi->fm->max_pool_size; 648 ubi->fm_wl_pool.max_size = ubi->fm->max_wl_pool_size; 649 ubi_msg("attached by fastmap %uMB %u blocks", 650 ubi->fsize_mb, ubi->peb_count); 651 ubi_dbg("fastmap pool size: %d", ubi->fm_pool.max_size); 652 ubi_dbg("fastmap WL pool size: %d", ubi->fm_wl_pool.max_size); 653 654 out: 655 if (ret) 656 ubi_err("Attach by fastmap failed, doing a full scan!"); 657 return ret; 658 659 free_hdr: 660 free_fm_sb: 661 goto out; 662 } 663 664 /* 665 * Scan the flash and attempt to attach via fastmap 666 */ 667 static void ipl_scan(struct ubi_scan_info *ubi) 668 { 669 unsigned int pnum; 670 int res; 671 672 /* 673 * Scan first for the fastmap super block 674 */ 675 for (pnum = 0; pnum < UBI_FM_MAX_START; pnum++) { 676 res = ubi_scan_vid_hdr(ubi, ubi->blockinfo + pnum, pnum); 677 /* 678 * We ignore errors here as we are meriliy scanning 679 * the headers. 680 */ 681 if (res != UBI_FASTMAP_ANCHOR) 682 continue; 683 684 /* 685 * If fastmap is disabled, continue scanning. This 686 * might happen because the previous attempt failed or 687 * the caller disabled it right away. 688 */ 689 if (!ubi->fm_enabled) 690 continue; 691 692 /* 693 * Try to attach the fastmap, if that fails continue 694 * scanning. 695 */ 696 if (!ubi_scan_fastmap(ubi, NULL, pnum)) 697 return; 698 /* 699 * Fastmap failed. Clear everything we have and start 700 * over. We are paranoid and do not trust anything. 701 */ 702 memset(ubi->volinfo, 0, sizeof(ubi->volinfo)); 703 pnum = 0; 704 break; 705 } 706 707 /* 708 * Continue scanning, ignore errors, we might find what we are 709 * looking for, 710 */ 711 for (; pnum < ubi->peb_count; pnum++) 712 ubi_scan_vid_hdr(ubi, ubi->blockinfo + pnum, pnum); 713 } 714 715 /* 716 * Load a logical block of a volume into memory 717 */ 718 static int ubi_load_block(struct ubi_scan_info *ubi, uint8_t *laddr, 719 struct ubi_vol_info *vi, u32 vol_id, u32 lnum, 720 u32 last) 721 { 722 struct ubi_vid_hdr *vh, *vrepl; 723 u32 pnum, crc, dlen; 724 725 retry: 726 /* 727 * If this is a fastmap run, we try to rescan full, otherwise 728 * we simply give up. 729 */ 730 if (!test_bit(lnum, vi->found)) { 731 ubi_warn("LEB %d of %d is missing", lnum, last); 732 return -EINVAL; 733 } 734 735 pnum = vi->lebs_to_pebs[lnum]; 736 737 ubi_dbg("Load vol %u LEB %u PEB %u", vol_id, lnum, pnum); 738 739 if (ubi_io_is_bad(ubi, pnum)) { 740 ubi_warn("Corrupted mapping block %d PB %d\n", lnum, pnum); 741 return -EINVAL; 742 } 743 744 if (test_bit(pnum, ubi->corrupt)) 745 goto find_other; 746 747 /* 748 * Lets try to read that block 749 */ 750 vh = ubi->blockinfo + pnum; 751 752 if (!test_bit(pnum, ubi->scanned)) { 753 ubi_warn("Vol: %u LEB %u PEB %u not yet scanned", vol_id, 754 lnum, pnum); 755 if (ubi_rescan_fm_vid_hdr(ubi, vh, pnum, vol_id, lnum)) 756 goto find_other; 757 } 758 759 /* 760 * Check, if the total number of blocks is correct 761 */ 762 if (be32_to_cpu(vh->used_ebs) != last) { 763 ubi_dbg("Block count missmatch."); 764 ubi_dbg("vh->used_ebs: %d nrblocks: %d", 765 be32_to_cpu(vh->used_ebs), last); 766 generic_set_bit(pnum, ubi->corrupt); 767 goto find_other; 768 } 769 770 /* 771 * Get the data length of this block. 772 */ 773 dlen = be32_to_cpu(vh->data_size); 774 775 /* 776 * Read the data into RAM. We ignore the return value 777 * here as the only thing which might go wrong are 778 * bitflips. Try nevertheless. 779 */ 780 ubi_io_read(ubi, laddr, pnum, ubi->leb_start, dlen); 781 782 /* Calculate CRC over the data */ 783 crc = crc32(UBI_CRC32_INIT, laddr, dlen); 784 785 if (crc != be32_to_cpu(vh->data_crc)) { 786 ubi_warn("Vol: %u LEB %u PEB %u data CRC failure", vol_id, 787 lnum, pnum); 788 generic_set_bit(pnum, ubi->corrupt); 789 goto find_other; 790 } 791 792 /* We are good. Return the data length we read */ 793 return dlen; 794 795 find_other: 796 ubi_dbg("Find replacement for LEB %u PEB %u", lnum, pnum); 797 generic_clear_bit(lnum, vi->found); 798 vrepl = NULL; 799 800 for (pnum = 0; pnum < ubi->peb_count; pnum++) { 801 struct ubi_vid_hdr *tmp = ubi->blockinfo + pnum; 802 u32 t_vol_id = be32_to_cpu(tmp->vol_id); 803 u32 t_lnum = be32_to_cpu(tmp->lnum); 804 805 if (test_bit(pnum, ubi->corrupt)) 806 continue; 807 808 if (t_vol_id != vol_id || t_lnum != lnum) 809 continue; 810 811 if (!test_bit(pnum, ubi->scanned)) { 812 ubi_warn("Vol: %u LEB %u PEB %u not yet scanned", 813 vol_id, lnum, pnum); 814 if (ubi_rescan_fm_vid_hdr(ubi, tmp, pnum, vol_id, lnum)) 815 continue; 816 } 817 818 /* 819 * We found one. If its the first, assign it otherwise 820 * compare the sqnum 821 */ 822 generic_set_bit(lnum, vi->found); 823 824 if (!vrepl) { 825 vrepl = tmp; 826 continue; 827 } 828 829 if (be64_to_cpu(vrepl->sqnum) < be64_to_cpu(tmp->sqnum)) 830 vrepl = tmp; 831 } 832 833 if (vrepl) { 834 /* Update the vi table */ 835 pnum = vrepl - ubi->blockinfo; 836 vi->lebs_to_pebs[lnum] = pnum; 837 ubi_dbg("Trying PEB %u for LEB %u", pnum, lnum); 838 vh = vrepl; 839 } 840 goto retry; 841 } 842 843 /* 844 * Load a volume into RAM 845 */ 846 static int ipl_load(struct ubi_scan_info *ubi, const u32 vol_id, uint8_t *laddr) 847 { 848 struct ubi_vol_info *vi; 849 u32 lnum, last, len; 850 851 if (vol_id >= UBI_SPL_VOL_IDS) 852 return -EINVAL; 853 854 len = 0; 855 vi = ubi->volinfo + vol_id; 856 last = vi->last_block + 1; 857 858 /* Read the blocks to RAM, check CRC */ 859 for (lnum = 0 ; lnum < last; lnum++) { 860 int res = ubi_load_block(ubi, laddr, vi, vol_id, lnum, last); 861 862 if (res < 0) { 863 ubi_warn("Failed to load volume %u", vol_id); 864 return res; 865 } 866 /* res is the data length of the read block */ 867 laddr += res; 868 len += res; 869 } 870 return len; 871 } 872 873 int ubispl_load_volumes(struct ubispl_info *info, struct ubispl_load *lvols, 874 int nrvols) 875 { 876 struct ubi_scan_info *ubi = info->ubi; 877 int res, i, fastmap = info->fastmap; 878 u32 fsize; 879 880 retry: 881 /* 882 * We do a partial initializiation of @ubi. Cleaning fm_buf is 883 * not necessary. 884 */ 885 memset(ubi, 0, offsetof(struct ubi_scan_info, fm_buf)); 886 887 ubi->read = info->read; 888 889 /* Precalculate the offsets */ 890 ubi->vid_offset = info->vid_offset; 891 ubi->leb_start = info->leb_start; 892 ubi->leb_size = info->peb_size - ubi->leb_start; 893 ubi->peb_count = info->peb_count; 894 ubi->peb_offset = info->peb_offset; 895 896 fsize = info->peb_size * info->peb_count; 897 ubi->fsize_mb = fsize >> 20; 898 899 /* Fastmap init */ 900 ubi->fm_size = ubi_calc_fm_size(ubi); 901 ubi->fm_enabled = fastmap; 902 903 for (i = 0; i < nrvols; i++) { 904 struct ubispl_load *lv = lvols + i; 905 906 generic_set_bit(lv->vol_id, ubi->toload); 907 } 908 909 ipl_scan(ubi); 910 911 for (i = 0; i < nrvols; i++) { 912 struct ubispl_load *lv = lvols + i; 913 914 ubi_msg("Loading VolId #%d", lv->vol_id); 915 res = ipl_load(ubi, lv->vol_id, lv->load_addr); 916 if (res < 0) { 917 if (fastmap) { 918 fastmap = 0; 919 goto retry; 920 } 921 ubi_warn("Failed"); 922 return res; 923 } 924 } 925 return 0; 926 } 927