UBI: improve internal interfaces · tjh.dev/kernel@89b96b6

+2 -2

drivers/mtd/ubi/build.c

··· 249 249 250 250 for (i = 0; i < ubi->vtbl_slots; i++) 251 251 if (ubi->volumes[i]) 252 - ubi_free_volume(ubi, i); 252 + ubi_free_volume(ubi, ubi->volumes[i]); 253 253 } 254 254 255 255 /** ··· 300 300 301 301 for (i = 0; i < ubi->vtbl_slots; i++) 302 302 if (ubi->volumes[i]) { 303 - err = ubi_add_volume(ubi, i); 303 + err = ubi_add_volume(ubi, ubi->volumes[i]); 304 304 if (err) { 305 305 ubi_err("cannot add volume %d", i); 306 306 goto out_volumes;

+3 -3

drivers/mtd/ubi/cdev.c

··· 249 249 if (off + len >= vol->usable_leb_size) 250 250 len = vol->usable_leb_size - off; 251 251 252 - err = ubi_eba_read_leb(ubi, vol_id, lnum, tbuf, off, len, 0); 252 + err = ubi_eba_read_leb(ubi, vol, lnum, tbuf, off, len, 0); 253 253 if (err) 254 254 break; 255 255 ··· 339 339 break; 340 340 } 341 341 342 - err = ubi_eba_write_leb(ubi, vol_id, lnum, tbuf, off, len, 342 + err = ubi_eba_write_leb(ubi, vol, lnum, tbuf, off, len, 343 343 UBI_UNKNOWN); 344 344 if (err) 345 345 break; ··· 484 484 } 485 485 486 486 dbg_msg("erase LEB %d:%d", vol->vol_id, lnum); 487 - err = ubi_eba_unmap_leb(ubi, vol->vol_id, lnum); 487 + err = ubi_eba_unmap_leb(ubi, vol, lnum); 488 488 if (err) 489 489 break; 490 490

+24 -27

drivers/mtd/ubi/eba.c

··· 289 289 /** 290 290 * ubi_eba_unmap_leb - un-map logical eraseblock. 291 291 * @ubi: UBI device description object 292 - * @vol_id: volume ID 292 + * @vol: volume description object 293 293 * @lnum: logical eraseblock number 294 294 * 295 295 * This function un-maps logical eraseblock @lnum and schedules corresponding 296 296 * physical eraseblock for erasure. Returns zero in case of success and a 297 297 * negative error code in case of failure. 298 298 */ 299 - int ubi_eba_unmap_leb(struct ubi_device *ubi, int vol_id, int lnum) 299 + int ubi_eba_unmap_leb(struct ubi_device *ubi, struct ubi_volume *vol, 300 + int lnum) 300 301 { 301 - int idx = vol_id2idx(ubi, vol_id), err, pnum; 302 - struct ubi_volume *vol = ubi->volumes[idx]; 302 + int err, pnum, vol_id = vol->vol_id; 303 303 304 304 if (ubi->ro_mode) 305 305 return -EROFS; ··· 326 326 /** 327 327 * ubi_eba_read_leb - read data. 328 328 * @ubi: UBI device description object 329 - * @vol_id: volume ID 329 + * @vol: volume description object 330 330 * @lnum: logical eraseblock number 331 331 * @buf: buffer to store the read data 332 332 * @offset: offset from where to read ··· 342 342 * returned for any volume type if an ECC error was detected by the MTD device 343 343 * driver. Other negative error cored may be returned in case of other errors. 344 344 */ 345 - int ubi_eba_read_leb(struct ubi_device *ubi, int vol_id, int lnum, void *buf, 346 - int offset, int len, int check) 345 + int ubi_eba_read_leb(struct ubi_device *ubi, struct ubi_volume *vol, int lnum, 346 + void *buf, int offset, int len, int check) 347 347 { 348 - int err, pnum, scrub = 0, idx = vol_id2idx(ubi, vol_id); 348 + int err, pnum, scrub = 0, vol_id = vol->vol_id; 349 349 struct ubi_vid_hdr *vid_hdr; 350 - struct ubi_volume *vol = ubi->volumes[idx]; 351 350 uint32_t uninitialized_var(crc); 352 351 353 352 err = leb_read_lock(ubi, vol_id, lnum); ··· 554 555 /** 555 556 * ubi_eba_write_leb - write data to dynamic volume. 556 557 * @ubi: UBI device description object 557 - * @vol_id: volume ID 558 + * @vol: volume description object 558 559 * @lnum: logical eraseblock number 559 560 * @buf: the data to write 560 561 * @offset: offset within the logical eraseblock where to write ··· 562 563 * @dtype: data type 563 564 * 564 565 * This function writes data to logical eraseblock @lnum of a dynamic volume 565 - * @vol_id. Returns zero in case of success and a negative error code in case 566 + * @vol. Returns zero in case of success and a negative error code in case 566 567 * of failure. In case of error, it is possible that something was still 567 568 * written to the flash media, but may be some garbage. 568 569 */ 569 - int ubi_eba_write_leb(struct ubi_device *ubi, int vol_id, int lnum, 570 + int ubi_eba_write_leb(struct ubi_device *ubi, struct ubi_volume *vol, int lnum, 570 571 const void *buf, int offset, int len, int dtype) 571 572 { 572 - int idx = vol_id2idx(ubi, vol_id), err, pnum, tries = 0; 573 - struct ubi_volume *vol = ubi->volumes[idx]; 573 + int err, pnum, tries = 0, vol_id = vol->vol_id; 574 574 struct ubi_vid_hdr *vid_hdr; 575 575 576 576 if (ubi->ro_mode) ··· 588 590 if (err) { 589 591 ubi_warn("failed to write data to PEB %d", pnum); 590 592 if (err == -EIO && ubi->bad_allowed) 591 - err = recover_peb(ubi, pnum, vol_id, lnum, buf, offset, len); 593 + err = recover_peb(ubi, pnum, vol_id, lnum, buf, 594 + offset, len); 592 595 if (err) 593 596 ubi_ro_mode(ubi); 594 597 } ··· 677 678 /** 678 679 * ubi_eba_write_leb_st - write data to static volume. 679 680 * @ubi: UBI device description object 680 - * @vol_id: volume ID 681 + * @vol: volume description object 681 682 * @lnum: logical eraseblock number 682 683 * @buf: data to write 683 684 * @len: how many bytes to write ··· 685 686 * @used_ebs: how many logical eraseblocks will this volume contain 686 687 * 687 688 * This function writes data to logical eraseblock @lnum of static volume 688 - * @vol_id. The @used_ebs argument should contain total number of logical 689 + * @vol. The @used_ebs argument should contain total number of logical 689 690 * eraseblock in this static volume. 690 691 * 691 692 * When writing to the last logical eraseblock, the @len argument doesn't have ··· 697 698 * volumes. This function returns zero in case of success and a negative error 698 699 * code in case of failure. 699 700 */ 700 - int ubi_eba_write_leb_st(struct ubi_device *ubi, int vol_id, int lnum, 701 - const void *buf, int len, int dtype, int used_ebs) 701 + int ubi_eba_write_leb_st(struct ubi_device *ubi, struct ubi_volume *vol, 702 + int lnum, const void *buf, int len, int dtype, 703 + int used_ebs) 702 704 { 703 - int err, pnum, tries = 0, data_size = len; 704 - int idx = vol_id2idx(ubi, vol_id); 705 - struct ubi_volume *vol = ubi->volumes[idx]; 705 + int err, pnum, tries = 0, data_size = len, vol_id = vol->vol_id; 706 706 struct ubi_vid_hdr *vid_hdr; 707 707 uint32_t crc; 708 708 ··· 797 799 /* 798 800 * ubi_eba_atomic_leb_change - change logical eraseblock atomically. 799 801 * @ubi: UBI device description object 800 - * @vol_id: volume ID 802 + * @vol: volume escription object 801 803 * @lnum: logical eraseblock number 802 804 * @buf: data to write 803 805 * @len: how many bytes to write ··· 812 814 * UBI reserves one LEB for the "atomic LEB change" operation, so only one 813 815 * LEB change may be done at a time. This is ensured by @ubi->alc_mutex. 814 816 */ 815 - int ubi_eba_atomic_leb_change(struct ubi_device *ubi, int vol_id, int lnum, 816 - const void *buf, int len, int dtype) 817 + int ubi_eba_atomic_leb_change(struct ubi_device *ubi, struct ubi_volume *vol, 818 + int lnum, const void *buf, int len, int dtype) 817 819 { 818 - int err, pnum, tries = 0, idx = vol_id2idx(ubi, vol_id); 819 - struct ubi_volume *vol = ubi->volumes[idx]; 820 + int err, pnum, tries = 0, vol_id = vol->vol_id; 820 821 struct ubi_vid_hdr *vid_hdr; 821 822 uint32_t crc; 822 823

+4 -5

drivers/mtd/ubi/gluebi.c

··· 129 129 if (to_read > total_read) 130 130 to_read = total_read; 131 131 132 - err = ubi_eba_read_leb(ubi, vol->vol_id, lnum, buf, offs, 133 - to_read, 0); 132 + err = ubi_eba_read_leb(ubi, vol, lnum, buf, offs, to_read, 0); 134 133 if (err) 135 134 break; 136 135 ··· 186 187 if (to_write > total_written) 187 188 to_write = total_written; 188 189 189 - err = ubi_eba_write_leb(ubi, vol->vol_id, lnum, buf, offs, 190 - to_write, UBI_UNKNOWN); 190 + err = ubi_eba_write_leb(ubi, vol, lnum, buf, offs, to_write, 191 + UBI_UNKNOWN); 191 192 if (err) 192 193 break; 193 194 ··· 236 237 return -EROFS; 237 238 238 239 for (i = 0; i < count; i++) { 239 - err = ubi_eba_unmap_leb(ubi, vol->vol_id, lnum + i); 240 + err = ubi_eba_unmap_leb(ubi, vol, lnum + i); 240 241 if (err) 241 242 goto out_err; 242 243 }

+6 -6

drivers/mtd/ubi/kapi.c

··· 332 332 if (len == 0) 333 333 return 0; 334 334 335 - err = ubi_eba_read_leb(ubi, vol_id, lnum, buf, offset, len, check); 335 + err = ubi_eba_read_leb(ubi, vol, lnum, buf, offset, len, check); 336 336 if (err && err == -EBADMSG && vol->vol_type == UBI_STATIC_VOLUME) { 337 337 ubi_warn("mark volume %d as corrupted", vol_id); 338 338 vol->corrupted = 1; ··· 399 399 if (len == 0) 400 400 return 0; 401 401 402 - return ubi_eba_write_leb(ubi, vol_id, lnum, buf, offset, len, dtype); 402 + return ubi_eba_write_leb(ubi, vol, lnum, buf, offset, len, dtype); 403 403 } 404 404 EXPORT_SYMBOL_GPL(ubi_leb_write); 405 405 ··· 448 448 if (len == 0) 449 449 return 0; 450 450 451 - return ubi_eba_atomic_leb_change(ubi, vol_id, lnum, buf, len, dtype); 451 + return ubi_eba_atomic_leb_change(ubi, vol, lnum, buf, len, dtype); 452 452 } 453 453 EXPORT_SYMBOL_GPL(ubi_leb_change); 454 454 ··· 481 481 if (vol->upd_marker) 482 482 return -EBADF; 483 483 484 - err = ubi_eba_unmap_leb(ubi, vol_id, lnum); 484 + err = ubi_eba_unmap_leb(ubi, vol, lnum); 485 485 if (err) 486 486 return err; 487 487 ··· 542 542 if (vol->upd_marker) 543 543 return -EBADF; 544 544 545 - return ubi_eba_unmap_leb(ubi, vol_id, lnum); 545 + return ubi_eba_unmap_leb(ubi, vol, lnum); 546 546 } 547 547 EXPORT_SYMBOL_GPL(ubi_leb_unmap); 548 548 ··· 587 587 if (vol->eba_tbl[lnum] >= 0) 588 588 return -EBADMSG; 589 589 590 - return ubi_eba_write_leb(ubi, vol_id, lnum, NULL, 0, 0, dtype); 590 + return ubi_eba_write_leb(ubi, vol, lnum, NULL, 0, 0, dtype); 591 591 } 592 592 EXPORT_SYMBOL_GPL(ubi_leb_map); 593 593

+1 -1

drivers/mtd/ubi/misc.c

··· 79 79 else 80 80 size = vol->usable_leb_size; 81 81 82 - err = ubi_eba_read_leb(ubi, vol_id, i, buf, 0, size, 1); 82 + err = ubi_eba_read_leb(ubi, vol, i, buf, 0, size, 1); 83 83 if (err) { 84 84 if (err == -EBADMSG) 85 85 err = 1;

+11 -10

drivers/mtd/ubi/ubi.h

··· 410 410 int ubi_create_volume(struct ubi_device *ubi, struct ubi_mkvol_req *req); 411 411 int ubi_remove_volume(struct ubi_volume_desc *desc); 412 412 int ubi_resize_volume(struct ubi_volume_desc *desc, int reserved_pebs); 413 - int ubi_add_volume(struct ubi_device *ubi, int vol_id); 414 - void ubi_free_volume(struct ubi_device *ubi, int vol_id); 413 + int ubi_add_volume(struct ubi_device *ubi, struct ubi_volume *vol); 414 + void ubi_free_volume(struct ubi_device *ubi, struct ubi_volume *vol); 415 415 416 416 /* upd.c */ 417 417 int ubi_start_update(struct ubi_device *ubi, int vol_id, long long bytes); ··· 435 435 #endif 436 436 437 437 /* eba.c */ 438 - int ubi_eba_unmap_leb(struct ubi_device *ubi, int vol_id, int lnum); 439 - int ubi_eba_read_leb(struct ubi_device *ubi, int vol_id, int lnum, void *buf, 440 - int offset, int len, int check); 441 - int ubi_eba_write_leb(struct ubi_device *ubi, int vol_id, int lnum, 438 + int ubi_eba_unmap_leb(struct ubi_device *ubi, struct ubi_volume *vol, 439 + int lnum); 440 + int ubi_eba_read_leb(struct ubi_device *ubi, struct ubi_volume *vol, int lnum, 441 + void *buf, int offset, int len, int check); 442 + int ubi_eba_write_leb(struct ubi_device *ubi, struct ubi_volume *vol, int lnum, 442 443 const void *buf, int offset, int len, int dtype); 443 - int ubi_eba_write_leb_st(struct ubi_device *ubi, int vol_id, int lnum, 444 - const void *buf, int len, int dtype, 444 + int ubi_eba_write_leb_st(struct ubi_device *ubi, struct ubi_volume *vol, 445 + int lnum, const void *buf, int len, int dtype, 445 446 int used_ebs); 446 - int ubi_eba_atomic_leb_change(struct ubi_device *ubi, int vol_id, int lnum, 447 - const void *buf, int len, int dtype); 447 + int ubi_eba_atomic_leb_change(struct ubi_device *ubi, struct ubi_volume *vol, 448 + int lnum, const void *buf, int len, int dtype); 448 449 int ubi_eba_copy_leb(struct ubi_device *ubi, int from, int to, 449 450 struct ubi_vid_hdr *vid_hdr); 450 451 int ubi_eba_init_scan(struct ubi_device *ubi, struct ubi_scan_info *si);

+3 -4

drivers/mtd/ubi/upd.c

··· 136 136 137 137 /* Before updating - wipe out the volume */ 138 138 for (i = 0; i < vol->reserved_pebs; i++) { 139 - err = ubi_eba_unmap_leb(ubi, vol_id, i); 139 + err = ubi_eba_unmap_leb(ubi, vol, i); 140 140 if (err) 141 141 return err; 142 142 } ··· 209 209 if (len != l) 210 210 dbg_msg("skip last %d bytes (0xFF)", len - l); 211 211 212 - err = ubi_eba_write_leb(ubi, vol_id, lnum, buf, 0, l, 213 - UBI_UNKNOWN); 212 + err = ubi_eba_write_leb(ubi, vol, lnum, buf, 0, l, UBI_UNKNOWN); 214 213 } else { 215 214 /* 216 215 * When writing static volume, and this is the last logical ··· 221 222 * contain zeros, not random trash. 222 223 */ 223 224 memset(buf + len, 0, vol->usable_leb_size - len); 224 - err = ubi_eba_write_leb_st(ubi, vol_id, lnum, buf, len, 225 + err = ubi_eba_write_leb_st(ubi, vol, lnum, buf, len, 225 226 UBI_UNKNOWN, used_ebs); 226 227 } 227 228

+10 -12

drivers/mtd/ubi/vmt.c

··· 417 417 return err; 418 418 419 419 for (i = 0; i < vol->reserved_pebs; i++) { 420 - err = ubi_eba_unmap_leb(ubi, vol_id, i); 420 + err = ubi_eba_unmap_leb(ubi, vol, i); 421 421 if (err) 422 422 return err; 423 423 } ··· 524 524 525 525 if (pebs < 0) { 526 526 for (i = 0; i < -pebs; i++) { 527 - err = ubi_eba_unmap_leb(ubi, vol_id, reserved_pebs + i); 527 + err = ubi_eba_unmap_leb(ubi, vol, reserved_pebs + i); 528 528 if (err) 529 529 goto out_acc; 530 530 } ··· 573 573 /** 574 574 * ubi_add_volume - add volume. 575 575 * @ubi: UBI device description object 576 - * @vol_id: volume ID 576 + * @vol: volume description object 577 577 * 578 578 * This function adds an existin volume and initializes all its data 579 579 * structures. Returnes zero in case of success and a negative error code in 580 580 * case of failure. 581 581 */ 582 - int ubi_add_volume(struct ubi_device *ubi, int vol_id) 582 + int ubi_add_volume(struct ubi_device *ubi, struct ubi_volume *vol) 583 583 { 584 - int err; 584 + int err, vol_id = vol->vol_id; 585 585 dev_t dev; 586 - struct ubi_volume *vol = ubi->volumes[vol_id]; 587 586 588 587 dbg_msg("add volume %d", vol_id); 589 588 ubi_dbg_dump_vol_info(vol); ··· 633 634 /** 634 635 * ubi_free_volume - free volume. 635 636 * @ubi: UBI device description object 636 - * @vol_id: volume ID 637 + * @vol: volume description object 637 638 * 638 - * This function frees all resources for volume @vol_id but does not remove it. 639 + * This function frees all resources for volume @vol but does not remove it. 639 640 * Used only when the UBI device is detached. 640 641 */ 641 - void ubi_free_volume(struct ubi_device *ubi, int vol_id) 642 + void ubi_free_volume(struct ubi_device *ubi, struct ubi_volume *vol) 642 643 { 643 644 int err; 644 - struct ubi_volume *vol = ubi->volumes[vol_id]; 645 645 646 - dbg_msg("free volume %d", vol_id); 646 + dbg_msg("free volume %d", vol->vol_id); 647 647 ubi_assert(vol); 648 648 649 649 vol->removed = 1; 650 650 err = ubi_destroy_gluebi(vol); 651 - ubi->volumes[vol_id] = NULL; 651 + ubi->volumes[vol->vol_id] = NULL; 652 652 cdev_del(&vol->cdev); 653 653 volume_sysfs_close(vol); 654 654 }

+4 -2

drivers/mtd/ubi/vtbl.c

··· 86 86 { 87 87 int i, err; 88 88 uint32_t crc; 89 + struct ubi_volume *layout_vol; 89 90 90 91 ubi_assert(idx >= 0 && idx < ubi->vtbl_slots); 92 + layout_vol = ubi->volumes[vol_id2idx(UBI_LAYOUT_VOL_ID)]; 91 93 92 94 if (!vtbl_rec) 93 95 vtbl_rec = &empty_vtbl_record; ··· 101 99 mutex_lock(&ubi->vtbl_mutex); 102 100 memcpy(&ubi->vtbl[idx], vtbl_rec, sizeof(struct ubi_vtbl_record)); 103 101 for (i = 0; i < UBI_LAYOUT_VOLUME_EBS; i++) { 104 - err = ubi_eba_unmap_leb(ubi, UBI_LAYOUT_VOL_ID, i); 102 + err = ubi_eba_unmap_leb(ubi, layout_vol, i); 105 103 if (err) { 106 104 mutex_unlock(&ubi->vtbl_mutex); 107 105 return err; 108 106 } 109 - err = ubi_eba_write_leb(ubi, UBI_LAYOUT_VOL_ID, i, ubi->vtbl, 0, 107 + err = ubi_eba_write_leb(ubi, layout_vol, i, ubi->vtbl, 0, 110 108 ubi->vtbl_size, UBI_LONGTERM); 111 109 if (err) { 112 110 mutex_unlock(&ubi->vtbl_mutex);