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