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 * The UBI Eraseblock Association (EBA) sub-system. 23 * 24 * This sub-system is responsible for I/O to/from logical eraseblock. 25 * 26 * Although in this implementation the EBA table is fully kept and managed in 27 * RAM, which assumes poor scalability, it might be (partially) maintained on 28 * flash in future implementations. 29 * 30 * The EBA sub-system implements per-logical eraseblock locking. Before 31 * accessing a logical eraseblock it is locked for reading or writing. The 32 * per-logical eraseblock locking is implemented by means of the lock tree. The 33 * lock tree is an RB-tree which refers all the currently locked logical 34 * eraseblocks. The lock tree elements are &struct ubi_ltree_entry objects. 35 * They are indexed by (@vol_id, @lnum) pairs. 36 * 37 * EBA also maintains the global sequence counter which is incremented each 38 * time a logical eraseblock is mapped to a physical eraseblock and it is 39 * stored in the volume identifier header. This means that each VID header has 40 * a unique sequence number. The sequence number is only increased an we assume 41 * 64 bits is enough to never overflow. 42 */ 43 44 #include <linux/slab.h> 45 #include <linux/crc32.h> 46 #include <linux/err.h> 47 #include "ubi.h" 48 49 /* Number of physical eraseblocks reserved for atomic LEB change operation */ 50 #define EBA_RESERVED_PEBS 1 51 52 /** 53 * struct ubi_eba_entry - structure encoding a single LEB -> PEB association 54 * @pnum: the physical eraseblock number attached to the LEB 55 * 56 * This structure is encoding a LEB -> PEB association. Note that the LEB 57 * number is not stored here, because it is the index used to access the 58 * entries table. 59 */ 60 struct ubi_eba_entry { 61 int pnum; 62 }; 63 64 /** 65 * struct ubi_eba_table - LEB -> PEB association information 66 * @entries: the LEB to PEB mapping (one entry per LEB). 67 * 68 * This structure is private to the EBA logic and should be kept here. 69 * It is encoding the LEB to PEB association table, and is subject to 70 * changes. 71 */ 72 struct ubi_eba_table { 73 struct ubi_eba_entry *entries; 74 }; 75 76 /** 77 * next_sqnum - get next sequence number. 78 * @ubi: UBI device description object 79 * 80 * This function returns next sequence number to use, which is just the current 81 * global sequence counter value. It also increases the global sequence 82 * counter. 83 */ 84 unsigned long long ubi_next_sqnum(struct ubi_device *ubi) 85 { 86 unsigned long long sqnum; 87 88 spin_lock(&ubi->ltree_lock); 89 sqnum = ubi->global_sqnum++; 90 spin_unlock(&ubi->ltree_lock); 91 92 return sqnum; 93 } 94 95 /** 96 * ubi_get_compat - get compatibility flags of a volume. 97 * @ubi: UBI device description object 98 * @vol_id: volume ID 99 * 100 * This function returns compatibility flags for an internal volume. User 101 * volumes have no compatibility flags, so %0 is returned. 102 */ 103 static int ubi_get_compat(const struct ubi_device *ubi, int vol_id) 104 { 105 if (vol_id == UBI_LAYOUT_VOLUME_ID) 106 return UBI_LAYOUT_VOLUME_COMPAT; 107 return 0; 108 } 109 110 /** 111 * ubi_eba_get_ldesc - get information about a LEB 112 * @vol: volume description object 113 * @lnum: logical eraseblock number 114 * @ldesc: the LEB descriptor to fill 115 * 116 * Used to query information about a specific LEB. 117 * It is currently only returning the physical position of the LEB, but will be 118 * extended to provide more information. 119 */ 120 void ubi_eba_get_ldesc(struct ubi_volume *vol, int lnum, 121 struct ubi_eba_leb_desc *ldesc) 122 { 123 ldesc->lnum = lnum; 124 ldesc->pnum = vol->eba_tbl->entries[lnum].pnum; 125 } 126 127 /** 128 * ubi_eba_create_table - allocate a new EBA table and initialize it with all 129 * LEBs unmapped 130 * @vol: volume containing the EBA table to copy 131 * @nentries: number of entries in the table 132 * 133 * Allocate a new EBA table and initialize it with all LEBs unmapped. 134 * Returns a valid pointer if it succeed, an ERR_PTR() otherwise. 135 */ 136 struct ubi_eba_table *ubi_eba_create_table(struct ubi_volume *vol, 137 int nentries) 138 { 139 struct ubi_eba_table *tbl; 140 int err = -ENOMEM; 141 int i; 142 143 tbl = kzalloc(sizeof(*tbl), GFP_KERNEL); 144 if (!tbl) 145 return ERR_PTR(-ENOMEM); 146 147 tbl->entries = kmalloc_array(nentries, sizeof(*tbl->entries), 148 GFP_KERNEL); 149 if (!tbl->entries) 150 goto err; 151 152 for (i = 0; i < nentries; i++) 153 tbl->entries[i].pnum = UBI_LEB_UNMAPPED; 154 155 return tbl; 156 157 err: 158 kfree(tbl->entries); 159 kfree(tbl); 160 161 return ERR_PTR(err); 162 } 163 164 /** 165 * ubi_eba_destroy_table - destroy an EBA table 166 * @tbl: the table to destroy 167 * 168 * Destroy an EBA table. 169 */ 170 void ubi_eba_destroy_table(struct ubi_eba_table *tbl) 171 { 172 if (!tbl) 173 return; 174 175 kfree(tbl->entries); 176 kfree(tbl); 177 } 178 179 /** 180 * ubi_eba_copy_table - copy the EBA table attached to vol into another table 181 * @vol: volume containing the EBA table to copy 182 * @dst: destination 183 * @nentries: number of entries to copy 184 * 185 * Copy the EBA table stored in vol into the one pointed by dst. 186 */ 187 void ubi_eba_copy_table(struct ubi_volume *vol, struct ubi_eba_table *dst, 188 int nentries) 189 { 190 struct ubi_eba_table *src; 191 int i; 192 193 ubi_assert(dst && vol && vol->eba_tbl); 194 195 src = vol->eba_tbl; 196 197 for (i = 0; i < nentries; i++) 198 dst->entries[i].pnum = src->entries[i].pnum; 199 } 200 201 /** 202 * ubi_eba_replace_table - assign a new EBA table to a volume 203 * @vol: volume containing the EBA table to copy 204 * @tbl: new EBA table 205 * 206 * Assign a new EBA table to the volume and release the old one. 207 */ 208 void ubi_eba_replace_table(struct ubi_volume *vol, struct ubi_eba_table *tbl) 209 { 210 ubi_eba_destroy_table(vol->eba_tbl); 211 vol->eba_tbl = tbl; 212 } 213 214 /** 215 * ltree_lookup - look up the lock tree. 216 * @ubi: UBI device description object 217 * @vol_id: volume ID 218 * @lnum: logical eraseblock number 219 * 220 * This function returns a pointer to the corresponding &struct ubi_ltree_entry 221 * object if the logical eraseblock is locked and %NULL if it is not. 222 * @ubi->ltree_lock has to be locked. 223 */ 224 static struct ubi_ltree_entry *ltree_lookup(struct ubi_device *ubi, int vol_id, 225 int lnum) 226 { 227 struct rb_node *p; 228 229 p = ubi->ltree.rb_node; 230 while (p) { 231 struct ubi_ltree_entry *le; 232 233 le = rb_entry(p, struct ubi_ltree_entry, rb); 234 235 if (vol_id < le->vol_id) 236 p = p->rb_left; 237 else if (vol_id > le->vol_id) 238 p = p->rb_right; 239 else { 240 if (lnum < le->lnum) 241 p = p->rb_left; 242 else if (lnum > le->lnum) 243 p = p->rb_right; 244 else 245 return le; 246 } 247 } 248 249 return NULL; 250 } 251 252 /** 253 * ltree_add_entry - add new entry to the lock tree. 254 * @ubi: UBI device description object 255 * @vol_id: volume ID 256 * @lnum: logical eraseblock number 257 * 258 * This function adds new entry for logical eraseblock (@vol_id, @lnum) to the 259 * lock tree. If such entry is already there, its usage counter is increased. 260 * Returns pointer to the lock tree entry or %-ENOMEM if memory allocation 261 * failed. 262 */ 263 static struct ubi_ltree_entry *ltree_add_entry(struct ubi_device *ubi, 264 int vol_id, int lnum) 265 { 266 struct ubi_ltree_entry *le, *le1, *le_free; 267 268 le = kmalloc(sizeof(struct ubi_ltree_entry), GFP_NOFS); 269 if (!le) 270 return ERR_PTR(-ENOMEM); 271 272 le->users = 0; 273 init_rwsem(&le->mutex); 274 le->vol_id = vol_id; 275 le->lnum = lnum; 276 277 spin_lock(&ubi->ltree_lock); 278 le1 = ltree_lookup(ubi, vol_id, lnum); 279 280 if (le1) { 281 /* 282 * This logical eraseblock is already locked. The newly 283 * allocated lock entry is not needed. 284 */ 285 le_free = le; 286 le = le1; 287 } else { 288 struct rb_node **p, *parent = NULL; 289 290 /* 291 * No lock entry, add the newly allocated one to the 292 * @ubi->ltree RB-tree. 293 */ 294 le_free = NULL; 295 296 p = &ubi->ltree.rb_node; 297 while (*p) { 298 parent = *p; 299 le1 = rb_entry(parent, struct ubi_ltree_entry, rb); 300 301 if (vol_id < le1->vol_id) 302 p = &(*p)->rb_left; 303 else if (vol_id > le1->vol_id) 304 p = &(*p)->rb_right; 305 else { 306 ubi_assert(lnum != le1->lnum); 307 if (lnum < le1->lnum) 308 p = &(*p)->rb_left; 309 else 310 p = &(*p)->rb_right; 311 } 312 } 313 314 rb_link_node(&le->rb, parent, p); 315 rb_insert_color(&le->rb, &ubi->ltree); 316 } 317 le->users += 1; 318 spin_unlock(&ubi->ltree_lock); 319 320 kfree(le_free); 321 return le; 322 } 323 324 /** 325 * leb_read_lock - lock logical eraseblock for reading. 326 * @ubi: UBI device description object 327 * @vol_id: volume ID 328 * @lnum: logical eraseblock number 329 * 330 * This function locks a logical eraseblock for reading. Returns zero in case 331 * of success and a negative error code in case of failure. 332 */ 333 static int leb_read_lock(struct ubi_device *ubi, int vol_id, int lnum) 334 { 335 struct ubi_ltree_entry *le; 336 337 le = ltree_add_entry(ubi, vol_id, lnum); 338 if (IS_ERR(le)) 339 return PTR_ERR(le); 340 down_read(&le->mutex); 341 return 0; 342 } 343 344 /** 345 * leb_read_unlock - unlock logical eraseblock. 346 * @ubi: UBI device description object 347 * @vol_id: volume ID 348 * @lnum: logical eraseblock number 349 */ 350 static void leb_read_unlock(struct ubi_device *ubi, int vol_id, int lnum) 351 { 352 struct ubi_ltree_entry *le; 353 354 spin_lock(&ubi->ltree_lock); 355 le = ltree_lookup(ubi, vol_id, lnum); 356 le->users -= 1; 357 ubi_assert(le->users >= 0); 358 up_read(&le->mutex); 359 if (le->users == 0) { 360 rb_erase(&le->rb, &ubi->ltree); 361 kfree(le); 362 } 363 spin_unlock(&ubi->ltree_lock); 364 } 365 366 /** 367 * leb_write_lock - lock logical eraseblock for writing. 368 * @ubi: UBI device description object 369 * @vol_id: volume ID 370 * @lnum: logical eraseblock number 371 * 372 * This function locks a logical eraseblock for writing. Returns zero in case 373 * of success and a negative error code in case of failure. 374 */ 375 static int leb_write_lock(struct ubi_device *ubi, int vol_id, int lnum) 376 { 377 struct ubi_ltree_entry *le; 378 379 le = ltree_add_entry(ubi, vol_id, lnum); 380 if (IS_ERR(le)) 381 return PTR_ERR(le); 382 down_write(&le->mutex); 383 return 0; 384 } 385 386 /** 387 * leb_write_lock - lock logical eraseblock for writing. 388 * @ubi: UBI device description object 389 * @vol_id: volume ID 390 * @lnum: logical eraseblock number 391 * 392 * This function locks a logical eraseblock for writing if there is no 393 * contention and does nothing if there is contention. Returns %0 in case of 394 * success, %1 in case of contention, and and a negative error code in case of 395 * failure. 396 */ 397 static int leb_write_trylock(struct ubi_device *ubi, int vol_id, int lnum) 398 { 399 struct ubi_ltree_entry *le; 400 401 le = ltree_add_entry(ubi, vol_id, lnum); 402 if (IS_ERR(le)) 403 return PTR_ERR(le); 404 if (down_write_trylock(&le->mutex)) 405 return 0; 406 407 /* Contention, cancel */ 408 spin_lock(&ubi->ltree_lock); 409 le->users -= 1; 410 ubi_assert(le->users >= 0); 411 if (le->users == 0) { 412 rb_erase(&le->rb, &ubi->ltree); 413 kfree(le); 414 } 415 spin_unlock(&ubi->ltree_lock); 416 417 return 1; 418 } 419 420 /** 421 * leb_write_unlock - unlock logical eraseblock. 422 * @ubi: UBI device description object 423 * @vol_id: volume ID 424 * @lnum: logical eraseblock number 425 */ 426 static void leb_write_unlock(struct ubi_device *ubi, int vol_id, int lnum) 427 { 428 struct ubi_ltree_entry *le; 429 430 spin_lock(&ubi->ltree_lock); 431 le = ltree_lookup(ubi, vol_id, lnum); 432 le->users -= 1; 433 ubi_assert(le->users >= 0); 434 up_write(&le->mutex); 435 if (le->users == 0) { 436 rb_erase(&le->rb, &ubi->ltree); 437 kfree(le); 438 } 439 spin_unlock(&ubi->ltree_lock); 440 } 441 442 /** 443 * ubi_eba_is_mapped - check if a LEB is mapped. 444 * @vol: volume description object 445 * @lnum: logical eraseblock number 446 * 447 * This function returns true if the LEB is mapped, false otherwise. 448 */ 449 bool ubi_eba_is_mapped(struct ubi_volume *vol, int lnum) 450 { 451 return vol->eba_tbl->entries[lnum].pnum >= 0; 452 } 453 454 /** 455 * ubi_eba_unmap_leb - un-map logical eraseblock. 456 * @ubi: UBI device description object 457 * @vol: volume description object 458 * @lnum: logical eraseblock number 459 * 460 * This function un-maps logical eraseblock @lnum and schedules corresponding 461 * physical eraseblock for erasure. Returns zero in case of success and a 462 * negative error code in case of failure. 463 */ 464 int ubi_eba_unmap_leb(struct ubi_device *ubi, struct ubi_volume *vol, 465 int lnum) 466 { 467 int err, pnum, vol_id = vol->vol_id; 468 469 if (ubi->ro_mode) 470 return -EROFS; 471 472 err = leb_write_lock(ubi, vol_id, lnum); 473 if (err) 474 return err; 475 476 pnum = vol->eba_tbl->entries[lnum].pnum; 477 if (pnum < 0) 478 /* This logical eraseblock is already unmapped */ 479 goto out_unlock; 480 481 dbg_eba("erase LEB %d:%d, PEB %d", vol_id, lnum, pnum); 482 483 down_read(&ubi->fm_eba_sem); 484 vol->eba_tbl->entries[lnum].pnum = UBI_LEB_UNMAPPED; 485 up_read(&ubi->fm_eba_sem); 486 err = ubi_wl_put_peb(ubi, vol_id, lnum, pnum, 0); 487 488 out_unlock: 489 leb_write_unlock(ubi, vol_id, lnum); 490 return err; 491 } 492 493 /** 494 * ubi_eba_read_leb - read data. 495 * @ubi: UBI device description object 496 * @vol: volume description object 497 * @lnum: logical eraseblock number 498 * @buf: buffer to store the read data 499 * @offset: offset from where to read 500 * @len: how many bytes to read 501 * @check: data CRC check flag 502 * 503 * If the logical eraseblock @lnum is unmapped, @buf is filled with 0xFF 504 * bytes. The @check flag only makes sense for static volumes and forces 505 * eraseblock data CRC checking. 506 * 507 * In case of success this function returns zero. In case of a static volume, 508 * if data CRC mismatches - %-EBADMSG is returned. %-EBADMSG may also be 509 * returned for any volume type if an ECC error was detected by the MTD device 510 * driver. Other negative error cored may be returned in case of other errors. 511 */ 512 int ubi_eba_read_leb(struct ubi_device *ubi, struct ubi_volume *vol, int lnum, 513 void *buf, int offset, int len, int check) 514 { 515 int err, pnum, scrub = 0, vol_id = vol->vol_id; 516 struct ubi_vid_io_buf *vidb; 517 struct ubi_vid_hdr *vid_hdr; 518 uint32_t uninitialized_var(crc); 519 520 err = leb_read_lock(ubi, vol_id, lnum); 521 if (err) 522 return err; 523 524 pnum = vol->eba_tbl->entries[lnum].pnum; 525 if (pnum < 0) { 526 /* 527 * The logical eraseblock is not mapped, fill the whole buffer 528 * with 0xFF bytes. The exception is static volumes for which 529 * it is an error to read unmapped logical eraseblocks. 530 */ 531 dbg_eba("read %d bytes from offset %d of LEB %d:%d (unmapped)", 532 len, offset, vol_id, lnum); 533 leb_read_unlock(ubi, vol_id, lnum); 534 ubi_assert(vol->vol_type != UBI_STATIC_VOLUME); 535 memset(buf, 0xFF, len); 536 return 0; 537 } 538 539 dbg_eba("read %d bytes from offset %d of LEB %d:%d, PEB %d", 540 len, offset, vol_id, lnum, pnum); 541 542 if (vol->vol_type == UBI_DYNAMIC_VOLUME) 543 check = 0; 544 545 retry: 546 if (check) { 547 vidb = ubi_alloc_vid_buf(ubi, GFP_NOFS); 548 if (!vidb) { 549 err = -ENOMEM; 550 goto out_unlock; 551 } 552 553 vid_hdr = ubi_get_vid_hdr(vidb); 554 555 err = ubi_io_read_vid_hdr(ubi, pnum, vidb, 1); 556 if (err && err != UBI_IO_BITFLIPS) { 557 if (err > 0) { 558 /* 559 * The header is either absent or corrupted. 560 * The former case means there is a bug - 561 * switch to read-only mode just in case. 562 * The latter case means a real corruption - we 563 * may try to recover data. FIXME: but this is 564 * not implemented. 565 */ 566 if (err == UBI_IO_BAD_HDR_EBADMSG || 567 err == UBI_IO_BAD_HDR) { 568 ubi_warn(ubi, "corrupted VID header at PEB %d, LEB %d:%d", 569 pnum, vol_id, lnum); 570 err = -EBADMSG; 571 } else { 572 /* 573 * Ending up here in the non-Fastmap case 574 * is a clear bug as the VID header had to 575 * be present at scan time to have it referenced. 576 * With fastmap the story is more complicated. 577 * Fastmap has the mapping info without the need 578 * of a full scan. So the LEB could have been 579 * unmapped, Fastmap cannot know this and keeps 580 * the LEB referenced. 581 * This is valid and works as the layer above UBI 582 * has to do bookkeeping about used/referenced 583 * LEBs in any case. 584 */ 585 if (ubi->fast_attach) { 586 err = -EBADMSG; 587 } else { 588 err = -EINVAL; 589 ubi_ro_mode(ubi); 590 } 591 } 592 } 593 goto out_free; 594 } else if (err == UBI_IO_BITFLIPS) 595 scrub = 1; 596 597 ubi_assert(lnum < be32_to_cpu(vid_hdr->used_ebs)); 598 ubi_assert(len == be32_to_cpu(vid_hdr->data_size)); 599 600 crc = be32_to_cpu(vid_hdr->data_crc); 601 ubi_free_vid_buf(vidb); 602 } 603 604 err = ubi_io_read_data(ubi, buf, pnum, offset, len); 605 if (err) { 606 if (err == UBI_IO_BITFLIPS) 607 scrub = 1; 608 else if (mtd_is_eccerr(err)) { 609 if (vol->vol_type == UBI_DYNAMIC_VOLUME) 610 goto out_unlock; 611 scrub = 1; 612 if (!check) { 613 ubi_msg(ubi, "force data checking"); 614 check = 1; 615 goto retry; 616 } 617 } else 618 goto out_unlock; 619 } 620 621 if (check) { 622 uint32_t crc1 = crc32(UBI_CRC32_INIT, buf, len); 623 if (crc1 != crc) { 624 ubi_warn(ubi, "CRC error: calculated %#08x, must be %#08x", 625 crc1, crc); 626 err = -EBADMSG; 627 goto out_unlock; 628 } 629 } 630 631 if (scrub) 632 err = ubi_wl_scrub_peb(ubi, pnum); 633 634 leb_read_unlock(ubi, vol_id, lnum); 635 return err; 636 637 out_free: 638 ubi_free_vid_buf(vidb); 639 out_unlock: 640 leb_read_unlock(ubi, vol_id, lnum); 641 return err; 642 } 643 644 /** 645 * ubi_eba_read_leb_sg - read data into a scatter gather list. 646 * @ubi: UBI device description object 647 * @vol: volume description object 648 * @lnum: logical eraseblock number 649 * @sgl: UBI scatter gather list to store the read data 650 * @offset: offset from where to read 651 * @len: how many bytes to read 652 * @check: data CRC check flag 653 * 654 * This function works exactly like ubi_eba_read_leb(). But instead of 655 * storing the read data into a buffer it writes to an UBI scatter gather 656 * list. 657 */ 658 int ubi_eba_read_leb_sg(struct ubi_device *ubi, struct ubi_volume *vol, 659 struct ubi_sgl *sgl, int lnum, int offset, int len, 660 int check) 661 { 662 int to_read; 663 int ret; 664 struct scatterlist *sg; 665 666 for (;;) { 667 ubi_assert(sgl->list_pos < UBI_MAX_SG_COUNT); 668 sg = &sgl->sg[sgl->list_pos]; 669 if (len < sg->length - sgl->page_pos) 670 to_read = len; 671 else 672 to_read = sg->length - sgl->page_pos; 673 674 ret = ubi_eba_read_leb(ubi, vol, lnum, 675 sg_virt(sg) + sgl->page_pos, offset, 676 to_read, check); 677 if (ret < 0) 678 return ret; 679 680 offset += to_read; 681 len -= to_read; 682 if (!len) { 683 sgl->page_pos += to_read; 684 if (sgl->page_pos == sg->length) { 685 sgl->list_pos++; 686 sgl->page_pos = 0; 687 } 688 689 break; 690 } 691 692 sgl->list_pos++; 693 sgl->page_pos = 0; 694 } 695 696 return ret; 697 } 698 699 /** 700 * try_recover_peb - try to recover from write failure. 701 * @vol: volume description object 702 * @pnum: the physical eraseblock to recover 703 * @lnum: logical eraseblock number 704 * @buf: data which was not written because of the write failure 705 * @offset: offset of the failed write 706 * @len: how many bytes should have been written 707 * @vidb: VID buffer 708 * @retry: whether the caller should retry in case of failure 709 * 710 * This function is called in case of a write failure and moves all good data 711 * from the potentially bad physical eraseblock to a good physical eraseblock. 712 * This function also writes the data which was not written due to the failure. 713 * Returns 0 in case of success, and a negative error code in case of failure. 714 * In case of failure, the %retry parameter is set to false if this is a fatal 715 * error (retrying won't help), and true otherwise. 716 */ 717 static int try_recover_peb(struct ubi_volume *vol, int pnum, int lnum, 718 const void *buf, int offset, int len, 719 struct ubi_vid_io_buf *vidb, bool *retry) 720 { 721 struct ubi_device *ubi = vol->ubi; 722 struct ubi_vid_hdr *vid_hdr; 723 int new_pnum, err, vol_id = vol->vol_id, data_size; 724 uint32_t crc; 725 726 *retry = false; 727 728 new_pnum = ubi_wl_get_peb(ubi); 729 if (new_pnum < 0) { 730 err = new_pnum; 731 goto out_put; 732 } 733 734 ubi_msg(ubi, "recover PEB %d, move data to PEB %d", 735 pnum, new_pnum); 736 737 err = ubi_io_read_vid_hdr(ubi, pnum, vidb, 1); 738 if (err && err != UBI_IO_BITFLIPS) { 739 if (err > 0) 740 err = -EIO; 741 goto out_put; 742 } 743 744 ubi_assert(vid_hdr->vol_type == UBI_VID_DYNAMIC); 745 746 mutex_lock(&ubi->buf_mutex); 747 memset(ubi->peb_buf + offset, 0xFF, len); 748 749 /* Read everything before the area where the write failure happened */ 750 if (offset > 0) { 751 err = ubi_io_read_data(ubi, ubi->peb_buf, pnum, 0, offset); 752 if (err && err != UBI_IO_BITFLIPS) 753 goto out_unlock; 754 } 755 756 *retry = true; 757 758 memcpy(ubi->peb_buf + offset, buf, len); 759 760 data_size = offset + len; 761 crc = crc32(UBI_CRC32_INIT, ubi->peb_buf, data_size); 762 vid_hdr->sqnum = cpu_to_be64(ubi_next_sqnum(ubi)); 763 vid_hdr->copy_flag = 1; 764 vid_hdr->data_size = cpu_to_be32(data_size); 765 vid_hdr->data_crc = cpu_to_be32(crc); 766 err = ubi_io_write_vid_hdr(ubi, new_pnum, vidb); 767 if (err) 768 goto out_unlock; 769 770 err = ubi_io_write_data(ubi, ubi->peb_buf, new_pnum, 0, data_size); 771 772 out_unlock: 773 mutex_unlock(&ubi->buf_mutex); 774 775 if (!err) 776 vol->eba_tbl->entries[lnum].pnum = new_pnum; 777 778 out_put: 779 up_read(&ubi->fm_eba_sem); 780 781 if (!err) { 782 ubi_wl_put_peb(ubi, vol_id, lnum, pnum, 1); 783 ubi_msg(ubi, "data was successfully recovered"); 784 } else if (new_pnum >= 0) { 785 /* 786 * Bad luck? This physical eraseblock is bad too? Crud. Let's 787 * try to get another one. 788 */ 789 ubi_wl_put_peb(ubi, vol_id, lnum, new_pnum, 1); 790 ubi_warn(ubi, "failed to write to PEB %d", new_pnum); 791 } 792 793 return err; 794 } 795 796 /** 797 * recover_peb - recover from write failure. 798 * @ubi: UBI device description object 799 * @pnum: the physical eraseblock to recover 800 * @vol_id: volume ID 801 * @lnum: logical eraseblock number 802 * @buf: data which was not written because of the write failure 803 * @offset: offset of the failed write 804 * @len: how many bytes should have been written 805 * 806 * This function is called in case of a write failure and moves all good data 807 * from the potentially bad physical eraseblock to a good physical eraseblock. 808 * This function also writes the data which was not written due to the failure. 809 * Returns 0 in case of success, and a negative error code in case of failure. 810 * This function tries %UBI_IO_RETRIES before giving up. 811 */ 812 static int recover_peb(struct ubi_device *ubi, int pnum, int vol_id, int lnum, 813 const void *buf, int offset, int len) 814 { 815 int err, idx = vol_id2idx(ubi, vol_id), tries; 816 struct ubi_volume *vol = ubi->volumes[idx]; 817 struct ubi_vid_io_buf *vidb; 818 819 vidb = ubi_alloc_vid_buf(ubi, GFP_NOFS); 820 if (!vidb) 821 return -ENOMEM; 822 823 for (tries = 0; tries <= UBI_IO_RETRIES; tries++) { 824 bool retry; 825 826 err = try_recover_peb(vol, pnum, lnum, buf, offset, len, vidb, 827 &retry); 828 if (!err || !retry) 829 break; 830 831 ubi_msg(ubi, "try again"); 832 } 833 834 ubi_free_vid_buf(vidb); 835 836 return err; 837 } 838 839 /** 840 * try_write_vid_and_data - try to write VID header and data to a new PEB. 841 * @vol: volume description object 842 * @lnum: logical eraseblock number 843 * @vidb: the VID buffer to write 844 * @buf: buffer containing the data 845 * @offset: where to start writing data 846 * @len: how many bytes should be written 847 * 848 * This function tries to write VID header and data belonging to logical 849 * eraseblock @lnum of volume @vol to a new physical eraseblock. Returns zero 850 * in case of success and a negative error code in case of failure. 851 * In case of error, it is possible that something was still written to the 852 * flash media, but may be some garbage. 853 */ 854 static int try_write_vid_and_data(struct ubi_volume *vol, int lnum, 855 struct ubi_vid_io_buf *vidb, const void *buf, 856 int offset, int len) 857 { 858 struct ubi_device *ubi = vol->ubi; 859 int pnum, opnum, err, vol_id = vol->vol_id; 860 861 pnum = ubi_wl_get_peb(ubi); 862 if (pnum < 0) { 863 err = pnum; 864 goto out_put; 865 } 866 867 opnum = vol->eba_tbl->entries[lnum].pnum; 868 869 dbg_eba("write VID hdr and %d bytes at offset %d of LEB %d:%d, PEB %d", 870 len, offset, vol_id, lnum, pnum); 871 872 err = ubi_io_write_vid_hdr(ubi, pnum, vidb); 873 if (err) { 874 ubi_warn(ubi, "failed to write VID header to LEB %d:%d, PEB %d", 875 vol_id, lnum, pnum); 876 goto out_put; 877 } 878 879 if (len) { 880 err = ubi_io_write_data(ubi, buf, pnum, offset, len); 881 if (err) { 882 ubi_warn(ubi, 883 "failed to write %d bytes at offset %d of LEB %d:%d, PEB %d", 884 len, offset, vol_id, lnum, pnum); 885 goto out_put; 886 } 887 } 888 889 vol->eba_tbl->entries[lnum].pnum = pnum; 890 891 out_put: 892 up_read(&ubi->fm_eba_sem); 893 894 if (err && pnum >= 0) 895 err = ubi_wl_put_peb(ubi, vol_id, lnum, pnum, 1); 896 else if (!err && opnum >= 0) 897 err = ubi_wl_put_peb(ubi, vol_id, lnum, opnum, 0); 898 899 return err; 900 } 901 902 /** 903 * ubi_eba_write_leb - write data to dynamic volume. 904 * @ubi: UBI device description object 905 * @vol: volume description object 906 * @lnum: logical eraseblock number 907 * @buf: the data to write 908 * @offset: offset within the logical eraseblock where to write 909 * @len: how many bytes to write 910 * 911 * This function writes data to logical eraseblock @lnum of a dynamic volume 912 * @vol. Returns zero in case of success and a negative error code in case 913 * of failure. In case of error, it is possible that something was still 914 * written to the flash media, but may be some garbage. 915 * This function retries %UBI_IO_RETRIES times before giving up. 916 */ 917 int ubi_eba_write_leb(struct ubi_device *ubi, struct ubi_volume *vol, int lnum, 918 const void *buf, int offset, int len) 919 { 920 int err, pnum, tries, vol_id = vol->vol_id; 921 struct ubi_vid_io_buf *vidb; 922 struct ubi_vid_hdr *vid_hdr; 923 924 if (ubi->ro_mode) 925 return -EROFS; 926 927 err = leb_write_lock(ubi, vol_id, lnum); 928 if (err) 929 return err; 930 931 pnum = vol->eba_tbl->entries[lnum].pnum; 932 if (pnum >= 0) { 933 dbg_eba("write %d bytes at offset %d of LEB %d:%d, PEB %d", 934 len, offset, vol_id, lnum, pnum); 935 936 err = ubi_io_write_data(ubi, buf, pnum, offset, len); 937 if (err) { 938 ubi_warn(ubi, "failed to write data to PEB %d", pnum); 939 if (err == -EIO && ubi->bad_allowed) 940 err = recover_peb(ubi, pnum, vol_id, lnum, buf, 941 offset, len); 942 } 943 944 goto out; 945 } 946 947 /* 948 * The logical eraseblock is not mapped. We have to get a free physical 949 * eraseblock and write the volume identifier header there first. 950 */ 951 vidb = ubi_alloc_vid_buf(ubi, GFP_NOFS); 952 if (!vidb) { 953 leb_write_unlock(ubi, vol_id, lnum); 954 return -ENOMEM; 955 } 956 957 vid_hdr = ubi_get_vid_hdr(vidb); 958 959 vid_hdr->vol_type = UBI_VID_DYNAMIC; 960 vid_hdr->sqnum = cpu_to_be64(ubi_next_sqnum(ubi)); 961 vid_hdr->vol_id = cpu_to_be32(vol_id); 962 vid_hdr->lnum = cpu_to_be32(lnum); 963 vid_hdr->compat = ubi_get_compat(ubi, vol_id); 964 vid_hdr->data_pad = cpu_to_be32(vol->data_pad); 965 966 for (tries = 0; tries <= UBI_IO_RETRIES; tries++) { 967 err = try_write_vid_and_data(vol, lnum, vidb, buf, offset, len); 968 if (err != -EIO || !ubi->bad_allowed) 969 break; 970 971 /* 972 * Fortunately, this is the first write operation to this 973 * physical eraseblock, so just put it and request a new one. 974 * We assume that if this physical eraseblock went bad, the 975 * erase code will handle that. 976 */ 977 vid_hdr->sqnum = cpu_to_be64(ubi_next_sqnum(ubi)); 978 ubi_msg(ubi, "try another PEB"); 979 } 980 981 ubi_free_vid_buf(vidb); 982 983 out: 984 if (err) 985 ubi_ro_mode(ubi); 986 987 leb_write_unlock(ubi, vol_id, lnum); 988 989 return err; 990 } 991 992 /** 993 * ubi_eba_write_leb_st - write data to static volume. 994 * @ubi: UBI device description object 995 * @vol: volume description object 996 * @lnum: logical eraseblock number 997 * @buf: data to write 998 * @len: how many bytes to write 999 * @used_ebs: how many logical eraseblocks will this volume contain 1000 * 1001 * This function writes data to logical eraseblock @lnum of static volume 1002 * @vol. The @used_ebs argument should contain total number of logical 1003 * eraseblock in this static volume. 1004 * 1005 * When writing to the last logical eraseblock, the @len argument doesn't have 1006 * to be aligned to the minimal I/O unit size. Instead, it has to be equivalent 1007 * to the real data size, although the @buf buffer has to contain the 1008 * alignment. In all other cases, @len has to be aligned. 1009 * 1010 * It is prohibited to write more than once to logical eraseblocks of static 1011 * volumes. This function returns zero in case of success and a negative error 1012 * code in case of failure. 1013 */ 1014 int ubi_eba_write_leb_st(struct ubi_device *ubi, struct ubi_volume *vol, 1015 int lnum, const void *buf, int len, int used_ebs) 1016 { 1017 int err, tries, data_size = len, vol_id = vol->vol_id; 1018 struct ubi_vid_io_buf *vidb; 1019 struct ubi_vid_hdr *vid_hdr; 1020 uint32_t crc; 1021 1022 if (ubi->ro_mode) 1023 return -EROFS; 1024 1025 if (lnum == used_ebs - 1) 1026 /* If this is the last LEB @len may be unaligned */ 1027 len = ALIGN(data_size, ubi->min_io_size); 1028 else 1029 ubi_assert(!(len & (ubi->min_io_size - 1))); 1030 1031 vidb = ubi_alloc_vid_buf(ubi, GFP_NOFS); 1032 if (!vidb) 1033 return -ENOMEM; 1034 1035 vid_hdr = ubi_get_vid_hdr(vidb); 1036 1037 err = leb_write_lock(ubi, vol_id, lnum); 1038 if (err) 1039 goto out; 1040 1041 vid_hdr->sqnum = cpu_to_be64(ubi_next_sqnum(ubi)); 1042 vid_hdr->vol_id = cpu_to_be32(vol_id); 1043 vid_hdr->lnum = cpu_to_be32(lnum); 1044 vid_hdr->compat = ubi_get_compat(ubi, vol_id); 1045 vid_hdr->data_pad = cpu_to_be32(vol->data_pad); 1046 1047 crc = crc32(UBI_CRC32_INIT, buf, data_size); 1048 vid_hdr->vol_type = UBI_VID_STATIC; 1049 vid_hdr->data_size = cpu_to_be32(data_size); 1050 vid_hdr->used_ebs = cpu_to_be32(used_ebs); 1051 vid_hdr->data_crc = cpu_to_be32(crc); 1052 1053 ubi_assert(vol->eba_tbl->entries[lnum].pnum < 0); 1054 1055 for (tries = 0; tries <= UBI_IO_RETRIES; tries++) { 1056 err = try_write_vid_and_data(vol, lnum, vidb, buf, 0, len); 1057 if (err != -EIO || !ubi->bad_allowed) 1058 break; 1059 1060 vid_hdr->sqnum = cpu_to_be64(ubi_next_sqnum(ubi)); 1061 ubi_msg(ubi, "try another PEB"); 1062 } 1063 1064 if (err) 1065 ubi_ro_mode(ubi); 1066 1067 leb_write_unlock(ubi, vol_id, lnum); 1068 1069 out: 1070 ubi_free_vid_buf(vidb); 1071 1072 return err; 1073 } 1074 1075 /* 1076 * ubi_eba_atomic_leb_change - change logical eraseblock atomically. 1077 * @ubi: UBI device description object 1078 * @vol: volume description object 1079 * @lnum: logical eraseblock number 1080 * @buf: data to write 1081 * @len: how many bytes to write 1082 * 1083 * This function changes the contents of a logical eraseblock atomically. @buf 1084 * has to contain new logical eraseblock data, and @len - the length of the 1085 * data, which has to be aligned. This function guarantees that in case of an 1086 * unclean reboot the old contents is preserved. Returns zero in case of 1087 * success and a negative error code in case of failure. 1088 * 1089 * UBI reserves one LEB for the "atomic LEB change" operation, so only one 1090 * LEB change may be done at a time. This is ensured by @ubi->alc_mutex. 1091 */ 1092 int ubi_eba_atomic_leb_change(struct ubi_device *ubi, struct ubi_volume *vol, 1093 int lnum, const void *buf, int len) 1094 { 1095 int err, tries, vol_id = vol->vol_id; 1096 struct ubi_vid_io_buf *vidb; 1097 struct ubi_vid_hdr *vid_hdr; 1098 uint32_t crc; 1099 1100 if (ubi->ro_mode) 1101 return -EROFS; 1102 1103 if (len == 0) { 1104 /* 1105 * Special case when data length is zero. In this case the LEB 1106 * has to be unmapped and mapped somewhere else. 1107 */ 1108 err = ubi_eba_unmap_leb(ubi, vol, lnum); 1109 if (err) 1110 return err; 1111 return ubi_eba_write_leb(ubi, vol, lnum, NULL, 0, 0); 1112 } 1113 1114 vidb = ubi_alloc_vid_buf(ubi, GFP_NOFS); 1115 if (!vidb) 1116 return -ENOMEM; 1117 1118 vid_hdr = ubi_get_vid_hdr(vidb); 1119 1120 mutex_lock(&ubi->alc_mutex); 1121 err = leb_write_lock(ubi, vol_id, lnum); 1122 if (err) 1123 goto out_mutex; 1124 1125 vid_hdr->sqnum = cpu_to_be64(ubi_next_sqnum(ubi)); 1126 vid_hdr->vol_id = cpu_to_be32(vol_id); 1127 vid_hdr->lnum = cpu_to_be32(lnum); 1128 vid_hdr->compat = ubi_get_compat(ubi, vol_id); 1129 vid_hdr->data_pad = cpu_to_be32(vol->data_pad); 1130 1131 crc = crc32(UBI_CRC32_INIT, buf, len); 1132 vid_hdr->vol_type = UBI_VID_DYNAMIC; 1133 vid_hdr->data_size = cpu_to_be32(len); 1134 vid_hdr->copy_flag = 1; 1135 vid_hdr->data_crc = cpu_to_be32(crc); 1136 1137 dbg_eba("change LEB %d:%d", vol_id, lnum); 1138 1139 for (tries = 0; tries <= UBI_IO_RETRIES; tries++) { 1140 err = try_write_vid_and_data(vol, lnum, vidb, buf, 0, len); 1141 if (err != -EIO || !ubi->bad_allowed) 1142 break; 1143 1144 vid_hdr->sqnum = cpu_to_be64(ubi_next_sqnum(ubi)); 1145 ubi_msg(ubi, "try another PEB"); 1146 } 1147 1148 /* 1149 * This flash device does not admit of bad eraseblocks or 1150 * something nasty and unexpected happened. Switch to read-only 1151 * mode just in case. 1152 */ 1153 if (err) 1154 ubi_ro_mode(ubi); 1155 1156 leb_write_unlock(ubi, vol_id, lnum); 1157 1158 out_mutex: 1159 mutex_unlock(&ubi->alc_mutex); 1160 ubi_free_vid_buf(vidb); 1161 return err; 1162 } 1163 1164 /** 1165 * is_error_sane - check whether a read error is sane. 1166 * @err: code of the error happened during reading 1167 * 1168 * This is a helper function for 'ubi_eba_copy_leb()' which is called when we 1169 * cannot read data from the target PEB (an error @err happened). If the error 1170 * code is sane, then we treat this error as non-fatal. Otherwise the error is 1171 * fatal and UBI will be switched to R/O mode later. 1172 * 1173 * The idea is that we try not to switch to R/O mode if the read error is 1174 * something which suggests there was a real read problem. E.g., %-EIO. Or a 1175 * memory allocation failed (-%ENOMEM). Otherwise, it is safer to switch to R/O 1176 * mode, simply because we do not know what happened at the MTD level, and we 1177 * cannot handle this. E.g., the underlying driver may have become crazy, and 1178 * it is safer to switch to R/O mode to preserve the data. 1179 * 1180 * And bear in mind, this is about reading from the target PEB, i.e. the PEB 1181 * which we have just written. 1182 */ 1183 static int is_error_sane(int err) 1184 { 1185 if (err == -EIO || err == -ENOMEM || err == UBI_IO_BAD_HDR || 1186 err == UBI_IO_BAD_HDR_EBADMSG || err == -ETIMEDOUT) 1187 return 0; 1188 return 1; 1189 } 1190 1191 /** 1192 * ubi_eba_copy_leb - copy logical eraseblock. 1193 * @ubi: UBI device description object 1194 * @from: physical eraseblock number from where to copy 1195 * @to: physical eraseblock number where to copy 1196 * @vid_hdr: VID header of the @from physical eraseblock 1197 * 1198 * This function copies logical eraseblock from physical eraseblock @from to 1199 * physical eraseblock @to. The @vid_hdr buffer may be changed by this 1200 * function. Returns: 1201 * o %0 in case of success; 1202 * o %MOVE_CANCEL_RACE, %MOVE_TARGET_WR_ERR, %MOVE_TARGET_BITFLIPS, etc; 1203 * o a negative error code in case of failure. 1204 */ 1205 int ubi_eba_copy_leb(struct ubi_device *ubi, int from, int to, 1206 struct ubi_vid_io_buf *vidb) 1207 { 1208 int err, vol_id, lnum, data_size, aldata_size, idx; 1209 struct ubi_vid_hdr *vid_hdr = ubi_get_vid_hdr(vidb); 1210 struct ubi_volume *vol; 1211 uint32_t crc; 1212 1213 ubi_assert(rwsem_is_locked(&ubi->fm_eba_sem)); 1214 1215 vol_id = be32_to_cpu(vid_hdr->vol_id); 1216 lnum = be32_to_cpu(vid_hdr->lnum); 1217 1218 dbg_wl("copy LEB %d:%d, PEB %d to PEB %d", vol_id, lnum, from, to); 1219 1220 if (vid_hdr->vol_type == UBI_VID_STATIC) { 1221 data_size = be32_to_cpu(vid_hdr->data_size); 1222 aldata_size = ALIGN(data_size, ubi->min_io_size); 1223 } else 1224 data_size = aldata_size = 1225 ubi->leb_size - be32_to_cpu(vid_hdr->data_pad); 1226 1227 idx = vol_id2idx(ubi, vol_id); 1228 spin_lock(&ubi->volumes_lock); 1229 /* 1230 * Note, we may race with volume deletion, which means that the volume 1231 * this logical eraseblock belongs to might be being deleted. Since the 1232 * volume deletion un-maps all the volume's logical eraseblocks, it will 1233 * be locked in 'ubi_wl_put_peb()' and wait for the WL worker to finish. 1234 */ 1235 vol = ubi->volumes[idx]; 1236 spin_unlock(&ubi->volumes_lock); 1237 if (!vol) { 1238 /* No need to do further work, cancel */ 1239 dbg_wl("volume %d is being removed, cancel", vol_id); 1240 return MOVE_CANCEL_RACE; 1241 } 1242 1243 /* 1244 * We do not want anybody to write to this logical eraseblock while we 1245 * are moving it, so lock it. 1246 * 1247 * Note, we are using non-waiting locking here, because we cannot sleep 1248 * on the LEB, since it may cause deadlocks. Indeed, imagine a task is 1249 * unmapping the LEB which is mapped to the PEB we are going to move 1250 * (@from). This task locks the LEB and goes sleep in the 1251 * 'ubi_wl_put_peb()' function on the @ubi->move_mutex. In turn, we are 1252 * holding @ubi->move_mutex and go sleep on the LEB lock. So, if the 1253 * LEB is already locked, we just do not move it and return 1254 * %MOVE_RETRY. Note, we do not return %MOVE_CANCEL_RACE here because 1255 * we do not know the reasons of the contention - it may be just a 1256 * normal I/O on this LEB, so we want to re-try. 1257 */ 1258 err = leb_write_trylock(ubi, vol_id, lnum); 1259 if (err) { 1260 dbg_wl("contention on LEB %d:%d, cancel", vol_id, lnum); 1261 return MOVE_RETRY; 1262 } 1263 1264 /* 1265 * The LEB might have been put meanwhile, and the task which put it is 1266 * probably waiting on @ubi->move_mutex. No need to continue the work, 1267 * cancel it. 1268 */ 1269 if (vol->eba_tbl->entries[lnum].pnum != from) { 1270 dbg_wl("LEB %d:%d is no longer mapped to PEB %d, mapped to PEB %d, cancel", 1271 vol_id, lnum, from, vol->eba_tbl->entries[lnum].pnum); 1272 err = MOVE_CANCEL_RACE; 1273 goto out_unlock_leb; 1274 } 1275 1276 /* 1277 * OK, now the LEB is locked and we can safely start moving it. Since 1278 * this function utilizes the @ubi->peb_buf buffer which is shared 1279 * with some other functions - we lock the buffer by taking the 1280 * @ubi->buf_mutex. 1281 */ 1282 mutex_lock(&ubi->buf_mutex); 1283 dbg_wl("read %d bytes of data", aldata_size); 1284 err = ubi_io_read_data(ubi, ubi->peb_buf, from, 0, aldata_size); 1285 if (err && err != UBI_IO_BITFLIPS) { 1286 ubi_warn(ubi, "error %d while reading data from PEB %d", 1287 err, from); 1288 err = MOVE_SOURCE_RD_ERR; 1289 goto out_unlock_buf; 1290 } 1291 1292 /* 1293 * Now we have got to calculate how much data we have to copy. In 1294 * case of a static volume it is fairly easy - the VID header contains 1295 * the data size. In case of a dynamic volume it is more difficult - we 1296 * have to read the contents, cut 0xFF bytes from the end and copy only 1297 * the first part. We must do this to avoid writing 0xFF bytes as it 1298 * may have some side-effects. And not only this. It is important not 1299 * to include those 0xFFs to CRC because later the they may be filled 1300 * by data. 1301 */ 1302 if (vid_hdr->vol_type == UBI_VID_DYNAMIC) 1303 aldata_size = data_size = 1304 ubi_calc_data_len(ubi, ubi->peb_buf, data_size); 1305 1306 cond_resched(); 1307 crc = crc32(UBI_CRC32_INIT, ubi->peb_buf, data_size); 1308 cond_resched(); 1309 1310 /* 1311 * It may turn out to be that the whole @from physical eraseblock 1312 * contains only 0xFF bytes. Then we have to only write the VID header 1313 * and do not write any data. This also means we should not set 1314 * @vid_hdr->copy_flag, @vid_hdr->data_size, and @vid_hdr->data_crc. 1315 */ 1316 if (data_size > 0) { 1317 vid_hdr->copy_flag = 1; 1318 vid_hdr->data_size = cpu_to_be32(data_size); 1319 vid_hdr->data_crc = cpu_to_be32(crc); 1320 } 1321 vid_hdr->sqnum = cpu_to_be64(ubi_next_sqnum(ubi)); 1322 1323 err = ubi_io_write_vid_hdr(ubi, to, vidb); 1324 if (err) { 1325 if (err == -EIO) 1326 err = MOVE_TARGET_WR_ERR; 1327 goto out_unlock_buf; 1328 } 1329 1330 cond_resched(); 1331 1332 /* Read the VID header back and check if it was written correctly */ 1333 err = ubi_io_read_vid_hdr(ubi, to, vidb, 1); 1334 if (err) { 1335 if (err != UBI_IO_BITFLIPS) { 1336 ubi_warn(ubi, "error %d while reading VID header back from PEB %d", 1337 err, to); 1338 if (is_error_sane(err)) 1339 err = MOVE_TARGET_RD_ERR; 1340 } else 1341 err = MOVE_TARGET_BITFLIPS; 1342 goto out_unlock_buf; 1343 } 1344 1345 if (data_size > 0) { 1346 err = ubi_io_write_data(ubi, ubi->peb_buf, to, 0, aldata_size); 1347 if (err) { 1348 if (err == -EIO) 1349 err = MOVE_TARGET_WR_ERR; 1350 goto out_unlock_buf; 1351 } 1352 1353 cond_resched(); 1354 } 1355 1356 ubi_assert(vol->eba_tbl->entries[lnum].pnum == from); 1357 vol->eba_tbl->entries[lnum].pnum = to; 1358 1359 out_unlock_buf: 1360 mutex_unlock(&ubi->buf_mutex); 1361 out_unlock_leb: 1362 leb_write_unlock(ubi, vol_id, lnum); 1363 return err; 1364 } 1365 1366 /** 1367 * print_rsvd_warning - warn about not having enough reserved PEBs. 1368 * @ubi: UBI device description object 1369 * 1370 * This is a helper function for 'ubi_eba_init()' which is called when UBI 1371 * cannot reserve enough PEBs for bad block handling. This function makes a 1372 * decision whether we have to print a warning or not. The algorithm is as 1373 * follows: 1374 * o if this is a new UBI image, then just print the warning 1375 * o if this is an UBI image which has already been used for some time, print 1376 * a warning only if we can reserve less than 10% of the expected amount of 1377 * the reserved PEB. 1378 * 1379 * The idea is that when UBI is used, PEBs become bad, and the reserved pool 1380 * of PEBs becomes smaller, which is normal and we do not want to scare users 1381 * with a warning every time they attach the MTD device. This was an issue 1382 * reported by real users. 1383 */ 1384 static void print_rsvd_warning(struct ubi_device *ubi, 1385 struct ubi_attach_info *ai) 1386 { 1387 /* 1388 * The 1 << 18 (256KiB) number is picked randomly, just a reasonably 1389 * large number to distinguish between newly flashed and used images. 1390 */ 1391 if (ai->max_sqnum > (1 << 18)) { 1392 int min = ubi->beb_rsvd_level / 10; 1393 1394 if (!min) 1395 min = 1; 1396 if (ubi->beb_rsvd_pebs > min) 1397 return; 1398 } 1399 1400 ubi_warn(ubi, "cannot reserve enough PEBs for bad PEB handling, reserved %d, need %d", 1401 ubi->beb_rsvd_pebs, ubi->beb_rsvd_level); 1402 if (ubi->corr_peb_count) 1403 ubi_warn(ubi, "%d PEBs are corrupted and not used", 1404 ubi->corr_peb_count); 1405 } 1406 1407 /** 1408 * self_check_eba - run a self check on the EBA table constructed by fastmap. 1409 * @ubi: UBI device description object 1410 * @ai_fastmap: UBI attach info object created by fastmap 1411 * @ai_scan: UBI attach info object created by scanning 1412 * 1413 * Returns < 0 in case of an internal error, 0 otherwise. 1414 * If a bad EBA table entry was found it will be printed out and 1415 * ubi_assert() triggers. 1416 */ 1417 int self_check_eba(struct ubi_device *ubi, struct ubi_attach_info *ai_fastmap, 1418 struct ubi_attach_info *ai_scan) 1419 { 1420 int i, j, num_volumes, ret = 0; 1421 int **scan_eba, **fm_eba; 1422 struct ubi_ainf_volume *av; 1423 struct ubi_volume *vol; 1424 struct ubi_ainf_peb *aeb; 1425 struct rb_node *rb; 1426 1427 num_volumes = ubi->vtbl_slots + UBI_INT_VOL_COUNT; 1428 1429 scan_eba = kmalloc(sizeof(*scan_eba) * num_volumes, GFP_KERNEL); 1430 if (!scan_eba) 1431 return -ENOMEM; 1432 1433 fm_eba = kmalloc(sizeof(*fm_eba) * num_volumes, GFP_KERNEL); 1434 if (!fm_eba) { 1435 kfree(scan_eba); 1436 return -ENOMEM; 1437 } 1438 1439 for (i = 0; i < num_volumes; i++) { 1440 vol = ubi->volumes[i]; 1441 if (!vol) 1442 continue; 1443 1444 scan_eba[i] = kmalloc(vol->reserved_pebs * sizeof(**scan_eba), 1445 GFP_KERNEL); 1446 if (!scan_eba[i]) { 1447 ret = -ENOMEM; 1448 goto out_free; 1449 } 1450 1451 fm_eba[i] = kmalloc(vol->reserved_pebs * sizeof(**fm_eba), 1452 GFP_KERNEL); 1453 if (!fm_eba[i]) { 1454 ret = -ENOMEM; 1455 goto out_free; 1456 } 1457 1458 for (j = 0; j < vol->reserved_pebs; j++) 1459 scan_eba[i][j] = fm_eba[i][j] = UBI_LEB_UNMAPPED; 1460 1461 av = ubi_find_av(ai_scan, idx2vol_id(ubi, i)); 1462 if (!av) 1463 continue; 1464 1465 ubi_rb_for_each_entry(rb, aeb, &av->root, u.rb) 1466 scan_eba[i][aeb->lnum] = aeb->pnum; 1467 1468 av = ubi_find_av(ai_fastmap, idx2vol_id(ubi, i)); 1469 if (!av) 1470 continue; 1471 1472 ubi_rb_for_each_entry(rb, aeb, &av->root, u.rb) 1473 fm_eba[i][aeb->lnum] = aeb->pnum; 1474 1475 for (j = 0; j < vol->reserved_pebs; j++) { 1476 if (scan_eba[i][j] != fm_eba[i][j]) { 1477 if (scan_eba[i][j] == UBI_LEB_UNMAPPED || 1478 fm_eba[i][j] == UBI_LEB_UNMAPPED) 1479 continue; 1480 1481 ubi_err(ubi, "LEB:%i:%i is PEB:%i instead of %i!", 1482 vol->vol_id, j, fm_eba[i][j], 1483 scan_eba[i][j]); 1484 ubi_assert(0); 1485 } 1486 } 1487 } 1488 1489 out_free: 1490 for (i = 0; i < num_volumes; i++) { 1491 if (!ubi->volumes[i]) 1492 continue; 1493 1494 kfree(scan_eba[i]); 1495 kfree(fm_eba[i]); 1496 } 1497 1498 kfree(scan_eba); 1499 kfree(fm_eba); 1500 return ret; 1501 } 1502 1503 /** 1504 * ubi_eba_init - initialize the EBA sub-system using attaching information. 1505 * @ubi: UBI device description object 1506 * @ai: attaching information 1507 * 1508 * This function returns zero in case of success and a negative error code in 1509 * case of failure. 1510 */ 1511 int ubi_eba_init(struct ubi_device *ubi, struct ubi_attach_info *ai) 1512 { 1513 int i, err, num_volumes; 1514 struct ubi_ainf_volume *av; 1515 struct ubi_volume *vol; 1516 struct ubi_ainf_peb *aeb; 1517 struct rb_node *rb; 1518 1519 dbg_eba("initialize EBA sub-system"); 1520 1521 spin_lock_init(&ubi->ltree_lock); 1522 mutex_init(&ubi->alc_mutex); 1523 ubi->ltree = RB_ROOT; 1524 1525 ubi->global_sqnum = ai->max_sqnum + 1; 1526 num_volumes = ubi->vtbl_slots + UBI_INT_VOL_COUNT; 1527 1528 for (i = 0; i < num_volumes; i++) { 1529 struct ubi_eba_table *tbl; 1530 1531 vol = ubi->volumes[i]; 1532 if (!vol) 1533 continue; 1534 1535 cond_resched(); 1536 1537 tbl = ubi_eba_create_table(vol, vol->reserved_pebs); 1538 if (IS_ERR(tbl)) { 1539 err = PTR_ERR(tbl); 1540 goto out_free; 1541 } 1542 1543 ubi_eba_replace_table(vol, tbl); 1544 1545 av = ubi_find_av(ai, idx2vol_id(ubi, i)); 1546 if (!av) 1547 continue; 1548 1549 ubi_rb_for_each_entry(rb, aeb, &av->root, u.rb) { 1550 if (aeb->lnum >= vol->reserved_pebs) { 1551 /* 1552 * This may happen in case of an unclean reboot 1553 * during re-size. 1554 */ 1555 ubi_move_aeb_to_list(av, aeb, &ai->erase); 1556 } else { 1557 struct ubi_eba_entry *entry; 1558 1559 entry = &vol->eba_tbl->entries[aeb->lnum]; 1560 entry->pnum = aeb->pnum; 1561 } 1562 } 1563 } 1564 1565 if (ubi->avail_pebs < EBA_RESERVED_PEBS) { 1566 ubi_err(ubi, "no enough physical eraseblocks (%d, need %d)", 1567 ubi->avail_pebs, EBA_RESERVED_PEBS); 1568 if (ubi->corr_peb_count) 1569 ubi_err(ubi, "%d PEBs are corrupted and not used", 1570 ubi->corr_peb_count); 1571 err = -ENOSPC; 1572 goto out_free; 1573 } 1574 ubi->avail_pebs -= EBA_RESERVED_PEBS; 1575 ubi->rsvd_pebs += EBA_RESERVED_PEBS; 1576 1577 if (ubi->bad_allowed) { 1578 ubi_calculate_reserved(ubi); 1579 1580 if (ubi->avail_pebs < ubi->beb_rsvd_level) { 1581 /* No enough free physical eraseblocks */ 1582 ubi->beb_rsvd_pebs = ubi->avail_pebs; 1583 print_rsvd_warning(ubi, ai); 1584 } else 1585 ubi->beb_rsvd_pebs = ubi->beb_rsvd_level; 1586 1587 ubi->avail_pebs -= ubi->beb_rsvd_pebs; 1588 ubi->rsvd_pebs += ubi->beb_rsvd_pebs; 1589 } 1590 1591 dbg_eba("EBA sub-system is initialized"); 1592 return 0; 1593 1594 out_free: 1595 for (i = 0; i < num_volumes; i++) { 1596 if (!ubi->volumes[i]) 1597 continue; 1598 ubi_eba_replace_table(ubi->volumes[i], NULL); 1599 } 1600 return err; 1601 } 1602