1 /* 2 * Copyright (c) International Business Machines Corp., 2006 3 * 4 * This program is free software; you can redistribute it and/or modify 5 * it under the terms of the GNU General Public License as published by 6 * the Free Software Foundation; either version 2 of the License, or 7 * (at your option) any later version. 8 * 9 * This program is distributed in the hope that it will be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See 12 * the GNU General Public License for more details. 13 * 14 * You should have received a copy of the GNU General Public License 15 * along with this program; if not, write to the Free Software 16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 17 * 18 * Author: Artem Bityutskiy (Битюцкий Артём) 19 */ 20 21 /* 22 * UBI attaching sub-system. 23 * 24 * This sub-system is responsible for attaching MTD devices and it also 25 * implements flash media scanning. 26 * 27 * The attaching information is represented by a &struct ubi_attach_info' 28 * object. Information about volumes is represented by &struct ubi_ainf_volume 29 * objects which are kept in volume RB-tree with root at the @volumes field. 30 * The RB-tree is indexed by the volume ID. 31 * 32 * Logical eraseblocks are represented by &struct ubi_ainf_peb objects. These 33 * objects are kept in per-volume RB-trees with the root at the corresponding 34 * &struct ubi_ainf_volume object. To put it differently, we keep an RB-tree of 35 * per-volume objects and each of these objects is the root of RB-tree of 36 * per-LEB objects. 37 * 38 * Corrupted physical eraseblocks are put to the @corr list, free physical 39 * eraseblocks are put to the @free list and the physical eraseblock to be 40 * erased are put to the @erase list. 41 * 42 * About corruptions 43 * ~~~~~~~~~~~~~~~~~ 44 * 45 * UBI protects EC and VID headers with CRC-32 checksums, so it can detect 46 * whether the headers are corrupted or not. Sometimes UBI also protects the 47 * data with CRC-32, e.g., when it executes the atomic LEB change operation, or 48 * when it moves the contents of a PEB for wear-leveling purposes. 49 * 50 * UBI tries to distinguish between 2 types of corruptions. 51 * 52 * 1. Corruptions caused by power cuts. These are expected corruptions and UBI 53 * tries to handle them gracefully, without printing too many warnings and 54 * error messages. The idea is that we do not lose important data in these 55 * cases - we may lose only the data which were being written to the media just 56 * before the power cut happened, and the upper layers (e.g., UBIFS) are 57 * supposed to handle such data losses (e.g., by using the FS journal). 58 * 59 * When UBI detects a corruption (CRC-32 mismatch) in a PEB, and it looks like 60 * the reason is a power cut, UBI puts this PEB to the @erase list, and all 61 * PEBs in the @erase list are scheduled for erasure later. 62 * 63 * 2. Unexpected corruptions which are not caused by power cuts. During 64 * attaching, such PEBs are put to the @corr list and UBI preserves them. 65 * Obviously, this lessens the amount of available PEBs, and if at some point 66 * UBI runs out of free PEBs, it switches to R/O mode. UBI also loudly informs 67 * about such PEBs every time the MTD device is attached. 68 * 69 * However, it is difficult to reliably distinguish between these types of 70 * corruptions and UBI's strategy is as follows (in case of attaching by 71 * scanning). UBI assumes corruption type 2 if the VID header is corrupted and 72 * the data area does not contain all 0xFFs, and there were no bit-flips or 73 * integrity errors (e.g., ECC errors in case of NAND) while reading the data 74 * area. Otherwise UBI assumes corruption type 1. So the decision criteria 75 * are as follows. 76 * o If the data area contains only 0xFFs, there are no data, and it is safe 77 * to just erase this PEB - this is corruption type 1. 78 * o If the data area has bit-flips or data integrity errors (ECC errors on 79 * NAND), it is probably a PEB which was being erased when power cut 80 * happened, so this is corruption type 1. However, this is just a guess, 81 * which might be wrong. 82 * o Otherwise this is corruption type 2. 83 */ 84 85 #include <linux/err.h> 86 #include <linux/slab.h> 87 #include <linux/crc32.h> 88 #include <linux/math64.h> 89 #include <linux/random.h> 90 #include "ubi.h" 91 92 static int self_check_ai(struct ubi_device *ubi, struct ubi_attach_info *ai); 93 94 /* Temporary variables used during scanning */ 95 static struct ubi_ec_hdr *ech; 96 static struct ubi_vid_hdr *vidh; 97 98 /** 99 * add_to_list - add physical eraseblock to a list. 100 * @ai: attaching information 101 * @pnum: physical eraseblock number to add 102 * @vol_id: the last used volume id for the PEB 103 * @lnum: the last used LEB number for the PEB 104 * @ec: erase counter of the physical eraseblock 105 * @to_head: if not zero, add to the head of the list 106 * @list: the list to add to 107 * 108 * This function allocates a 'struct ubi_ainf_peb' object for physical 109 * eraseblock @pnum and adds it to the "free", "erase", or "alien" lists. 110 * It stores the @lnum and @vol_id alongside, which can both be 111 * %UBI_UNKNOWN if they are not available, not readable, or not assigned. 112 * If @to_head is not zero, PEB will be added to the head of the list, which 113 * basically means it will be processed first later. E.g., we add corrupted 114 * PEBs (corrupted due to power cuts) to the head of the erase list to make 115 * sure we erase them first and get rid of corruptions ASAP. This function 116 * returns zero in case of success and a negative error code in case of 117 * failure. 118 */ 119 static int add_to_list(struct ubi_attach_info *ai, int pnum, int vol_id, 120 int lnum, int ec, int to_head, struct list_head *list) 121 { 122 struct ubi_ainf_peb *aeb; 123 124 if (list == &ai->free) { 125 dbg_bld("add to free: PEB %d, EC %d", pnum, ec); 126 } else if (list == &ai->erase) { 127 dbg_bld("add to erase: PEB %d, EC %d", pnum, ec); 128 } else if (list == &ai->alien) { 129 dbg_bld("add to alien: PEB %d, EC %d", pnum, ec); 130 ai->alien_peb_count += 1; 131 } else 132 BUG(); 133 134 aeb = kmem_cache_alloc(ai->aeb_slab_cache, GFP_KERNEL); 135 if (!aeb) 136 return -ENOMEM; 137 138 aeb->pnum = pnum; 139 aeb->vol_id = vol_id; 140 aeb->lnum = lnum; 141 aeb->ec = ec; 142 if (to_head) 143 list_add(&aeb->u.list, list); 144 else 145 list_add_tail(&aeb->u.list, list); 146 return 0; 147 } 148 149 /** 150 * add_corrupted - add a corrupted physical eraseblock. 151 * @ai: attaching information 152 * @pnum: physical eraseblock number to add 153 * @ec: erase counter of the physical eraseblock 154 * 155 * This function allocates a 'struct ubi_ainf_peb' object for a corrupted 156 * physical eraseblock @pnum and adds it to the 'corr' list. The corruption 157 * was presumably not caused by a power cut. Returns zero in case of success 158 * and a negative error code in case of failure. 159 */ 160 static int add_corrupted(struct ubi_attach_info *ai, int pnum, int ec) 161 { 162 struct ubi_ainf_peb *aeb; 163 164 dbg_bld("add to corrupted: PEB %d, EC %d", pnum, ec); 165 166 aeb = kmem_cache_alloc(ai->aeb_slab_cache, GFP_KERNEL); 167 if (!aeb) 168 return -ENOMEM; 169 170 ai->corr_peb_count += 1; 171 aeb->pnum = pnum; 172 aeb->ec = ec; 173 list_add(&aeb->u.list, &ai->corr); 174 return 0; 175 } 176 177 /** 178 * validate_vid_hdr - check volume identifier header. 179 * @vid_hdr: the volume identifier header to check 180 * @av: information about the volume this logical eraseblock belongs to 181 * @pnum: physical eraseblock number the VID header came from 182 * 183 * This function checks that data stored in @vid_hdr is consistent. Returns 184 * non-zero if an inconsistency was found and zero if not. 185 * 186 * Note, UBI does sanity check of everything it reads from the flash media. 187 * Most of the checks are done in the I/O sub-system. Here we check that the 188 * information in the VID header is consistent to the information in other VID 189 * headers of the same volume. 190 */ 191 static int validate_vid_hdr(const struct ubi_vid_hdr *vid_hdr, 192 const struct ubi_ainf_volume *av, int pnum) 193 { 194 int vol_type = vid_hdr->vol_type; 195 int vol_id = be32_to_cpu(vid_hdr->vol_id); 196 int used_ebs = be32_to_cpu(vid_hdr->used_ebs); 197 int data_pad = be32_to_cpu(vid_hdr->data_pad); 198 199 if (av->leb_count != 0) { 200 int av_vol_type; 201 202 /* 203 * This is not the first logical eraseblock belonging to this 204 * volume. Ensure that the data in its VID header is consistent 205 * to the data in previous logical eraseblock headers. 206 */ 207 208 if (vol_id != av->vol_id) { 209 ubi_err("inconsistent vol_id"); 210 goto bad; 211 } 212 213 if (av->vol_type == UBI_STATIC_VOLUME) 214 av_vol_type = UBI_VID_STATIC; 215 else 216 av_vol_type = UBI_VID_DYNAMIC; 217 218 if (vol_type != av_vol_type) { 219 ubi_err("inconsistent vol_type"); 220 goto bad; 221 } 222 223 if (used_ebs != av->used_ebs) { 224 ubi_err("inconsistent used_ebs"); 225 goto bad; 226 } 227 228 if (data_pad != av->data_pad) { 229 ubi_err("inconsistent data_pad"); 230 goto bad; 231 } 232 } 233 234 return 0; 235 236 bad: 237 ubi_err("inconsistent VID header at PEB %d", pnum); 238 ubi_dump_vid_hdr(vid_hdr); 239 ubi_dump_av(av); 240 return -EINVAL; 241 } 242 243 /** 244 * add_volume - add volume to the attaching information. 245 * @ai: attaching information 246 * @vol_id: ID of the volume to add 247 * @pnum: physical eraseblock number 248 * @vid_hdr: volume identifier header 249 * 250 * If the volume corresponding to the @vid_hdr logical eraseblock is already 251 * present in the attaching information, this function does nothing. Otherwise 252 * it adds corresponding volume to the attaching information. Returns a pointer 253 * to the allocated "av" object in case of success and a negative error code in 254 * case of failure. 255 */ 256 static struct ubi_ainf_volume *add_volume(struct ubi_attach_info *ai, 257 int vol_id, int pnum, 258 const struct ubi_vid_hdr *vid_hdr) 259 { 260 struct ubi_ainf_volume *av; 261 struct rb_node **p = &ai->volumes.rb_node, *parent = NULL; 262 263 ubi_assert(vol_id == be32_to_cpu(vid_hdr->vol_id)); 264 265 /* Walk the volume RB-tree to look if this volume is already present */ 266 while (*p) { 267 parent = *p; 268 av = rb_entry(parent, struct ubi_ainf_volume, rb); 269 270 if (vol_id == av->vol_id) 271 return av; 272 273 if (vol_id > av->vol_id) 274 p = &(*p)->rb_left; 275 else 276 p = &(*p)->rb_right; 277 } 278 279 /* The volume is absent - add it */ 280 av = kmalloc(sizeof(struct ubi_ainf_volume), GFP_KERNEL); 281 if (!av) 282 return ERR_PTR(-ENOMEM); 283 284 av->highest_lnum = av->leb_count = 0; 285 av->vol_id = vol_id; 286 av->root = RB_ROOT; 287 av->used_ebs = be32_to_cpu(vid_hdr->used_ebs); 288 av->data_pad = be32_to_cpu(vid_hdr->data_pad); 289 av->compat = vid_hdr->compat; 290 av->vol_type = vid_hdr->vol_type == UBI_VID_DYNAMIC ? UBI_DYNAMIC_VOLUME 291 : UBI_STATIC_VOLUME; 292 if (vol_id > ai->highest_vol_id) 293 ai->highest_vol_id = vol_id; 294 295 rb_link_node(&av->rb, parent, p); 296 rb_insert_color(&av->rb, &ai->volumes); 297 ai->vols_found += 1; 298 dbg_bld("added volume %d", vol_id); 299 return av; 300 } 301 302 /** 303 * ubi_compare_lebs - find out which logical eraseblock is newer. 304 * @ubi: UBI device description object 305 * @aeb: first logical eraseblock to compare 306 * @pnum: physical eraseblock number of the second logical eraseblock to 307 * compare 308 * @vid_hdr: volume identifier header of the second logical eraseblock 309 * 310 * This function compares 2 copies of a LEB and informs which one is newer. In 311 * case of success this function returns a positive value, in case of failure, a 312 * negative error code is returned. The success return codes use the following 313 * bits: 314 * o bit 0 is cleared: the first PEB (described by @aeb) is newer than the 315 * second PEB (described by @pnum and @vid_hdr); 316 * o bit 0 is set: the second PEB is newer; 317 * o bit 1 is cleared: no bit-flips were detected in the newer LEB; 318 * o bit 1 is set: bit-flips were detected in the newer LEB; 319 * o bit 2 is cleared: the older LEB is not corrupted; 320 * o bit 2 is set: the older LEB is corrupted. 321 */ 322 int ubi_compare_lebs(struct ubi_device *ubi, const struct ubi_ainf_peb *aeb, 323 int pnum, const struct ubi_vid_hdr *vid_hdr) 324 { 325 int len, err, second_is_newer, bitflips = 0, corrupted = 0; 326 uint32_t data_crc, crc; 327 struct ubi_vid_hdr *vh = NULL; 328 unsigned long long sqnum2 = be64_to_cpu(vid_hdr->sqnum); 329 330 if (sqnum2 == aeb->sqnum) { 331 /* 332 * This must be a really ancient UBI image which has been 333 * created before sequence numbers support has been added. At 334 * that times we used 32-bit LEB versions stored in logical 335 * eraseblocks. That was before UBI got into mainline. We do not 336 * support these images anymore. Well, those images still work, 337 * but only if no unclean reboots happened. 338 */ 339 ubi_err("unsupported on-flash UBI format"); 340 return -EINVAL; 341 } 342 343 /* Obviously the LEB with lower sequence counter is older */ 344 second_is_newer = (sqnum2 > aeb->sqnum); 345 346 /* 347 * Now we know which copy is newer. If the copy flag of the PEB with 348 * newer version is not set, then we just return, otherwise we have to 349 * check data CRC. For the second PEB we already have the VID header, 350 * for the first one - we'll need to re-read it from flash. 351 * 352 * Note: this may be optimized so that we wouldn't read twice. 353 */ 354 355 if (second_is_newer) { 356 if (!vid_hdr->copy_flag) { 357 /* It is not a copy, so it is newer */ 358 dbg_bld("second PEB %d is newer, copy_flag is unset", 359 pnum); 360 return 1; 361 } 362 } else { 363 if (!aeb->copy_flag) { 364 /* It is not a copy, so it is newer */ 365 dbg_bld("first PEB %d is newer, copy_flag is unset", 366 pnum); 367 return bitflips << 1; 368 } 369 370 vh = ubi_zalloc_vid_hdr(ubi, GFP_KERNEL); 371 if (!vh) 372 return -ENOMEM; 373 374 pnum = aeb->pnum; 375 err = ubi_io_read_vid_hdr(ubi, pnum, vh, 0); 376 if (err) { 377 if (err == UBI_IO_BITFLIPS) 378 bitflips = 1; 379 else { 380 ubi_err("VID of PEB %d header is bad, but it was OK earlier, err %d", 381 pnum, err); 382 if (err > 0) 383 err = -EIO; 384 385 goto out_free_vidh; 386 } 387 } 388 389 vid_hdr = vh; 390 } 391 392 /* Read the data of the copy and check the CRC */ 393 394 len = be32_to_cpu(vid_hdr->data_size); 395 396 mutex_lock(&ubi->buf_mutex); 397 err = ubi_io_read_data(ubi, ubi->peb_buf, pnum, 0, len); 398 if (err && err != UBI_IO_BITFLIPS && !mtd_is_eccerr(err)) 399 goto out_unlock; 400 401 data_crc = be32_to_cpu(vid_hdr->data_crc); 402 crc = crc32(UBI_CRC32_INIT, ubi->peb_buf, len); 403 if (crc != data_crc) { 404 dbg_bld("PEB %d CRC error: calculated %#08x, must be %#08x", 405 pnum, crc, data_crc); 406 corrupted = 1; 407 bitflips = 0; 408 second_is_newer = !second_is_newer; 409 } else { 410 dbg_bld("PEB %d CRC is OK", pnum); 411 bitflips = !!err; 412 } 413 mutex_unlock(&ubi->buf_mutex); 414 415 ubi_free_vid_hdr(ubi, vh); 416 417 if (second_is_newer) 418 dbg_bld("second PEB %d is newer, copy_flag is set", pnum); 419 else 420 dbg_bld("first PEB %d is newer, copy_flag is set", pnum); 421 422 return second_is_newer | (bitflips << 1) | (corrupted << 2); 423 424 out_unlock: 425 mutex_unlock(&ubi->buf_mutex); 426 out_free_vidh: 427 ubi_free_vid_hdr(ubi, vh); 428 return err; 429 } 430 431 /** 432 * ubi_add_to_av - add used physical eraseblock to the attaching information. 433 * @ubi: UBI device description object 434 * @ai: attaching information 435 * @pnum: the physical eraseblock number 436 * @ec: erase counter 437 * @vid_hdr: the volume identifier header 438 * @bitflips: if bit-flips were detected when this physical eraseblock was read 439 * 440 * This function adds information about a used physical eraseblock to the 441 * 'used' tree of the corresponding volume. The function is rather complex 442 * because it has to handle cases when this is not the first physical 443 * eraseblock belonging to the same logical eraseblock, and the newer one has 444 * to be picked, while the older one has to be dropped. This function returns 445 * zero in case of success and a negative error code in case of failure. 446 */ 447 int ubi_add_to_av(struct ubi_device *ubi, struct ubi_attach_info *ai, int pnum, 448 int ec, const struct ubi_vid_hdr *vid_hdr, int bitflips) 449 { 450 int err, vol_id, lnum; 451 unsigned long long sqnum; 452 struct ubi_ainf_volume *av; 453 struct ubi_ainf_peb *aeb; 454 struct rb_node **p, *parent = NULL; 455 456 vol_id = be32_to_cpu(vid_hdr->vol_id); 457 lnum = be32_to_cpu(vid_hdr->lnum); 458 sqnum = be64_to_cpu(vid_hdr->sqnum); 459 460 dbg_bld("PEB %d, LEB %d:%d, EC %d, sqnum %llu, bitflips %d", 461 pnum, vol_id, lnum, ec, sqnum, bitflips); 462 463 av = add_volume(ai, vol_id, pnum, vid_hdr); 464 if (IS_ERR(av)) 465 return PTR_ERR(av); 466 467 if (ai->max_sqnum < sqnum) 468 ai->max_sqnum = sqnum; 469 470 /* 471 * Walk the RB-tree of logical eraseblocks of volume @vol_id to look 472 * if this is the first instance of this logical eraseblock or not. 473 */ 474 p = &av->root.rb_node; 475 while (*p) { 476 int cmp_res; 477 478 parent = *p; 479 aeb = rb_entry(parent, struct ubi_ainf_peb, u.rb); 480 if (lnum != aeb->lnum) { 481 if (lnum < aeb->lnum) 482 p = &(*p)->rb_left; 483 else 484 p = &(*p)->rb_right; 485 continue; 486 } 487 488 /* 489 * There is already a physical eraseblock describing the same 490 * logical eraseblock present. 491 */ 492 493 dbg_bld("this LEB already exists: PEB %d, sqnum %llu, EC %d", 494 aeb->pnum, aeb->sqnum, aeb->ec); 495 496 /* 497 * Make sure that the logical eraseblocks have different 498 * sequence numbers. Otherwise the image is bad. 499 * 500 * However, if the sequence number is zero, we assume it must 501 * be an ancient UBI image from the era when UBI did not have 502 * sequence numbers. We still can attach these images, unless 503 * there is a need to distinguish between old and new 504 * eraseblocks, in which case we'll refuse the image in 505 * 'ubi_compare_lebs()'. In other words, we attach old clean 506 * images, but refuse attaching old images with duplicated 507 * logical eraseblocks because there was an unclean reboot. 508 */ 509 if (aeb->sqnum == sqnum && sqnum != 0) { 510 ubi_err("two LEBs with same sequence number %llu", 511 sqnum); 512 ubi_dump_aeb(aeb, 0); 513 ubi_dump_vid_hdr(vid_hdr); 514 return -EINVAL; 515 } 516 517 /* 518 * Now we have to drop the older one and preserve the newer 519 * one. 520 */ 521 cmp_res = ubi_compare_lebs(ubi, aeb, pnum, vid_hdr); 522 if (cmp_res < 0) 523 return cmp_res; 524 525 if (cmp_res & 1) { 526 /* 527 * This logical eraseblock is newer than the one 528 * found earlier. 529 */ 530 err = validate_vid_hdr(vid_hdr, av, pnum); 531 if (err) 532 return err; 533 534 err = add_to_list(ai, aeb->pnum, aeb->vol_id, 535 aeb->lnum, aeb->ec, cmp_res & 4, 536 &ai->erase); 537 if (err) 538 return err; 539 540 aeb->ec = ec; 541 aeb->pnum = pnum; 542 aeb->vol_id = vol_id; 543 aeb->lnum = lnum; 544 aeb->scrub = ((cmp_res & 2) || bitflips); 545 aeb->copy_flag = vid_hdr->copy_flag; 546 aeb->sqnum = sqnum; 547 548 if (av->highest_lnum == lnum) 549 av->last_data_size = 550 be32_to_cpu(vid_hdr->data_size); 551 552 return 0; 553 } else { 554 /* 555 * This logical eraseblock is older than the one found 556 * previously. 557 */ 558 return add_to_list(ai, pnum, vol_id, lnum, ec, 559 cmp_res & 4, &ai->erase); 560 } 561 } 562 563 /* 564 * We've met this logical eraseblock for the first time, add it to the 565 * attaching information. 566 */ 567 568 err = validate_vid_hdr(vid_hdr, av, pnum); 569 if (err) 570 return err; 571 572 aeb = kmem_cache_alloc(ai->aeb_slab_cache, GFP_KERNEL); 573 if (!aeb) 574 return -ENOMEM; 575 576 aeb->ec = ec; 577 aeb->pnum = pnum; 578 aeb->vol_id = vol_id; 579 aeb->lnum = lnum; 580 aeb->scrub = bitflips; 581 aeb->copy_flag = vid_hdr->copy_flag; 582 aeb->sqnum = sqnum; 583 584 if (av->highest_lnum <= lnum) { 585 av->highest_lnum = lnum; 586 av->last_data_size = be32_to_cpu(vid_hdr->data_size); 587 } 588 589 av->leb_count += 1; 590 rb_link_node(&aeb->u.rb, parent, p); 591 rb_insert_color(&aeb->u.rb, &av->root); 592 return 0; 593 } 594 595 /** 596 * ubi_find_av - find volume in the attaching information. 597 * @ai: attaching information 598 * @vol_id: the requested volume ID 599 * 600 * This function returns a pointer to the volume description or %NULL if there 601 * are no data about this volume in the attaching information. 602 */ 603 struct ubi_ainf_volume *ubi_find_av(const struct ubi_attach_info *ai, 604 int vol_id) 605 { 606 struct ubi_ainf_volume *av; 607 struct rb_node *p = ai->volumes.rb_node; 608 609 while (p) { 610 av = rb_entry(p, struct ubi_ainf_volume, rb); 611 612 if (vol_id == av->vol_id) 613 return av; 614 615 if (vol_id > av->vol_id) 616 p = p->rb_left; 617 else 618 p = p->rb_right; 619 } 620 621 return NULL; 622 } 623 624 /** 625 * ubi_remove_av - delete attaching information about a volume. 626 * @ai: attaching information 627 * @av: the volume attaching information to delete 628 */ 629 void ubi_remove_av(struct ubi_attach_info *ai, struct ubi_ainf_volume *av) 630 { 631 struct rb_node *rb; 632 struct ubi_ainf_peb *aeb; 633 634 dbg_bld("remove attaching information about volume %d", av->vol_id); 635 636 while ((rb = rb_first(&av->root))) { 637 aeb = rb_entry(rb, struct ubi_ainf_peb, u.rb); 638 rb_erase(&aeb->u.rb, &av->root); 639 list_add_tail(&aeb->u.list, &ai->erase); 640 } 641 642 rb_erase(&av->rb, &ai->volumes); 643 kfree(av); 644 ai->vols_found -= 1; 645 } 646 647 /** 648 * early_erase_peb - erase a physical eraseblock. 649 * @ubi: UBI device description object 650 * @ai: attaching information 651 * @pnum: physical eraseblock number to erase; 652 * @ec: erase counter value to write (%UBI_UNKNOWN if it is unknown) 653 * 654 * This function erases physical eraseblock 'pnum', and writes the erase 655 * counter header to it. This function should only be used on UBI device 656 * initialization stages, when the EBA sub-system had not been yet initialized. 657 * This function returns zero in case of success and a negative error code in 658 * case of failure. 659 */ 660 static int early_erase_peb(struct ubi_device *ubi, 661 const struct ubi_attach_info *ai, int pnum, int ec) 662 { 663 int err; 664 struct ubi_ec_hdr *ec_hdr; 665 666 if ((long long)ec >= UBI_MAX_ERASECOUNTER) { 667 /* 668 * Erase counter overflow. Upgrade UBI and use 64-bit 669 * erase counters internally. 670 */ 671 ubi_err("erase counter overflow at PEB %d, EC %d", pnum, ec); 672 return -EINVAL; 673 } 674 675 ec_hdr = kzalloc(ubi->ec_hdr_alsize, GFP_KERNEL); 676 if (!ec_hdr) 677 return -ENOMEM; 678 679 ec_hdr->ec = cpu_to_be64(ec); 680 681 err = ubi_io_sync_erase(ubi, pnum, 0); 682 if (err < 0) 683 goto out_free; 684 685 err = ubi_io_write_ec_hdr(ubi, pnum, ec_hdr); 686 687 out_free: 688 kfree(ec_hdr); 689 return err; 690 } 691 692 /** 693 * ubi_early_get_peb - get a free physical eraseblock. 694 * @ubi: UBI device description object 695 * @ai: attaching information 696 * 697 * This function returns a free physical eraseblock. It is supposed to be 698 * called on the UBI initialization stages when the wear-leveling sub-system is 699 * not initialized yet. This function picks a physical eraseblocks from one of 700 * the lists, writes the EC header if it is needed, and removes it from the 701 * list. 702 * 703 * This function returns a pointer to the "aeb" of the found free PEB in case 704 * of success and an error code in case of failure. 705 */ 706 struct ubi_ainf_peb *ubi_early_get_peb(struct ubi_device *ubi, 707 struct ubi_attach_info *ai) 708 { 709 int err = 0; 710 struct ubi_ainf_peb *aeb, *tmp_aeb; 711 712 if (!list_empty(&ai->free)) { 713 aeb = list_entry(ai->free.next, struct ubi_ainf_peb, u.list); 714 list_del(&aeb->u.list); 715 dbg_bld("return free PEB %d, EC %d", aeb->pnum, aeb->ec); 716 return aeb; 717 } 718 719 /* 720 * We try to erase the first physical eraseblock from the erase list 721 * and pick it if we succeed, or try to erase the next one if not. And 722 * so forth. We don't want to take care about bad eraseblocks here - 723 * they'll be handled later. 724 */ 725 list_for_each_entry_safe(aeb, tmp_aeb, &ai->erase, u.list) { 726 if (aeb->ec == UBI_UNKNOWN) 727 aeb->ec = ai->mean_ec; 728 729 err = early_erase_peb(ubi, ai, aeb->pnum, aeb->ec+1); 730 if (err) 731 continue; 732 733 aeb->ec += 1; 734 list_del(&aeb->u.list); 735 dbg_bld("return PEB %d, EC %d", aeb->pnum, aeb->ec); 736 return aeb; 737 } 738 739 ubi_err("no free eraseblocks"); 740 return ERR_PTR(-ENOSPC); 741 } 742 743 /** 744 * check_corruption - check the data area of PEB. 745 * @ubi: UBI device description object 746 * @vid_hdr: the (corrupted) VID header of this PEB 747 * @pnum: the physical eraseblock number to check 748 * 749 * This is a helper function which is used to distinguish between VID header 750 * corruptions caused by power cuts and other reasons. If the PEB contains only 751 * 0xFF bytes in the data area, the VID header is most probably corrupted 752 * because of a power cut (%0 is returned in this case). Otherwise, it was 753 * probably corrupted for some other reasons (%1 is returned in this case). A 754 * negative error code is returned if a read error occurred. 755 * 756 * If the corruption reason was a power cut, UBI can safely erase this PEB. 757 * Otherwise, it should preserve it to avoid possibly destroying important 758 * information. 759 */ 760 static int check_corruption(struct ubi_device *ubi, struct ubi_vid_hdr *vid_hdr, 761 int pnum) 762 { 763 int err; 764 765 mutex_lock(&ubi->buf_mutex); 766 memset(ubi->peb_buf, 0x00, ubi->leb_size); 767 768 err = ubi_io_read(ubi, ubi->peb_buf, pnum, ubi->leb_start, 769 ubi->leb_size); 770 if (err == UBI_IO_BITFLIPS || mtd_is_eccerr(err)) { 771 /* 772 * Bit-flips or integrity errors while reading the data area. 773 * It is difficult to say for sure what type of corruption is 774 * this, but presumably a power cut happened while this PEB was 775 * erased, so it became unstable and corrupted, and should be 776 * erased. 777 */ 778 err = 0; 779 goto out_unlock; 780 } 781 782 if (err) 783 goto out_unlock; 784 785 if (ubi_check_pattern(ubi->peb_buf, 0xFF, ubi->leb_size)) 786 goto out_unlock; 787 788 ubi_err("PEB %d contains corrupted VID header, and the data does not contain all 0xFF", 789 pnum); 790 ubi_err("this may be a non-UBI PEB or a severe VID header corruption which requires manual inspection"); 791 ubi_dump_vid_hdr(vid_hdr); 792 pr_err("hexdump of PEB %d offset %d, length %d", 793 pnum, ubi->leb_start, ubi->leb_size); 794 ubi_dbg_print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1, 795 ubi->peb_buf, ubi->leb_size, 1); 796 err = 1; 797 798 out_unlock: 799 mutex_unlock(&ubi->buf_mutex); 800 return err; 801 } 802 803 /** 804 * scan_peb - scan and process UBI headers of a PEB. 805 * @ubi: UBI device description object 806 * @ai: attaching information 807 * @pnum: the physical eraseblock number 808 * @vid: The volume ID of the found volume will be stored in this pointer 809 * @sqnum: The sqnum of the found volume will be stored in this pointer 810 * 811 * This function reads UBI headers of PEB @pnum, checks them, and adds 812 * information about this PEB to the corresponding list or RB-tree in the 813 * "attaching info" structure. Returns zero if the physical eraseblock was 814 * successfully handled and a negative error code in case of failure. 815 */ 816 static int scan_peb(struct ubi_device *ubi, struct ubi_attach_info *ai, 817 int pnum, int *vid, unsigned long long *sqnum) 818 { 819 long long uninitialized_var(ec); 820 int err, bitflips = 0, vol_id = -1, ec_err = 0; 821 822 dbg_bld("scan PEB %d", pnum); 823 824 /* Skip bad physical eraseblocks */ 825 err = ubi_io_is_bad(ubi, pnum); 826 if (err < 0) 827 return err; 828 else if (err) { 829 ai->bad_peb_count += 1; 830 return 0; 831 } 832 833 err = ubi_io_read_ec_hdr(ubi, pnum, ech, 0); 834 if (err < 0) 835 return err; 836 switch (err) { 837 case 0: 838 break; 839 case UBI_IO_BITFLIPS: 840 bitflips = 1; 841 break; 842 case UBI_IO_FF: 843 ai->empty_peb_count += 1; 844 return add_to_list(ai, pnum, UBI_UNKNOWN, UBI_UNKNOWN, 845 UBI_UNKNOWN, 0, &ai->erase); 846 case UBI_IO_FF_BITFLIPS: 847 ai->empty_peb_count += 1; 848 return add_to_list(ai, pnum, UBI_UNKNOWN, UBI_UNKNOWN, 849 UBI_UNKNOWN, 1, &ai->erase); 850 case UBI_IO_BAD_HDR_EBADMSG: 851 case UBI_IO_BAD_HDR: 852 /* 853 * We have to also look at the VID header, possibly it is not 854 * corrupted. Set %bitflips flag in order to make this PEB be 855 * moved and EC be re-created. 856 */ 857 ec_err = err; 858 ec = UBI_UNKNOWN; 859 bitflips = 1; 860 break; 861 default: 862 ubi_err("'ubi_io_read_ec_hdr()' returned unknown code %d", err); 863 return -EINVAL; 864 } 865 866 if (!ec_err) { 867 int image_seq; 868 869 /* Make sure UBI version is OK */ 870 if (ech->version != UBI_VERSION) { 871 ubi_err("this UBI version is %d, image version is %d", 872 UBI_VERSION, (int)ech->version); 873 return -EINVAL; 874 } 875 876 ec = be64_to_cpu(ech->ec); 877 if (ec > UBI_MAX_ERASECOUNTER) { 878 /* 879 * Erase counter overflow. The EC headers have 64 bits 880 * reserved, but we anyway make use of only 31 bit 881 * values, as this seems to be enough for any existing 882 * flash. Upgrade UBI and use 64-bit erase counters 883 * internally. 884 */ 885 ubi_err("erase counter overflow, max is %d", 886 UBI_MAX_ERASECOUNTER); 887 ubi_dump_ec_hdr(ech); 888 return -EINVAL; 889 } 890 891 /* 892 * Make sure that all PEBs have the same image sequence number. 893 * This allows us to detect situations when users flash UBI 894 * images incorrectly, so that the flash has the new UBI image 895 * and leftovers from the old one. This feature was added 896 * relatively recently, and the sequence number was always 897 * zero, because old UBI implementations always set it to zero. 898 * For this reasons, we do not panic if some PEBs have zero 899 * sequence number, while other PEBs have non-zero sequence 900 * number. 901 */ 902 image_seq = be32_to_cpu(ech->image_seq); 903 if (!ubi->image_seq && image_seq) 904 ubi->image_seq = image_seq; 905 if (ubi->image_seq && image_seq && 906 ubi->image_seq != image_seq) { 907 ubi_err("bad image sequence number %d in PEB %d, expected %d", 908 image_seq, pnum, ubi->image_seq); 909 ubi_dump_ec_hdr(ech); 910 return -EINVAL; 911 } 912 } 913 914 /* OK, we've done with the EC header, let's look at the VID header */ 915 916 err = ubi_io_read_vid_hdr(ubi, pnum, vidh, 0); 917 if (err < 0) 918 return err; 919 switch (err) { 920 case 0: 921 break; 922 case UBI_IO_BITFLIPS: 923 bitflips = 1; 924 break; 925 case UBI_IO_BAD_HDR_EBADMSG: 926 if (ec_err == UBI_IO_BAD_HDR_EBADMSG) 927 /* 928 * Both EC and VID headers are corrupted and were read 929 * with data integrity error, probably this is a bad 930 * PEB, bit it is not marked as bad yet. This may also 931 * be a result of power cut during erasure. 932 */ 933 ai->maybe_bad_peb_count += 1; 934 case UBI_IO_BAD_HDR: 935 if (ec_err) 936 /* 937 * Both headers are corrupted. There is a possibility 938 * that this a valid UBI PEB which has corresponding 939 * LEB, but the headers are corrupted. However, it is 940 * impossible to distinguish it from a PEB which just 941 * contains garbage because of a power cut during erase 942 * operation. So we just schedule this PEB for erasure. 943 * 944 * Besides, in case of NOR flash, we deliberately 945 * corrupt both headers because NOR flash erasure is 946 * slow and can start from the end. 947 */ 948 err = 0; 949 else 950 /* 951 * The EC was OK, but the VID header is corrupted. We 952 * have to check what is in the data area. 953 */ 954 err = check_corruption(ubi, vidh, pnum); 955 956 if (err < 0) 957 return err; 958 else if (!err) 959 /* This corruption is caused by a power cut */ 960 err = add_to_list(ai, pnum, UBI_UNKNOWN, 961 UBI_UNKNOWN, ec, 1, &ai->erase); 962 else 963 /* This is an unexpected corruption */ 964 err = add_corrupted(ai, pnum, ec); 965 if (err) 966 return err; 967 goto adjust_mean_ec; 968 case UBI_IO_FF_BITFLIPS: 969 err = add_to_list(ai, pnum, UBI_UNKNOWN, UBI_UNKNOWN, 970 ec, 1, &ai->erase); 971 if (err) 972 return err; 973 goto adjust_mean_ec; 974 case UBI_IO_FF: 975 if (ec_err || bitflips) 976 err = add_to_list(ai, pnum, UBI_UNKNOWN, 977 UBI_UNKNOWN, ec, 1, &ai->erase); 978 else 979 err = add_to_list(ai, pnum, UBI_UNKNOWN, 980 UBI_UNKNOWN, ec, 0, &ai->free); 981 if (err) 982 return err; 983 goto adjust_mean_ec; 984 default: 985 ubi_err("'ubi_io_read_vid_hdr()' returned unknown code %d", 986 err); 987 return -EINVAL; 988 } 989 990 vol_id = be32_to_cpu(vidh->vol_id); 991 if (vid) 992 *vid = vol_id; 993 if (sqnum) 994 *sqnum = be64_to_cpu(vidh->sqnum); 995 if (vol_id > UBI_MAX_VOLUMES && vol_id != UBI_LAYOUT_VOLUME_ID) { 996 int lnum = be32_to_cpu(vidh->lnum); 997 998 /* Unsupported internal volume */ 999 switch (vidh->compat) { 1000 case UBI_COMPAT_DELETE: 1001 if (vol_id != UBI_FM_SB_VOLUME_ID 1002 && vol_id != UBI_FM_DATA_VOLUME_ID) { 1003 ubi_msg("\"delete\" compatible internal volume %d:%d found, will remove it", 1004 vol_id, lnum); 1005 } 1006 err = add_to_list(ai, pnum, vol_id, lnum, 1007 ec, 1, &ai->erase); 1008 if (err) 1009 return err; 1010 return 0; 1011 1012 case UBI_COMPAT_RO: 1013 ubi_msg("read-only compatible internal volume %d:%d found, switch to read-only mode", 1014 vol_id, lnum); 1015 ubi->ro_mode = 1; 1016 break; 1017 1018 case UBI_COMPAT_PRESERVE: 1019 ubi_msg("\"preserve\" compatible internal volume %d:%d found", 1020 vol_id, lnum); 1021 err = add_to_list(ai, pnum, vol_id, lnum, 1022 ec, 0, &ai->alien); 1023 if (err) 1024 return err; 1025 return 0; 1026 1027 case UBI_COMPAT_REJECT: 1028 ubi_err("incompatible internal volume %d:%d found", 1029 vol_id, lnum); 1030 return -EINVAL; 1031 } 1032 } 1033 1034 if (ec_err) 1035 ubi_warn("valid VID header but corrupted EC header at PEB %d", 1036 pnum); 1037 err = ubi_add_to_av(ubi, ai, pnum, ec, vidh, bitflips); 1038 if (err) 1039 return err; 1040 1041 adjust_mean_ec: 1042 if (!ec_err) { 1043 ai->ec_sum += ec; 1044 ai->ec_count += 1; 1045 if (ec > ai->max_ec) 1046 ai->max_ec = ec; 1047 if (ec < ai->min_ec) 1048 ai->min_ec = ec; 1049 } 1050 1051 return 0; 1052 } 1053 1054 /** 1055 * late_analysis - analyze the overall situation with PEB. 1056 * @ubi: UBI device description object 1057 * @ai: attaching information 1058 * 1059 * This is a helper function which takes a look what PEBs we have after we 1060 * gather information about all of them ("ai" is compete). It decides whether 1061 * the flash is empty and should be formatted of whether there are too many 1062 * corrupted PEBs and we should not attach this MTD device. Returns zero if we 1063 * should proceed with attaching the MTD device, and %-EINVAL if we should not. 1064 */ 1065 static int late_analysis(struct ubi_device *ubi, struct ubi_attach_info *ai) 1066 { 1067 struct ubi_ainf_peb *aeb; 1068 int max_corr, peb_count; 1069 1070 peb_count = ubi->peb_count - ai->bad_peb_count - ai->alien_peb_count; 1071 max_corr = peb_count / 20 ?: 8; 1072 1073 /* 1074 * Few corrupted PEBs is not a problem and may be just a result of 1075 * unclean reboots. However, many of them may indicate some problems 1076 * with the flash HW or driver. 1077 */ 1078 if (ai->corr_peb_count) { 1079 ubi_err("%d PEBs are corrupted and preserved", 1080 ai->corr_peb_count); 1081 pr_err("Corrupted PEBs are:"); 1082 list_for_each_entry(aeb, &ai->corr, u.list) 1083 pr_cont(" %d", aeb->pnum); 1084 pr_cont("\n"); 1085 1086 /* 1087 * If too many PEBs are corrupted, we refuse attaching, 1088 * otherwise, only print a warning. 1089 */ 1090 if (ai->corr_peb_count >= max_corr) { 1091 ubi_err("too many corrupted PEBs, refusing"); 1092 return -EINVAL; 1093 } 1094 } 1095 1096 if (ai->empty_peb_count + ai->maybe_bad_peb_count == peb_count) { 1097 /* 1098 * All PEBs are empty, or almost all - a couple PEBs look like 1099 * they may be bad PEBs which were not marked as bad yet. 1100 * 1101 * This piece of code basically tries to distinguish between 1102 * the following situations: 1103 * 1104 * 1. Flash is empty, but there are few bad PEBs, which are not 1105 * marked as bad so far, and which were read with error. We 1106 * want to go ahead and format this flash. While formatting, 1107 * the faulty PEBs will probably be marked as bad. 1108 * 1109 * 2. Flash contains non-UBI data and we do not want to format 1110 * it and destroy possibly important information. 1111 */ 1112 if (ai->maybe_bad_peb_count <= 2) { 1113 ai->is_empty = 1; 1114 ubi_msg("empty MTD device detected"); 1115 get_random_bytes(&ubi->image_seq, 1116 sizeof(ubi->image_seq)); 1117 } else { 1118 ubi_err("MTD device is not UBI-formatted and possibly contains non-UBI data - refusing it"); 1119 return -EINVAL; 1120 } 1121 1122 } 1123 1124 return 0; 1125 } 1126 1127 /** 1128 * destroy_av - free volume attaching information. 1129 * @av: volume attaching information 1130 * @ai: attaching information 1131 * 1132 * This function destroys the volume attaching information. 1133 */ 1134 static void destroy_av(struct ubi_attach_info *ai, struct ubi_ainf_volume *av) 1135 { 1136 struct ubi_ainf_peb *aeb; 1137 struct rb_node *this = av->root.rb_node; 1138 1139 while (this) { 1140 if (this->rb_left) 1141 this = this->rb_left; 1142 else if (this->rb_right) 1143 this = this->rb_right; 1144 else { 1145 aeb = rb_entry(this, struct ubi_ainf_peb, u.rb); 1146 this = rb_parent(this); 1147 if (this) { 1148 if (this->rb_left == &aeb->u.rb) 1149 this->rb_left = NULL; 1150 else 1151 this->rb_right = NULL; 1152 } 1153 1154 kmem_cache_free(ai->aeb_slab_cache, aeb); 1155 } 1156 } 1157 kfree(av); 1158 } 1159 1160 /** 1161 * destroy_ai - destroy attaching information. 1162 * @ai: attaching information 1163 */ 1164 static void destroy_ai(struct ubi_attach_info *ai) 1165 { 1166 struct ubi_ainf_peb *aeb, *aeb_tmp; 1167 struct ubi_ainf_volume *av; 1168 struct rb_node *rb; 1169 1170 list_for_each_entry_safe(aeb, aeb_tmp, &ai->alien, u.list) { 1171 list_del(&aeb->u.list); 1172 kmem_cache_free(ai->aeb_slab_cache, aeb); 1173 } 1174 list_for_each_entry_safe(aeb, aeb_tmp, &ai->erase, u.list) { 1175 list_del(&aeb->u.list); 1176 kmem_cache_free(ai->aeb_slab_cache, aeb); 1177 } 1178 list_for_each_entry_safe(aeb, aeb_tmp, &ai->corr, u.list) { 1179 list_del(&aeb->u.list); 1180 kmem_cache_free(ai->aeb_slab_cache, aeb); 1181 } 1182 list_for_each_entry_safe(aeb, aeb_tmp, &ai->free, u.list) { 1183 list_del(&aeb->u.list); 1184 kmem_cache_free(ai->aeb_slab_cache, aeb); 1185 } 1186 1187 /* Destroy the volume RB-tree */ 1188 rb = ai->volumes.rb_node; 1189 while (rb) { 1190 if (rb->rb_left) 1191 rb = rb->rb_left; 1192 else if (rb->rb_right) 1193 rb = rb->rb_right; 1194 else { 1195 av = rb_entry(rb, struct ubi_ainf_volume, rb); 1196 1197 rb = rb_parent(rb); 1198 if (rb) { 1199 if (rb->rb_left == &av->rb) 1200 rb->rb_left = NULL; 1201 else 1202 rb->rb_right = NULL; 1203 } 1204 1205 destroy_av(ai, av); 1206 } 1207 } 1208 1209 if (ai->aeb_slab_cache) 1210 kmem_cache_destroy(ai->aeb_slab_cache); 1211 1212 kfree(ai); 1213 } 1214 1215 /** 1216 * scan_all - scan entire MTD device. 1217 * @ubi: UBI device description object 1218 * @ai: attach info object 1219 * @start: start scanning at this PEB 1220 * 1221 * This function does full scanning of an MTD device and returns complete 1222 * information about it in form of a "struct ubi_attach_info" object. In case 1223 * of failure, an error code is returned. 1224 */ 1225 static int scan_all(struct ubi_device *ubi, struct ubi_attach_info *ai, 1226 int start) 1227 { 1228 int err, pnum; 1229 struct rb_node *rb1, *rb2; 1230 struct ubi_ainf_volume *av; 1231 struct ubi_ainf_peb *aeb; 1232 1233 err = -ENOMEM; 1234 1235 ech = kzalloc(ubi->ec_hdr_alsize, GFP_KERNEL); 1236 if (!ech) 1237 return err; 1238 1239 vidh = ubi_zalloc_vid_hdr(ubi, GFP_KERNEL); 1240 if (!vidh) 1241 goto out_ech; 1242 1243 for (pnum = start; pnum < ubi->peb_count; pnum++) { 1244 cond_resched(); 1245 1246 dbg_gen("process PEB %d", pnum); 1247 err = scan_peb(ubi, ai, pnum, NULL, NULL); 1248 if (err < 0) 1249 goto out_vidh; 1250 } 1251 1252 ubi_msg("scanning is finished"); 1253 1254 /* Calculate mean erase counter */ 1255 if (ai->ec_count) 1256 ai->mean_ec = div_u64(ai->ec_sum, ai->ec_count); 1257 1258 err = late_analysis(ubi, ai); 1259 if (err) 1260 goto out_vidh; 1261 1262 /* 1263 * In case of unknown erase counter we use the mean erase counter 1264 * value. 1265 */ 1266 ubi_rb_for_each_entry(rb1, av, &ai->volumes, rb) { 1267 ubi_rb_for_each_entry(rb2, aeb, &av->root, u.rb) 1268 if (aeb->ec == UBI_UNKNOWN) 1269 aeb->ec = ai->mean_ec; 1270 } 1271 1272 list_for_each_entry(aeb, &ai->free, u.list) { 1273 if (aeb->ec == UBI_UNKNOWN) 1274 aeb->ec = ai->mean_ec; 1275 } 1276 1277 list_for_each_entry(aeb, &ai->corr, u.list) 1278 if (aeb->ec == UBI_UNKNOWN) 1279 aeb->ec = ai->mean_ec; 1280 1281 list_for_each_entry(aeb, &ai->erase, u.list) 1282 if (aeb->ec == UBI_UNKNOWN) 1283 aeb->ec = ai->mean_ec; 1284 1285 err = self_check_ai(ubi, ai); 1286 if (err) 1287 goto out_vidh; 1288 1289 ubi_free_vid_hdr(ubi, vidh); 1290 kfree(ech); 1291 1292 return 0; 1293 1294 out_vidh: 1295 ubi_free_vid_hdr(ubi, vidh); 1296 out_ech: 1297 kfree(ech); 1298 return err; 1299 } 1300 1301 #ifdef CONFIG_MTD_UBI_FASTMAP 1302 1303 /** 1304 * scan_fastmap - try to find a fastmap and attach from it. 1305 * @ubi: UBI device description object 1306 * @ai: attach info object 1307 * 1308 * Returns 0 on success, negative return values indicate an internal 1309 * error. 1310 * UBI_NO_FASTMAP denotes that no fastmap was found. 1311 * UBI_BAD_FASTMAP denotes that the found fastmap was invalid. 1312 */ 1313 static int scan_fast(struct ubi_device *ubi, struct ubi_attach_info *ai) 1314 { 1315 int err, pnum, fm_anchor = -1; 1316 unsigned long long max_sqnum = 0; 1317 1318 err = -ENOMEM; 1319 1320 ech = kzalloc(ubi->ec_hdr_alsize, GFP_KERNEL); 1321 if (!ech) 1322 goto out; 1323 1324 vidh = ubi_zalloc_vid_hdr(ubi, GFP_KERNEL); 1325 if (!vidh) 1326 goto out_ech; 1327 1328 for (pnum = 0; pnum < UBI_FM_MAX_START; pnum++) { 1329 int vol_id = -1; 1330 unsigned long long sqnum = -1; 1331 cond_resched(); 1332 1333 dbg_gen("process PEB %d", pnum); 1334 err = scan_peb(ubi, ai, pnum, &vol_id, &sqnum); 1335 if (err < 0) 1336 goto out_vidh; 1337 1338 if (vol_id == UBI_FM_SB_VOLUME_ID && sqnum > max_sqnum) { 1339 max_sqnum = sqnum; 1340 fm_anchor = pnum; 1341 } 1342 } 1343 1344 ubi_free_vid_hdr(ubi, vidh); 1345 kfree(ech); 1346 1347 if (fm_anchor < 0) 1348 return UBI_NO_FASTMAP; 1349 1350 return ubi_scan_fastmap(ubi, ai, fm_anchor); 1351 1352 out_vidh: 1353 ubi_free_vid_hdr(ubi, vidh); 1354 out_ech: 1355 kfree(ech); 1356 out: 1357 return err; 1358 } 1359 1360 #endif 1361 1362 static struct ubi_attach_info *alloc_ai(const char *slab_name) 1363 { 1364 struct ubi_attach_info *ai; 1365 1366 ai = kzalloc(sizeof(struct ubi_attach_info), GFP_KERNEL); 1367 if (!ai) 1368 return ai; 1369 1370 INIT_LIST_HEAD(&ai->corr); 1371 INIT_LIST_HEAD(&ai->free); 1372 INIT_LIST_HEAD(&ai->erase); 1373 INIT_LIST_HEAD(&ai->alien); 1374 ai->volumes = RB_ROOT; 1375 ai->aeb_slab_cache = kmem_cache_create(slab_name, 1376 sizeof(struct ubi_ainf_peb), 1377 0, 0, NULL); 1378 if (!ai->aeb_slab_cache) { 1379 kfree(ai); 1380 ai = NULL; 1381 } 1382 1383 return ai; 1384 } 1385 1386 /** 1387 * ubi_attach - attach an MTD device. 1388 * @ubi: UBI device descriptor 1389 * @force_scan: if set to non-zero attach by scanning 1390 * 1391 * This function returns zero in case of success and a negative error code in 1392 * case of failure. 1393 */ 1394 int ubi_attach(struct ubi_device *ubi, int force_scan) 1395 { 1396 int err; 1397 struct ubi_attach_info *ai; 1398 1399 ai = alloc_ai("ubi_aeb_slab_cache"); 1400 if (!ai) 1401 return -ENOMEM; 1402 1403 #ifdef CONFIG_MTD_UBI_FASTMAP 1404 /* On small flash devices we disable fastmap in any case. */ 1405 if ((int)mtd_div_by_eb(ubi->mtd->size, ubi->mtd) <= UBI_FM_MAX_START) { 1406 ubi->fm_disabled = 1; 1407 force_scan = 1; 1408 } 1409 1410 if (force_scan) 1411 err = scan_all(ubi, ai, 0); 1412 else { 1413 err = scan_fast(ubi, ai); 1414 if (err > 0) { 1415 if (err != UBI_NO_FASTMAP) { 1416 destroy_ai(ai); 1417 ai = alloc_ai("ubi_aeb_slab_cache2"); 1418 if (!ai) 1419 return -ENOMEM; 1420 } 1421 1422 err = scan_all(ubi, ai, UBI_FM_MAX_START); 1423 } 1424 } 1425 #else 1426 err = scan_all(ubi, ai, 0); 1427 #endif 1428 if (err) 1429 goto out_ai; 1430 1431 ubi->bad_peb_count = ai->bad_peb_count; 1432 ubi->good_peb_count = ubi->peb_count - ubi->bad_peb_count; 1433 ubi->corr_peb_count = ai->corr_peb_count; 1434 ubi->max_ec = ai->max_ec; 1435 ubi->mean_ec = ai->mean_ec; 1436 dbg_gen("max. sequence number: %llu", ai->max_sqnum); 1437 1438 err = ubi_read_volume_table(ubi, ai); 1439 if (err) 1440 goto out_ai; 1441 1442 err = ubi_wl_init(ubi, ai); 1443 if (err) 1444 goto out_vtbl; 1445 1446 err = ubi_eba_init(ubi, ai); 1447 if (err) 1448 goto out_wl; 1449 1450 #ifdef CONFIG_MTD_UBI_FASTMAP 1451 if (ubi->fm && ubi_dbg_chk_gen(ubi)) { 1452 struct ubi_attach_info *scan_ai; 1453 1454 scan_ai = alloc_ai("ubi_ckh_aeb_slab_cache"); 1455 if (!scan_ai) 1456 goto out_wl; 1457 1458 err = scan_all(ubi, scan_ai, 0); 1459 if (err) { 1460 destroy_ai(scan_ai); 1461 goto out_wl; 1462 } 1463 1464 err = self_check_eba(ubi, ai, scan_ai); 1465 destroy_ai(scan_ai); 1466 1467 if (err) 1468 goto out_wl; 1469 } 1470 #endif 1471 1472 destroy_ai(ai); 1473 return 0; 1474 1475 out_wl: 1476 ubi_wl_close(ubi); 1477 out_vtbl: 1478 ubi_free_internal_volumes(ubi); 1479 vfree(ubi->vtbl); 1480 out_ai: 1481 destroy_ai(ai); 1482 return err; 1483 } 1484 1485 /** 1486 * self_check_ai - check the attaching information. 1487 * @ubi: UBI device description object 1488 * @ai: attaching information 1489 * 1490 * This function returns zero if the attaching information is all right, and a 1491 * negative error code if not or if an error occurred. 1492 */ 1493 static int self_check_ai(struct ubi_device *ubi, struct ubi_attach_info *ai) 1494 { 1495 int pnum, err, vols_found = 0; 1496 struct rb_node *rb1, *rb2; 1497 struct ubi_ainf_volume *av; 1498 struct ubi_ainf_peb *aeb, *last_aeb; 1499 uint8_t *buf; 1500 1501 if (!ubi_dbg_chk_gen(ubi)) 1502 return 0; 1503 1504 /* 1505 * At first, check that attaching information is OK. 1506 */ 1507 ubi_rb_for_each_entry(rb1, av, &ai->volumes, rb) { 1508 int leb_count = 0; 1509 1510 cond_resched(); 1511 1512 vols_found += 1; 1513 1514 if (ai->is_empty) { 1515 ubi_err("bad is_empty flag"); 1516 goto bad_av; 1517 } 1518 1519 if (av->vol_id < 0 || av->highest_lnum < 0 || 1520 av->leb_count < 0 || av->vol_type < 0 || av->used_ebs < 0 || 1521 av->data_pad < 0 || av->last_data_size < 0) { 1522 ubi_err("negative values"); 1523 goto bad_av; 1524 } 1525 1526 if (av->vol_id >= UBI_MAX_VOLUMES && 1527 av->vol_id < UBI_INTERNAL_VOL_START) { 1528 ubi_err("bad vol_id"); 1529 goto bad_av; 1530 } 1531 1532 if (av->vol_id > ai->highest_vol_id) { 1533 ubi_err("highest_vol_id is %d, but vol_id %d is there", 1534 ai->highest_vol_id, av->vol_id); 1535 goto out; 1536 } 1537 1538 if (av->vol_type != UBI_DYNAMIC_VOLUME && 1539 av->vol_type != UBI_STATIC_VOLUME) { 1540 ubi_err("bad vol_type"); 1541 goto bad_av; 1542 } 1543 1544 if (av->data_pad > ubi->leb_size / 2) { 1545 ubi_err("bad data_pad"); 1546 goto bad_av; 1547 } 1548 1549 last_aeb = NULL; 1550 ubi_rb_for_each_entry(rb2, aeb, &av->root, u.rb) { 1551 cond_resched(); 1552 1553 last_aeb = aeb; 1554 leb_count += 1; 1555 1556 if (aeb->pnum < 0 || aeb->ec < 0) { 1557 ubi_err("negative values"); 1558 goto bad_aeb; 1559 } 1560 1561 if (aeb->ec < ai->min_ec) { 1562 ubi_err("bad ai->min_ec (%d), %d found", 1563 ai->min_ec, aeb->ec); 1564 goto bad_aeb; 1565 } 1566 1567 if (aeb->ec > ai->max_ec) { 1568 ubi_err("bad ai->max_ec (%d), %d found", 1569 ai->max_ec, aeb->ec); 1570 goto bad_aeb; 1571 } 1572 1573 if (aeb->pnum >= ubi->peb_count) { 1574 ubi_err("too high PEB number %d, total PEBs %d", 1575 aeb->pnum, ubi->peb_count); 1576 goto bad_aeb; 1577 } 1578 1579 if (av->vol_type == UBI_STATIC_VOLUME) { 1580 if (aeb->lnum >= av->used_ebs) { 1581 ubi_err("bad lnum or used_ebs"); 1582 goto bad_aeb; 1583 } 1584 } else { 1585 if (av->used_ebs != 0) { 1586 ubi_err("non-zero used_ebs"); 1587 goto bad_aeb; 1588 } 1589 } 1590 1591 if (aeb->lnum > av->highest_lnum) { 1592 ubi_err("incorrect highest_lnum or lnum"); 1593 goto bad_aeb; 1594 } 1595 } 1596 1597 if (av->leb_count != leb_count) { 1598 ubi_err("bad leb_count, %d objects in the tree", 1599 leb_count); 1600 goto bad_av; 1601 } 1602 1603 if (!last_aeb) 1604 continue; 1605 1606 aeb = last_aeb; 1607 1608 if (aeb->lnum != av->highest_lnum) { 1609 ubi_err("bad highest_lnum"); 1610 goto bad_aeb; 1611 } 1612 } 1613 1614 if (vols_found != ai->vols_found) { 1615 ubi_err("bad ai->vols_found %d, should be %d", 1616 ai->vols_found, vols_found); 1617 goto out; 1618 } 1619 1620 /* Check that attaching information is correct */ 1621 ubi_rb_for_each_entry(rb1, av, &ai->volumes, rb) { 1622 last_aeb = NULL; 1623 ubi_rb_for_each_entry(rb2, aeb, &av->root, u.rb) { 1624 int vol_type; 1625 1626 cond_resched(); 1627 1628 last_aeb = aeb; 1629 1630 err = ubi_io_read_vid_hdr(ubi, aeb->pnum, vidh, 1); 1631 if (err && err != UBI_IO_BITFLIPS) { 1632 ubi_err("VID header is not OK (%d)", err); 1633 if (err > 0) 1634 err = -EIO; 1635 return err; 1636 } 1637 1638 vol_type = vidh->vol_type == UBI_VID_DYNAMIC ? 1639 UBI_DYNAMIC_VOLUME : UBI_STATIC_VOLUME; 1640 if (av->vol_type != vol_type) { 1641 ubi_err("bad vol_type"); 1642 goto bad_vid_hdr; 1643 } 1644 1645 if (aeb->sqnum != be64_to_cpu(vidh->sqnum)) { 1646 ubi_err("bad sqnum %llu", aeb->sqnum); 1647 goto bad_vid_hdr; 1648 } 1649 1650 if (av->vol_id != be32_to_cpu(vidh->vol_id)) { 1651 ubi_err("bad vol_id %d", av->vol_id); 1652 goto bad_vid_hdr; 1653 } 1654 1655 if (av->compat != vidh->compat) { 1656 ubi_err("bad compat %d", vidh->compat); 1657 goto bad_vid_hdr; 1658 } 1659 1660 if (aeb->lnum != be32_to_cpu(vidh->lnum)) { 1661 ubi_err("bad lnum %d", aeb->lnum); 1662 goto bad_vid_hdr; 1663 } 1664 1665 if (av->used_ebs != be32_to_cpu(vidh->used_ebs)) { 1666 ubi_err("bad used_ebs %d", av->used_ebs); 1667 goto bad_vid_hdr; 1668 } 1669 1670 if (av->data_pad != be32_to_cpu(vidh->data_pad)) { 1671 ubi_err("bad data_pad %d", av->data_pad); 1672 goto bad_vid_hdr; 1673 } 1674 } 1675 1676 if (!last_aeb) 1677 continue; 1678 1679 if (av->highest_lnum != be32_to_cpu(vidh->lnum)) { 1680 ubi_err("bad highest_lnum %d", av->highest_lnum); 1681 goto bad_vid_hdr; 1682 } 1683 1684 if (av->last_data_size != be32_to_cpu(vidh->data_size)) { 1685 ubi_err("bad last_data_size %d", av->last_data_size); 1686 goto bad_vid_hdr; 1687 } 1688 } 1689 1690 /* 1691 * Make sure that all the physical eraseblocks are in one of the lists 1692 * or trees. 1693 */ 1694 buf = kzalloc(ubi->peb_count, GFP_KERNEL); 1695 if (!buf) 1696 return -ENOMEM; 1697 1698 for (pnum = 0; pnum < ubi->peb_count; pnum++) { 1699 err = ubi_io_is_bad(ubi, pnum); 1700 if (err < 0) { 1701 kfree(buf); 1702 return err; 1703 } else if (err) 1704 buf[pnum] = 1; 1705 } 1706 1707 ubi_rb_for_each_entry(rb1, av, &ai->volumes, rb) 1708 ubi_rb_for_each_entry(rb2, aeb, &av->root, u.rb) 1709 buf[aeb->pnum] = 1; 1710 1711 list_for_each_entry(aeb, &ai->free, u.list) 1712 buf[aeb->pnum] = 1; 1713 1714 list_for_each_entry(aeb, &ai->corr, u.list) 1715 buf[aeb->pnum] = 1; 1716 1717 list_for_each_entry(aeb, &ai->erase, u.list) 1718 buf[aeb->pnum] = 1; 1719 1720 list_for_each_entry(aeb, &ai->alien, u.list) 1721 buf[aeb->pnum] = 1; 1722 1723 err = 0; 1724 for (pnum = 0; pnum < ubi->peb_count; pnum++) 1725 if (!buf[pnum]) { 1726 ubi_err("PEB %d is not referred", pnum); 1727 err = 1; 1728 } 1729 1730 kfree(buf); 1731 if (err) 1732 goto out; 1733 return 0; 1734 1735 bad_aeb: 1736 ubi_err("bad attaching information about LEB %d", aeb->lnum); 1737 ubi_dump_aeb(aeb, 0); 1738 ubi_dump_av(av); 1739 goto out; 1740 1741 bad_av: 1742 ubi_err("bad attaching information about volume %d", av->vol_id); 1743 ubi_dump_av(av); 1744 goto out; 1745 1746 bad_vid_hdr: 1747 ubi_err("bad attaching information about volume %d", av->vol_id); 1748 ubi_dump_av(av); 1749 ubi_dump_vid_hdr(vidh); 1750 1751 out: 1752 dump_stack(); 1753 return -EINVAL; 1754 } 1755