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