1 /* 2 * Copyright (c) International Business Machines Corp., 2006 3 * Copyright (c) Nokia Corporation, 2007 4 * 5 * This program is free software; you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License as published by 7 * the Free Software Foundation; either version 2 of the License, or 8 * (at your option) any later version. 9 * 10 * This program is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See 13 * the GNU General Public License for more details. 14 * 15 * You should have received a copy of the GNU General Public License 16 * along with this program; if not, write to the Free Software 17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 18 * 19 * Author: Artem Bityutskiy (Битюцкий Артём), 20 * Frank Haverkamp 21 */ 22 23 /* 24 * This file includes UBI initialization and building of UBI devices. 25 * 26 * When UBI is initialized, it attaches all the MTD devices specified as the 27 * module load parameters or the kernel boot parameters. If MTD devices were 28 * specified, UBI does not attach any MTD device, but it is possible to do 29 * later using the "UBI control device". 30 * 31 * At the moment we only attach UBI devices by scanning, which will become a 32 * bottleneck when flashes reach certain large size. Then one may improve UBI 33 * and add other methods, although it does not seem to be easy to do. 34 */ 35 36 #ifdef UBI_LINUX 37 #include <linux/err.h> 38 #include <linux/module.h> 39 #include <linux/moduleparam.h> 40 #include <linux/stringify.h> 41 #include <linux/stat.h> 42 #include <linux/miscdevice.h> 43 #include <linux/log2.h> 44 #include <linux/kthread.h> 45 #endif 46 #include <ubi_uboot.h> 47 #include "ubi.h" 48 49 /* Maximum length of the 'mtd=' parameter */ 50 #define MTD_PARAM_LEN_MAX 64 51 52 /** 53 * struct mtd_dev_param - MTD device parameter description data structure. 54 * @name: MTD device name or number string 55 * @vid_hdr_offs: VID header offset 56 */ 57 struct mtd_dev_param 58 { 59 char name[MTD_PARAM_LEN_MAX]; 60 int vid_hdr_offs; 61 }; 62 63 /* Numbers of elements set in the @mtd_dev_param array */ 64 static int mtd_devs = 0; 65 66 /* MTD devices specification parameters */ 67 static struct mtd_dev_param mtd_dev_param[UBI_MAX_DEVICES]; 68 69 /* Root UBI "class" object (corresponds to '/<sysfs>/class/ubi/') */ 70 struct class *ubi_class; 71 72 #ifdef UBI_LINUX 73 /* Slab cache for wear-leveling entries */ 74 struct kmem_cache *ubi_wl_entry_slab; 75 76 /* UBI control character device */ 77 static struct miscdevice ubi_ctrl_cdev = { 78 .minor = MISC_DYNAMIC_MINOR, 79 .name = "ubi_ctrl", 80 .fops = &ubi_ctrl_cdev_operations, 81 }; 82 #endif 83 84 /* All UBI devices in system */ 85 struct ubi_device *ubi_devices[UBI_MAX_DEVICES]; 86 87 #ifdef UBI_LINUX 88 /* Serializes UBI devices creations and removals */ 89 DEFINE_MUTEX(ubi_devices_mutex); 90 91 /* Protects @ubi_devices and @ubi->ref_count */ 92 static DEFINE_SPINLOCK(ubi_devices_lock); 93 94 /* "Show" method for files in '/<sysfs>/class/ubi/' */ 95 static ssize_t ubi_version_show(struct class *class, char *buf) 96 { 97 return sprintf(buf, "%d\n", UBI_VERSION); 98 } 99 100 /* UBI version attribute ('/<sysfs>/class/ubi/version') */ 101 static struct class_attribute ubi_version = 102 __ATTR(version, S_IRUGO, ubi_version_show, NULL); 103 104 static ssize_t dev_attribute_show(struct device *dev, 105 struct device_attribute *attr, char *buf); 106 107 /* UBI device attributes (correspond to files in '/<sysfs>/class/ubi/ubiX') */ 108 static struct device_attribute dev_eraseblock_size = 109 __ATTR(eraseblock_size, S_IRUGO, dev_attribute_show, NULL); 110 static struct device_attribute dev_avail_eraseblocks = 111 __ATTR(avail_eraseblocks, S_IRUGO, dev_attribute_show, NULL); 112 static struct device_attribute dev_total_eraseblocks = 113 __ATTR(total_eraseblocks, S_IRUGO, dev_attribute_show, NULL); 114 static struct device_attribute dev_volumes_count = 115 __ATTR(volumes_count, S_IRUGO, dev_attribute_show, NULL); 116 static struct device_attribute dev_max_ec = 117 __ATTR(max_ec, S_IRUGO, dev_attribute_show, NULL); 118 static struct device_attribute dev_reserved_for_bad = 119 __ATTR(reserved_for_bad, S_IRUGO, dev_attribute_show, NULL); 120 static struct device_attribute dev_bad_peb_count = 121 __ATTR(bad_peb_count, S_IRUGO, dev_attribute_show, NULL); 122 static struct device_attribute dev_max_vol_count = 123 __ATTR(max_vol_count, S_IRUGO, dev_attribute_show, NULL); 124 static struct device_attribute dev_min_io_size = 125 __ATTR(min_io_size, S_IRUGO, dev_attribute_show, NULL); 126 static struct device_attribute dev_bgt_enabled = 127 __ATTR(bgt_enabled, S_IRUGO, dev_attribute_show, NULL); 128 static struct device_attribute dev_mtd_num = 129 __ATTR(mtd_num, S_IRUGO, dev_attribute_show, NULL); 130 #endif 131 132 /** 133 * ubi_get_device - get UBI device. 134 * @ubi_num: UBI device number 135 * 136 * This function returns UBI device description object for UBI device number 137 * @ubi_num, or %NULL if the device does not exist. This function increases the 138 * device reference count to prevent removal of the device. In other words, the 139 * device cannot be removed if its reference count is not zero. 140 */ 141 struct ubi_device *ubi_get_device(int ubi_num) 142 { 143 struct ubi_device *ubi; 144 145 spin_lock(&ubi_devices_lock); 146 ubi = ubi_devices[ubi_num]; 147 if (ubi) { 148 ubi_assert(ubi->ref_count >= 0); 149 ubi->ref_count += 1; 150 get_device(&ubi->dev); 151 } 152 spin_unlock(&ubi_devices_lock); 153 154 return ubi; 155 } 156 157 /** 158 * ubi_put_device - drop an UBI device reference. 159 * @ubi: UBI device description object 160 */ 161 void ubi_put_device(struct ubi_device *ubi) 162 { 163 spin_lock(&ubi_devices_lock); 164 ubi->ref_count -= 1; 165 put_device(&ubi->dev); 166 spin_unlock(&ubi_devices_lock); 167 } 168 169 /** 170 * ubi_get_by_major - get UBI device description object by character device 171 * major number. 172 * @major: major number 173 * 174 * This function is similar to 'ubi_get_device()', but it searches the device 175 * by its major number. 176 */ 177 struct ubi_device *ubi_get_by_major(int major) 178 { 179 int i; 180 struct ubi_device *ubi; 181 182 spin_lock(&ubi_devices_lock); 183 for (i = 0; i < UBI_MAX_DEVICES; i++) { 184 ubi = ubi_devices[i]; 185 if (ubi && MAJOR(ubi->cdev.dev) == major) { 186 ubi_assert(ubi->ref_count >= 0); 187 ubi->ref_count += 1; 188 get_device(&ubi->dev); 189 spin_unlock(&ubi_devices_lock); 190 return ubi; 191 } 192 } 193 spin_unlock(&ubi_devices_lock); 194 195 return NULL; 196 } 197 198 /** 199 * ubi_major2num - get UBI device number by character device major number. 200 * @major: major number 201 * 202 * This function searches UBI device number object by its major number. If UBI 203 * device was not found, this function returns -ENODEV, otherwise the UBI device 204 * number is returned. 205 */ 206 int ubi_major2num(int major) 207 { 208 int i, ubi_num = -ENODEV; 209 210 spin_lock(&ubi_devices_lock); 211 for (i = 0; i < UBI_MAX_DEVICES; i++) { 212 struct ubi_device *ubi = ubi_devices[i]; 213 214 if (ubi && MAJOR(ubi->cdev.dev) == major) { 215 ubi_num = ubi->ubi_num; 216 break; 217 } 218 } 219 spin_unlock(&ubi_devices_lock); 220 221 return ubi_num; 222 } 223 224 #ifdef UBI_LINUX 225 /* "Show" method for files in '/<sysfs>/class/ubi/ubiX/' */ 226 static ssize_t dev_attribute_show(struct device *dev, 227 struct device_attribute *attr, char *buf) 228 { 229 ssize_t ret; 230 struct ubi_device *ubi; 231 232 /* 233 * The below code looks weird, but it actually makes sense. We get the 234 * UBI device reference from the contained 'struct ubi_device'. But it 235 * is unclear if the device was removed or not yet. Indeed, if the 236 * device was removed before we increased its reference count, 237 * 'ubi_get_device()' will return -ENODEV and we fail. 238 * 239 * Remember, 'struct ubi_device' is freed in the release function, so 240 * we still can use 'ubi->ubi_num'. 241 */ 242 ubi = container_of(dev, struct ubi_device, dev); 243 ubi = ubi_get_device(ubi->ubi_num); 244 if (!ubi) 245 return -ENODEV; 246 247 if (attr == &dev_eraseblock_size) 248 ret = sprintf(buf, "%d\n", ubi->leb_size); 249 else if (attr == &dev_avail_eraseblocks) 250 ret = sprintf(buf, "%d\n", ubi->avail_pebs); 251 else if (attr == &dev_total_eraseblocks) 252 ret = sprintf(buf, "%d\n", ubi->good_peb_count); 253 else if (attr == &dev_volumes_count) 254 ret = sprintf(buf, "%d\n", ubi->vol_count - UBI_INT_VOL_COUNT); 255 else if (attr == &dev_max_ec) 256 ret = sprintf(buf, "%d\n", ubi->max_ec); 257 else if (attr == &dev_reserved_for_bad) 258 ret = sprintf(buf, "%d\n", ubi->beb_rsvd_pebs); 259 else if (attr == &dev_bad_peb_count) 260 ret = sprintf(buf, "%d\n", ubi->bad_peb_count); 261 else if (attr == &dev_max_vol_count) 262 ret = sprintf(buf, "%d\n", ubi->vtbl_slots); 263 else if (attr == &dev_min_io_size) 264 ret = sprintf(buf, "%d\n", ubi->min_io_size); 265 else if (attr == &dev_bgt_enabled) 266 ret = sprintf(buf, "%d\n", ubi->thread_enabled); 267 else if (attr == &dev_mtd_num) 268 ret = sprintf(buf, "%d\n", ubi->mtd->index); 269 else 270 ret = -EINVAL; 271 272 ubi_put_device(ubi); 273 return ret; 274 } 275 276 /* Fake "release" method for UBI devices */ 277 static void dev_release(struct device *dev) { } 278 279 /** 280 * ubi_sysfs_init - initialize sysfs for an UBI device. 281 * @ubi: UBI device description object 282 * 283 * This function returns zero in case of success and a negative error code in 284 * case of failure. 285 */ 286 static int ubi_sysfs_init(struct ubi_device *ubi) 287 { 288 int err; 289 290 ubi->dev.release = dev_release; 291 ubi->dev.devt = ubi->cdev.dev; 292 ubi->dev.class = ubi_class; 293 sprintf(&ubi->dev.bus_id[0], UBI_NAME_STR"%d", ubi->ubi_num); 294 err = device_register(&ubi->dev); 295 if (err) 296 return err; 297 298 err = device_create_file(&ubi->dev, &dev_eraseblock_size); 299 if (err) 300 return err; 301 err = device_create_file(&ubi->dev, &dev_avail_eraseblocks); 302 if (err) 303 return err; 304 err = device_create_file(&ubi->dev, &dev_total_eraseblocks); 305 if (err) 306 return err; 307 err = device_create_file(&ubi->dev, &dev_volumes_count); 308 if (err) 309 return err; 310 err = device_create_file(&ubi->dev, &dev_max_ec); 311 if (err) 312 return err; 313 err = device_create_file(&ubi->dev, &dev_reserved_for_bad); 314 if (err) 315 return err; 316 err = device_create_file(&ubi->dev, &dev_bad_peb_count); 317 if (err) 318 return err; 319 err = device_create_file(&ubi->dev, &dev_max_vol_count); 320 if (err) 321 return err; 322 err = device_create_file(&ubi->dev, &dev_min_io_size); 323 if (err) 324 return err; 325 err = device_create_file(&ubi->dev, &dev_bgt_enabled); 326 if (err) 327 return err; 328 err = device_create_file(&ubi->dev, &dev_mtd_num); 329 return err; 330 } 331 332 /** 333 * ubi_sysfs_close - close sysfs for an UBI device. 334 * @ubi: UBI device description object 335 */ 336 static void ubi_sysfs_close(struct ubi_device *ubi) 337 { 338 device_remove_file(&ubi->dev, &dev_mtd_num); 339 device_remove_file(&ubi->dev, &dev_bgt_enabled); 340 device_remove_file(&ubi->dev, &dev_min_io_size); 341 device_remove_file(&ubi->dev, &dev_max_vol_count); 342 device_remove_file(&ubi->dev, &dev_bad_peb_count); 343 device_remove_file(&ubi->dev, &dev_reserved_for_bad); 344 device_remove_file(&ubi->dev, &dev_max_ec); 345 device_remove_file(&ubi->dev, &dev_volumes_count); 346 device_remove_file(&ubi->dev, &dev_total_eraseblocks); 347 device_remove_file(&ubi->dev, &dev_avail_eraseblocks); 348 device_remove_file(&ubi->dev, &dev_eraseblock_size); 349 device_unregister(&ubi->dev); 350 } 351 #endif 352 353 /** 354 * kill_volumes - destroy all volumes. 355 * @ubi: UBI device description object 356 */ 357 static void kill_volumes(struct ubi_device *ubi) 358 { 359 int i; 360 361 for (i = 0; i < ubi->vtbl_slots; i++) 362 if (ubi->volumes[i]) 363 ubi_free_volume(ubi, ubi->volumes[i]); 364 } 365 366 /** 367 * uif_init - initialize user interfaces for an UBI device. 368 * @ubi: UBI device description object 369 * 370 * This function returns zero in case of success and a negative error code in 371 * case of failure. 372 */ 373 static int uif_init(struct ubi_device *ubi) 374 { 375 int i, err; 376 #ifdef UBI_LINUX 377 dev_t dev; 378 #endif 379 380 sprintf(ubi->ubi_name, UBI_NAME_STR "%d", ubi->ubi_num); 381 382 /* 383 * Major numbers for the UBI character devices are allocated 384 * dynamically. Major numbers of volume character devices are 385 * equivalent to ones of the corresponding UBI character device. Minor 386 * numbers of UBI character devices are 0, while minor numbers of 387 * volume character devices start from 1. Thus, we allocate one major 388 * number and ubi->vtbl_slots + 1 minor numbers. 389 */ 390 err = alloc_chrdev_region(&dev, 0, ubi->vtbl_slots + 1, ubi->ubi_name); 391 if (err) { 392 ubi_err("cannot register UBI character devices"); 393 return err; 394 } 395 396 ubi_assert(MINOR(dev) == 0); 397 cdev_init(&ubi->cdev, &ubi_cdev_operations); 398 dbg_msg("%s major is %u", ubi->ubi_name, MAJOR(dev)); 399 ubi->cdev.owner = THIS_MODULE; 400 401 err = cdev_add(&ubi->cdev, dev, 1); 402 if (err) { 403 ubi_err("cannot add character device"); 404 goto out_unreg; 405 } 406 407 err = ubi_sysfs_init(ubi); 408 if (err) 409 goto out_sysfs; 410 411 for (i = 0; i < ubi->vtbl_slots; i++) 412 if (ubi->volumes[i]) { 413 err = ubi_add_volume(ubi, ubi->volumes[i]); 414 if (err) { 415 ubi_err("cannot add volume %d", i); 416 goto out_volumes; 417 } 418 } 419 420 return 0; 421 422 out_volumes: 423 kill_volumes(ubi); 424 out_sysfs: 425 ubi_sysfs_close(ubi); 426 cdev_del(&ubi->cdev); 427 out_unreg: 428 unregister_chrdev_region(ubi->cdev.dev, ubi->vtbl_slots + 1); 429 ubi_err("cannot initialize UBI %s, error %d", ubi->ubi_name, err); 430 return err; 431 } 432 433 /** 434 * uif_close - close user interfaces for an UBI device. 435 * @ubi: UBI device description object 436 */ 437 static void uif_close(struct ubi_device *ubi) 438 { 439 kill_volumes(ubi); 440 ubi_sysfs_close(ubi); 441 cdev_del(&ubi->cdev); 442 unregister_chrdev_region(ubi->cdev.dev, ubi->vtbl_slots + 1); 443 } 444 445 /** 446 * attach_by_scanning - attach an MTD device using scanning method. 447 * @ubi: UBI device descriptor 448 * 449 * This function returns zero in case of success and a negative error code in 450 * case of failure. 451 * 452 * Note, currently this is the only method to attach UBI devices. Hopefully in 453 * the future we'll have more scalable attaching methods and avoid full media 454 * scanning. But even in this case scanning will be needed as a fall-back 455 * attaching method if there are some on-flash table corruptions. 456 */ 457 static int attach_by_scanning(struct ubi_device *ubi) 458 { 459 int err; 460 struct ubi_scan_info *si; 461 462 si = ubi_scan(ubi); 463 if (IS_ERR(si)) 464 return PTR_ERR(si); 465 466 ubi->bad_peb_count = si->bad_peb_count; 467 ubi->good_peb_count = ubi->peb_count - ubi->bad_peb_count; 468 ubi->max_ec = si->max_ec; 469 ubi->mean_ec = si->mean_ec; 470 471 err = ubi_read_volume_table(ubi, si); 472 if (err) 473 goto out_si; 474 475 err = ubi_wl_init_scan(ubi, si); 476 if (err) 477 goto out_vtbl; 478 479 err = ubi_eba_init_scan(ubi, si); 480 if (err) 481 goto out_wl; 482 483 ubi_scan_destroy_si(si); 484 return 0; 485 486 out_wl: 487 ubi_wl_close(ubi); 488 out_vtbl: 489 vfree(ubi->vtbl); 490 out_si: 491 ubi_scan_destroy_si(si); 492 return err; 493 } 494 495 /** 496 * io_init - initialize I/O unit for a given UBI device. 497 * @ubi: UBI device description object 498 * 499 * If @ubi->vid_hdr_offset or @ubi->leb_start is zero, default offsets are 500 * assumed: 501 * o EC header is always at offset zero - this cannot be changed; 502 * o VID header starts just after the EC header at the closest address 503 * aligned to @io->hdrs_min_io_size; 504 * o data starts just after the VID header at the closest address aligned to 505 * @io->min_io_size 506 * 507 * This function returns zero in case of success and a negative error code in 508 * case of failure. 509 */ 510 static int io_init(struct ubi_device *ubi) 511 { 512 if (ubi->mtd->numeraseregions != 0) { 513 /* 514 * Some flashes have several erase regions. Different regions 515 * may have different eraseblock size and other 516 * characteristics. It looks like mostly multi-region flashes 517 * have one "main" region and one or more small regions to 518 * store boot loader code or boot parameters or whatever. I 519 * guess we should just pick the largest region. But this is 520 * not implemented. 521 */ 522 ubi_err("multiple regions, not implemented"); 523 return -EINVAL; 524 } 525 526 if (ubi->vid_hdr_offset < 0) 527 return -EINVAL; 528 529 /* 530 * Note, in this implementation we support MTD devices with 0x7FFFFFFF 531 * physical eraseblocks maximum. 532 */ 533 534 ubi->peb_size = ubi->mtd->erasesize; 535 ubi->peb_count = ubi->mtd->size / ubi->mtd->erasesize; 536 ubi->flash_size = ubi->mtd->size; 537 538 if (ubi->mtd->block_isbad && ubi->mtd->block_markbad) 539 ubi->bad_allowed = 1; 540 541 ubi->min_io_size = ubi->mtd->writesize; 542 ubi->hdrs_min_io_size = ubi->mtd->writesize >> ubi->mtd->subpage_sft; 543 544 /* 545 * Make sure minimal I/O unit is power of 2. Note, there is no 546 * fundamental reason for this assumption. It is just an optimization 547 * which allows us to avoid costly division operations. 548 */ 549 if (!is_power_of_2(ubi->min_io_size)) { 550 ubi_err("min. I/O unit (%d) is not power of 2", 551 ubi->min_io_size); 552 return -EINVAL; 553 } 554 555 ubi_assert(ubi->hdrs_min_io_size > 0); 556 ubi_assert(ubi->hdrs_min_io_size <= ubi->min_io_size); 557 ubi_assert(ubi->min_io_size % ubi->hdrs_min_io_size == 0); 558 559 /* Calculate default aligned sizes of EC and VID headers */ 560 ubi->ec_hdr_alsize = ALIGN(UBI_EC_HDR_SIZE, ubi->hdrs_min_io_size); 561 ubi->vid_hdr_alsize = ALIGN(UBI_VID_HDR_SIZE, ubi->hdrs_min_io_size); 562 563 dbg_msg("min_io_size %d", ubi->min_io_size); 564 dbg_msg("hdrs_min_io_size %d", ubi->hdrs_min_io_size); 565 dbg_msg("ec_hdr_alsize %d", ubi->ec_hdr_alsize); 566 dbg_msg("vid_hdr_alsize %d", ubi->vid_hdr_alsize); 567 568 if (ubi->vid_hdr_offset == 0) 569 /* Default offset */ 570 ubi->vid_hdr_offset = ubi->vid_hdr_aloffset = 571 ubi->ec_hdr_alsize; 572 else { 573 ubi->vid_hdr_aloffset = ubi->vid_hdr_offset & 574 ~(ubi->hdrs_min_io_size - 1); 575 ubi->vid_hdr_shift = ubi->vid_hdr_offset - 576 ubi->vid_hdr_aloffset; 577 } 578 579 /* Similar for the data offset */ 580 ubi->leb_start = ubi->vid_hdr_offset + UBI_EC_HDR_SIZE; 581 ubi->leb_start = ALIGN(ubi->leb_start, ubi->min_io_size); 582 583 dbg_msg("vid_hdr_offset %d", ubi->vid_hdr_offset); 584 dbg_msg("vid_hdr_aloffset %d", ubi->vid_hdr_aloffset); 585 dbg_msg("vid_hdr_shift %d", ubi->vid_hdr_shift); 586 dbg_msg("leb_start %d", ubi->leb_start); 587 588 /* The shift must be aligned to 32-bit boundary */ 589 if (ubi->vid_hdr_shift % 4) { 590 ubi_err("unaligned VID header shift %d", 591 ubi->vid_hdr_shift); 592 return -EINVAL; 593 } 594 595 /* Check sanity */ 596 if (ubi->vid_hdr_offset < UBI_EC_HDR_SIZE || 597 ubi->leb_start < ubi->vid_hdr_offset + UBI_VID_HDR_SIZE || 598 ubi->leb_start > ubi->peb_size - UBI_VID_HDR_SIZE || 599 ubi->leb_start & (ubi->min_io_size - 1)) { 600 ubi_err("bad VID header (%d) or data offsets (%d)", 601 ubi->vid_hdr_offset, ubi->leb_start); 602 return -EINVAL; 603 } 604 605 /* 606 * It may happen that EC and VID headers are situated in one minimal 607 * I/O unit. In this case we can only accept this UBI image in 608 * read-only mode. 609 */ 610 if (ubi->vid_hdr_offset + UBI_VID_HDR_SIZE <= ubi->hdrs_min_io_size) { 611 ubi_warn("EC and VID headers are in the same minimal I/O unit, " 612 "switch to read-only mode"); 613 ubi->ro_mode = 1; 614 } 615 616 ubi->leb_size = ubi->peb_size - ubi->leb_start; 617 618 if (!(ubi->mtd->flags & MTD_WRITEABLE)) { 619 ubi_msg("MTD device %d is write-protected, attach in " 620 "read-only mode", ubi->mtd->index); 621 ubi->ro_mode = 1; 622 } 623 624 ubi_msg("physical eraseblock size: %d bytes (%d KiB)", 625 ubi->peb_size, ubi->peb_size >> 10); 626 ubi_msg("logical eraseblock size: %d bytes", ubi->leb_size); 627 ubi_msg("smallest flash I/O unit: %d", ubi->min_io_size); 628 if (ubi->hdrs_min_io_size != ubi->min_io_size) 629 ubi_msg("sub-page size: %d", 630 ubi->hdrs_min_io_size); 631 ubi_msg("VID header offset: %d (aligned %d)", 632 ubi->vid_hdr_offset, ubi->vid_hdr_aloffset); 633 ubi_msg("data offset: %d", ubi->leb_start); 634 635 /* 636 * Note, ideally, we have to initialize ubi->bad_peb_count here. But 637 * unfortunately, MTD does not provide this information. We should loop 638 * over all physical eraseblocks and invoke mtd->block_is_bad() for 639 * each physical eraseblock. So, we skip ubi->bad_peb_count 640 * uninitialized and initialize it after scanning. 641 */ 642 643 return 0; 644 } 645 646 /** 647 * autoresize - re-size the volume which has the "auto-resize" flag set. 648 * @ubi: UBI device description object 649 * @vol_id: ID of the volume to re-size 650 * 651 * This function re-sizes the volume marked by the @UBI_VTBL_AUTORESIZE_FLG in 652 * the volume table to the largest possible size. See comments in ubi-header.h 653 * for more description of the flag. Returns zero in case of success and a 654 * negative error code in case of failure. 655 */ 656 static int autoresize(struct ubi_device *ubi, int vol_id) 657 { 658 struct ubi_volume_desc desc; 659 struct ubi_volume *vol = ubi->volumes[vol_id]; 660 int err, old_reserved_pebs = vol->reserved_pebs; 661 662 /* 663 * Clear the auto-resize flag in the volume in-memory copy of the 664 * volume table, and 'ubi_resize_volume()' will propogate this change 665 * to the flash. 666 */ 667 ubi->vtbl[vol_id].flags &= ~UBI_VTBL_AUTORESIZE_FLG; 668 669 if (ubi->avail_pebs == 0) { 670 struct ubi_vtbl_record vtbl_rec; 671 672 /* 673 * No avalilable PEBs to re-size the volume, clear the flag on 674 * flash and exit. 675 */ 676 memcpy(&vtbl_rec, &ubi->vtbl[vol_id], 677 sizeof(struct ubi_vtbl_record)); 678 err = ubi_change_vtbl_record(ubi, vol_id, &vtbl_rec); 679 if (err) 680 ubi_err("cannot clean auto-resize flag for volume %d", 681 vol_id); 682 } else { 683 desc.vol = vol; 684 err = ubi_resize_volume(&desc, 685 old_reserved_pebs + ubi->avail_pebs); 686 if (err) 687 ubi_err("cannot auto-resize volume %d", vol_id); 688 } 689 690 if (err) 691 return err; 692 693 ubi_msg("volume %d (\"%s\") re-sized from %d to %d LEBs", vol_id, 694 vol->name, old_reserved_pebs, vol->reserved_pebs); 695 return 0; 696 } 697 698 /** 699 * ubi_attach_mtd_dev - attach an MTD device. 700 * @mtd_dev: MTD device description object 701 * @ubi_num: number to assign to the new UBI device 702 * @vid_hdr_offset: VID header offset 703 * 704 * This function attaches MTD device @mtd_dev to UBI and assign @ubi_num number 705 * to the newly created UBI device, unless @ubi_num is %UBI_DEV_NUM_AUTO, in 706 * which case this function finds a vacant device nubert and assings it 707 * automatically. Returns the new UBI device number in case of success and a 708 * negative error code in case of failure. 709 * 710 * Note, the invocations of this function has to be serialized by the 711 * @ubi_devices_mutex. 712 */ 713 int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num, int vid_hdr_offset) 714 { 715 struct ubi_device *ubi; 716 int i, err; 717 718 /* 719 * Check if we already have the same MTD device attached. 720 * 721 * Note, this function assumes that UBI devices creations and deletions 722 * are serialized, so it does not take the &ubi_devices_lock. 723 */ 724 for (i = 0; i < UBI_MAX_DEVICES; i++) { 725 ubi = ubi_devices[i]; 726 if (ubi && mtd->index == ubi->mtd->index) { 727 dbg_err("mtd%d is already attached to ubi%d", 728 mtd->index, i); 729 return -EEXIST; 730 } 731 } 732 733 /* 734 * Make sure this MTD device is not emulated on top of an UBI volume 735 * already. Well, generally this recursion works fine, but there are 736 * different problems like the UBI module takes a reference to itself 737 * by attaching (and thus, opening) the emulated MTD device. This 738 * results in inability to unload the module. And in general it makes 739 * no sense to attach emulated MTD devices, so we prohibit this. 740 */ 741 if (mtd->type == MTD_UBIVOLUME) { 742 ubi_err("refuse attaching mtd%d - it is already emulated on " 743 "top of UBI", mtd->index); 744 return -EINVAL; 745 } 746 747 if (ubi_num == UBI_DEV_NUM_AUTO) { 748 /* Search for an empty slot in the @ubi_devices array */ 749 for (ubi_num = 0; ubi_num < UBI_MAX_DEVICES; ubi_num++) 750 if (!ubi_devices[ubi_num]) 751 break; 752 if (ubi_num == UBI_MAX_DEVICES) { 753 dbg_err("only %d UBI devices may be created", UBI_MAX_DEVICES); 754 return -ENFILE; 755 } 756 } else { 757 if (ubi_num >= UBI_MAX_DEVICES) 758 return -EINVAL; 759 760 /* Make sure ubi_num is not busy */ 761 if (ubi_devices[ubi_num]) { 762 dbg_err("ubi%d already exists", ubi_num); 763 return -EEXIST; 764 } 765 } 766 767 ubi = kzalloc(sizeof(struct ubi_device), GFP_KERNEL); 768 if (!ubi) 769 return -ENOMEM; 770 771 ubi->mtd = mtd; 772 ubi->ubi_num = ubi_num; 773 ubi->vid_hdr_offset = vid_hdr_offset; 774 ubi->autoresize_vol_id = -1; 775 776 mutex_init(&ubi->buf_mutex); 777 mutex_init(&ubi->ckvol_mutex); 778 mutex_init(&ubi->volumes_mutex); 779 spin_lock_init(&ubi->volumes_lock); 780 781 ubi_msg("attaching mtd%d to ubi%d", mtd->index, ubi_num); 782 783 err = io_init(ubi); 784 if (err) 785 goto out_free; 786 787 err = -ENOMEM; 788 ubi->peb_buf1 = vmalloc(ubi->peb_size); 789 if (!ubi->peb_buf1) 790 goto out_free; 791 792 ubi->peb_buf2 = vmalloc(ubi->peb_size); 793 if (!ubi->peb_buf2) 794 goto out_free; 795 796 #ifdef CONFIG_MTD_UBI_DEBUG 797 mutex_init(&ubi->dbg_buf_mutex); 798 ubi->dbg_peb_buf = vmalloc(ubi->peb_size); 799 if (!ubi->dbg_peb_buf) 800 goto out_free; 801 #endif 802 803 err = attach_by_scanning(ubi); 804 if (err) { 805 dbg_err("failed to attach by scanning, error %d", err); 806 goto out_free; 807 } 808 809 if (ubi->autoresize_vol_id != -1) { 810 err = autoresize(ubi, ubi->autoresize_vol_id); 811 if (err) 812 goto out_detach; 813 } 814 815 err = uif_init(ubi); 816 if (err) 817 goto out_detach; 818 819 ubi->bgt_thread = kthread_create(ubi_thread, ubi, ubi->bgt_name); 820 if (IS_ERR(ubi->bgt_thread)) { 821 err = PTR_ERR(ubi->bgt_thread); 822 ubi_err("cannot spawn \"%s\", error %d", ubi->bgt_name, 823 err); 824 goto out_uif; 825 } 826 827 ubi_msg("attached mtd%d to ubi%d", mtd->index, ubi_num); 828 ubi_msg("MTD device name: \"%s\"", mtd->name); 829 ubi_msg("MTD device size: %llu MiB", ubi->flash_size >> 20); 830 ubi_msg("number of good PEBs: %d", ubi->good_peb_count); 831 ubi_msg("number of bad PEBs: %d", ubi->bad_peb_count); 832 ubi_msg("max. allowed volumes: %d", ubi->vtbl_slots); 833 ubi_msg("wear-leveling threshold: %d", CONFIG_MTD_UBI_WL_THRESHOLD); 834 ubi_msg("number of internal volumes: %d", UBI_INT_VOL_COUNT); 835 ubi_msg("number of user volumes: %d", 836 ubi->vol_count - UBI_INT_VOL_COUNT); 837 ubi_msg("available PEBs: %d", ubi->avail_pebs); 838 ubi_msg("total number of reserved PEBs: %d", ubi->rsvd_pebs); 839 ubi_msg("number of PEBs reserved for bad PEB handling: %d", 840 ubi->beb_rsvd_pebs); 841 ubi_msg("max/mean erase counter: %d/%d", ubi->max_ec, ubi->mean_ec); 842 843 /* Enable the background thread */ 844 if (!DBG_DISABLE_BGT) { 845 ubi->thread_enabled = 1; 846 wake_up_process(ubi->bgt_thread); 847 } 848 849 ubi_devices[ubi_num] = ubi; 850 return ubi_num; 851 852 out_uif: 853 uif_close(ubi); 854 out_detach: 855 ubi_eba_close(ubi); 856 ubi_wl_close(ubi); 857 vfree(ubi->vtbl); 858 out_free: 859 vfree(ubi->peb_buf1); 860 vfree(ubi->peb_buf2); 861 #ifdef CONFIG_MTD_UBI_DEBUG 862 vfree(ubi->dbg_peb_buf); 863 #endif 864 kfree(ubi); 865 return err; 866 } 867 868 /** 869 * ubi_detach_mtd_dev - detach an MTD device. 870 * @ubi_num: UBI device number to detach from 871 * @anyway: detach MTD even if device reference count is not zero 872 * 873 * This function destroys an UBI device number @ubi_num and detaches the 874 * underlying MTD device. Returns zero in case of success and %-EBUSY if the 875 * UBI device is busy and cannot be destroyed, and %-EINVAL if it does not 876 * exist. 877 * 878 * Note, the invocations of this function has to be serialized by the 879 * @ubi_devices_mutex. 880 */ 881 int ubi_detach_mtd_dev(int ubi_num, int anyway) 882 { 883 struct ubi_device *ubi; 884 885 if (ubi_num < 0 || ubi_num >= UBI_MAX_DEVICES) 886 return -EINVAL; 887 888 spin_lock(&ubi_devices_lock); 889 ubi = ubi_devices[ubi_num]; 890 if (!ubi) { 891 spin_unlock(&ubi_devices_lock); 892 return -EINVAL; 893 } 894 895 if (ubi->ref_count) { 896 if (!anyway) { 897 spin_unlock(&ubi_devices_lock); 898 return -EBUSY; 899 } 900 /* This may only happen if there is a bug */ 901 ubi_err("%s reference count %d, destroy anyway", 902 ubi->ubi_name, ubi->ref_count); 903 } 904 ubi_devices[ubi_num] = NULL; 905 spin_unlock(&ubi_devices_lock); 906 907 ubi_assert(ubi_num == ubi->ubi_num); 908 dbg_msg("detaching mtd%d from ubi%d", ubi->mtd->index, ubi_num); 909 910 /* 911 * Before freeing anything, we have to stop the background thread to 912 * prevent it from doing anything on this device while we are freeing. 913 */ 914 if (ubi->bgt_thread) 915 kthread_stop(ubi->bgt_thread); 916 917 uif_close(ubi); 918 ubi_eba_close(ubi); 919 ubi_wl_close(ubi); 920 vfree(ubi->vtbl); 921 put_mtd_device(ubi->mtd); 922 vfree(ubi->peb_buf1); 923 vfree(ubi->peb_buf2); 924 #ifdef CONFIG_MTD_UBI_DEBUG 925 vfree(ubi->dbg_peb_buf); 926 #endif 927 ubi_msg("mtd%d is detached from ubi%d", ubi->mtd->index, ubi->ubi_num); 928 kfree(ubi); 929 return 0; 930 } 931 932 /** 933 * find_mtd_device - open an MTD device by its name or number. 934 * @mtd_dev: name or number of the device 935 * 936 * This function tries to open and MTD device described by @mtd_dev string, 937 * which is first treated as an ASCII number, and if it is not true, it is 938 * treated as MTD device name. Returns MTD device description object in case of 939 * success and a negative error code in case of failure. 940 */ 941 static struct mtd_info * __init open_mtd_device(const char *mtd_dev) 942 { 943 struct mtd_info *mtd; 944 int mtd_num; 945 char *endp; 946 947 mtd_num = simple_strtoul(mtd_dev, &endp, 0); 948 if (*endp != '\0' || mtd_dev == endp) { 949 /* 950 * This does not look like an ASCII integer, probably this is 951 * MTD device name. 952 */ 953 mtd = get_mtd_device_nm(mtd_dev); 954 } else 955 mtd = get_mtd_device(NULL, mtd_num); 956 957 return mtd; 958 } 959 960 int __init ubi_init(void) 961 { 962 int err, i, k; 963 964 /* Ensure that EC and VID headers have correct size */ 965 BUILD_BUG_ON(sizeof(struct ubi_ec_hdr) != 64); 966 BUILD_BUG_ON(sizeof(struct ubi_vid_hdr) != 64); 967 968 if (mtd_devs > UBI_MAX_DEVICES) { 969 ubi_err("too many MTD devices, maximum is %d", UBI_MAX_DEVICES); 970 return -EINVAL; 971 } 972 973 /* Create base sysfs directory and sysfs files */ 974 ubi_class = class_create(THIS_MODULE, UBI_NAME_STR); 975 if (IS_ERR(ubi_class)) { 976 err = PTR_ERR(ubi_class); 977 ubi_err("cannot create UBI class"); 978 goto out; 979 } 980 981 err = class_create_file(ubi_class, &ubi_version); 982 if (err) { 983 ubi_err("cannot create sysfs file"); 984 goto out_class; 985 } 986 987 err = misc_register(&ubi_ctrl_cdev); 988 if (err) { 989 ubi_err("cannot register device"); 990 goto out_version; 991 } 992 993 #ifdef UBI_LINUX 994 ubi_wl_entry_slab = kmem_cache_create("ubi_wl_entry_slab", 995 sizeof(struct ubi_wl_entry), 996 0, 0, NULL); 997 if (!ubi_wl_entry_slab) 998 goto out_dev_unreg; 999 #endif 1000 1001 /* Attach MTD devices */ 1002 for (i = 0; i < mtd_devs; i++) { 1003 struct mtd_dev_param *p = &mtd_dev_param[i]; 1004 struct mtd_info *mtd; 1005 1006 cond_resched(); 1007 1008 mtd = open_mtd_device(p->name); 1009 if (IS_ERR(mtd)) { 1010 err = PTR_ERR(mtd); 1011 goto out_detach; 1012 } 1013 1014 mutex_lock(&ubi_devices_mutex); 1015 err = ubi_attach_mtd_dev(mtd, UBI_DEV_NUM_AUTO, 1016 p->vid_hdr_offs); 1017 mutex_unlock(&ubi_devices_mutex); 1018 if (err < 0) { 1019 put_mtd_device(mtd); 1020 ubi_err("cannot attach mtd%d", mtd->index); 1021 goto out_detach; 1022 } 1023 } 1024 1025 return 0; 1026 1027 out_detach: 1028 for (k = 0; k < i; k++) 1029 if (ubi_devices[k]) { 1030 mutex_lock(&ubi_devices_mutex); 1031 ubi_detach_mtd_dev(ubi_devices[k]->ubi_num, 1); 1032 mutex_unlock(&ubi_devices_mutex); 1033 } 1034 #ifdef UBI_LINUX 1035 kmem_cache_destroy(ubi_wl_entry_slab); 1036 out_dev_unreg: 1037 #endif 1038 misc_deregister(&ubi_ctrl_cdev); 1039 out_version: 1040 class_remove_file(ubi_class, &ubi_version); 1041 out_class: 1042 class_destroy(ubi_class); 1043 out: 1044 ubi_err("UBI error: cannot initialize UBI, error %d", err); 1045 return err; 1046 } 1047 module_init(ubi_init); 1048 1049 void __exit ubi_exit(void) 1050 { 1051 int i; 1052 1053 for (i = 0; i < UBI_MAX_DEVICES; i++) 1054 if (ubi_devices[i]) { 1055 mutex_lock(&ubi_devices_mutex); 1056 ubi_detach_mtd_dev(ubi_devices[i]->ubi_num, 1); 1057 mutex_unlock(&ubi_devices_mutex); 1058 } 1059 kmem_cache_destroy(ubi_wl_entry_slab); 1060 misc_deregister(&ubi_ctrl_cdev); 1061 class_remove_file(ubi_class, &ubi_version); 1062 class_destroy(ubi_class); 1063 mtd_devs = 0; 1064 } 1065 module_exit(ubi_exit); 1066 1067 /** 1068 * bytes_str_to_int - convert a string representing number of bytes to an 1069 * integer. 1070 * @str: the string to convert 1071 * 1072 * This function returns positive resulting integer in case of success and a 1073 * negative error code in case of failure. 1074 */ 1075 static int __init bytes_str_to_int(const char *str) 1076 { 1077 char *endp; 1078 unsigned long result; 1079 1080 result = simple_strtoul(str, &endp, 0); 1081 if (str == endp || result < 0) { 1082 printk(KERN_ERR "UBI error: incorrect bytes count: \"%s\"\n", 1083 str); 1084 return -EINVAL; 1085 } 1086 1087 switch (*endp) { 1088 case 'G': 1089 result *= 1024; 1090 case 'M': 1091 result *= 1024; 1092 case 'K': 1093 result *= 1024; 1094 if (endp[1] == 'i' && endp[2] == 'B') 1095 endp += 2; 1096 case '\0': 1097 break; 1098 default: 1099 printk(KERN_ERR "UBI error: incorrect bytes count: \"%s\"\n", 1100 str); 1101 return -EINVAL; 1102 } 1103 1104 return result; 1105 } 1106 1107 /** 1108 * ubi_mtd_param_parse - parse the 'mtd=' UBI parameter. 1109 * @val: the parameter value to parse 1110 * @kp: not used 1111 * 1112 * This function returns zero in case of success and a negative error code in 1113 * case of error. 1114 */ 1115 int __init ubi_mtd_param_parse(const char *val, struct kernel_param *kp) 1116 { 1117 int i, len; 1118 struct mtd_dev_param *p; 1119 char buf[MTD_PARAM_LEN_MAX]; 1120 char *pbuf = &buf[0]; 1121 char *tokens[2] = {NULL, NULL}; 1122 1123 if (!val) 1124 return -EINVAL; 1125 1126 if (mtd_devs == UBI_MAX_DEVICES) { 1127 printk(KERN_ERR "UBI error: too many parameters, max. is %d\n", 1128 UBI_MAX_DEVICES); 1129 return -EINVAL; 1130 } 1131 1132 len = strnlen(val, MTD_PARAM_LEN_MAX); 1133 if (len == MTD_PARAM_LEN_MAX) { 1134 printk(KERN_ERR "UBI error: parameter \"%s\" is too long, " 1135 "max. is %d\n", val, MTD_PARAM_LEN_MAX); 1136 return -EINVAL; 1137 } 1138 1139 if (len == 0) { 1140 printk(KERN_WARNING "UBI warning: empty 'mtd=' parameter - " 1141 "ignored\n"); 1142 return 0; 1143 } 1144 1145 strcpy(buf, val); 1146 1147 /* Get rid of the final newline */ 1148 if (buf[len - 1] == '\n') 1149 buf[len - 1] = '\0'; 1150 1151 for (i = 0; i < 2; i++) 1152 tokens[i] = strsep(&pbuf, ","); 1153 1154 if (pbuf) { 1155 printk(KERN_ERR "UBI error: too many arguments at \"%s\"\n", 1156 val); 1157 return -EINVAL; 1158 } 1159 1160 p = &mtd_dev_param[mtd_devs]; 1161 strcpy(&p->name[0], tokens[0]); 1162 1163 if (tokens[1]) 1164 p->vid_hdr_offs = bytes_str_to_int(tokens[1]); 1165 1166 if (p->vid_hdr_offs < 0) 1167 return p->vid_hdr_offs; 1168 1169 mtd_devs += 1; 1170 return 0; 1171 } 1172 1173 module_param_call(mtd, ubi_mtd_param_parse, NULL, NULL, 000); 1174 MODULE_PARM_DESC(mtd, "MTD devices to attach. Parameter format: " 1175 "mtd=<name|num>[,<vid_hdr_offs>].\n" 1176 "Multiple \"mtd\" parameters may be specified.\n" 1177 "MTD devices may be specified by their number or name.\n" 1178 "Optional \"vid_hdr_offs\" parameter specifies UBI VID " 1179 "header position and data starting position to be used " 1180 "by UBI.\n" 1181 "Example: mtd=content,1984 mtd=4 - attach MTD device" 1182 "with name \"content\" using VID header offset 1984, and " 1183 "MTD device number 4 with default VID header offset."); 1184 1185 MODULE_VERSION(__stringify(UBI_VERSION)); 1186 MODULE_DESCRIPTION("UBI - Unsorted Block Images"); 1187 MODULE_AUTHOR("Artem Bityutskiy"); 1188 MODULE_LICENSE("GPL"); 1189