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#include <linux/err.h> 37#include <linux/module.h> 38#include <linux/moduleparam.h> 39#include <linux/stringify.h> 40#include <linux/namei.h> 41#include <linux/stat.h> 42#include <linux/miscdevice.h> 43#include <linux/log2.h> 44#include <linux/kthread.h> 45#include <linux/kernel.h> 46#include <linux/slab.h> 47#include "ubi.h" 48 49/* Maximum length of the 'mtd=' parameter */ 50#define MTD_PARAM_LEN_MAX 64 51 52#ifdef CONFIG_MTD_UBI_MODULE 53#define ubi_is_module() 1 54#else 55#define ubi_is_module() 0 56#endif 57 58/** 59 * struct mtd_dev_param - MTD device parameter description data structure. 60 * @name: MTD character device node path, MTD device name, or MTD device number 61 * string 62 * @vid_hdr_offs: VID header offset 63 */ 64struct mtd_dev_param { 65 char name[MTD_PARAM_LEN_MAX]; 66 int vid_hdr_offs; 67}; 68 69/* Numbers of elements set in the @mtd_dev_param array */ 70static int __initdata mtd_devs; 71 72/* MTD devices specification parameters */ 73static struct mtd_dev_param __initdata mtd_dev_param[UBI_MAX_DEVICES]; 74 75/* Root UBI "class" object (corresponds to '/<sysfs>/class/ubi/') */ 76struct class *ubi_class; 77 78/* Slab cache for wear-leveling entries */ 79struct kmem_cache *ubi_wl_entry_slab; 80 81/* UBI control character device */ 82static struct miscdevice ubi_ctrl_cdev = { 83 .minor = MISC_DYNAMIC_MINOR, 84 .name = "ubi_ctrl", 85 .fops = &ubi_ctrl_cdev_operations, 86}; 87 88/* All UBI devices in system */ 89static struct ubi_device *ubi_devices[UBI_MAX_DEVICES]; 90 91/* Serializes UBI devices creations and removals */ 92DEFINE_MUTEX(ubi_devices_mutex); 93 94/* Protects @ubi_devices and @ubi->ref_count */ 95static DEFINE_SPINLOCK(ubi_devices_lock); 96 97/* "Show" method for files in '/<sysfs>/class/ubi/' */ 98static ssize_t ubi_version_show(struct class *class, struct class_attribute *attr, 99 char *buf) 100{ 101 return sprintf(buf, "%d\n", UBI_VERSION); 102} 103 104/* UBI version attribute ('/<sysfs>/class/ubi/version') */ 105static struct class_attribute ubi_version = 106 __ATTR(version, S_IRUGO, ubi_version_show, NULL); 107 108static ssize_t dev_attribute_show(struct device *dev, 109 struct device_attribute *attr, char *buf); 110 111/* UBI device attributes (correspond to files in '/<sysfs>/class/ubi/ubiX') */ 112static struct device_attribute dev_eraseblock_size = 113 __ATTR(eraseblock_size, S_IRUGO, dev_attribute_show, NULL); 114static struct device_attribute dev_avail_eraseblocks = 115 __ATTR(avail_eraseblocks, S_IRUGO, dev_attribute_show, NULL); 116static struct device_attribute dev_total_eraseblocks = 117 __ATTR(total_eraseblocks, S_IRUGO, dev_attribute_show, NULL); 118static struct device_attribute dev_volumes_count = 119 __ATTR(volumes_count, S_IRUGO, dev_attribute_show, NULL); 120static struct device_attribute dev_max_ec = 121 __ATTR(max_ec, S_IRUGO, dev_attribute_show, NULL); 122static struct device_attribute dev_reserved_for_bad = 123 __ATTR(reserved_for_bad, S_IRUGO, dev_attribute_show, NULL); 124static struct device_attribute dev_bad_peb_count = 125 __ATTR(bad_peb_count, S_IRUGO, dev_attribute_show, NULL); 126static struct device_attribute dev_max_vol_count = 127 __ATTR(max_vol_count, S_IRUGO, dev_attribute_show, NULL); 128static struct device_attribute dev_min_io_size = 129 __ATTR(min_io_size, S_IRUGO, dev_attribute_show, NULL); 130static struct device_attribute dev_bgt_enabled = 131 __ATTR(bgt_enabled, S_IRUGO, dev_attribute_show, NULL); 132static struct device_attribute dev_mtd_num = 133 __ATTR(mtd_num, S_IRUGO, dev_attribute_show, NULL); 134 135/** 136 * ubi_volume_notify - send a volume change notification. 137 * @ubi: UBI device description object 138 * @vol: volume description object of the changed volume 139 * @ntype: notification type to send (%UBI_VOLUME_ADDED, etc) 140 * 141 * This is a helper function which notifies all subscribers about a volume 142 * change event (creation, removal, re-sizing, re-naming, updating). Returns 143 * zero in case of success and a negative error code in case of failure. 144 */ 145int ubi_volume_notify(struct ubi_device *ubi, struct ubi_volume *vol, int ntype) 146{ 147 struct ubi_notification nt; 148 149 ubi_do_get_device_info(ubi, &nt.di); 150 ubi_do_get_volume_info(ubi, vol, &nt.vi); 151 return blocking_notifier_call_chain(&ubi_notifiers, ntype, &nt); 152} 153 154/** 155 * ubi_notify_all - send a notification to all volumes. 156 * @ubi: UBI device description object 157 * @ntype: notification type to send (%UBI_VOLUME_ADDED, etc) 158 * @nb: the notifier to call 159 * 160 * This function walks all volumes of UBI device @ubi and sends the @ntype 161 * notification for each volume. If @nb is %NULL, then all registered notifiers 162 * are called, otherwise only the @nb notifier is called. Returns the number of 163 * sent notifications. 164 */ 165int ubi_notify_all(struct ubi_device *ubi, int ntype, struct notifier_block *nb) 166{ 167 struct ubi_notification nt; 168 int i, count = 0; 169 170 ubi_do_get_device_info(ubi, &nt.di); 171 172 mutex_lock(&ubi->device_mutex); 173 for (i = 0; i < ubi->vtbl_slots; i++) { 174 /* 175 * Since the @ubi->device is locked, and we are not going to 176 * change @ubi->volumes, we do not have to lock 177 * @ubi->volumes_lock. 178 */ 179 if (!ubi->volumes[i]) 180 continue; 181 182 ubi_do_get_volume_info(ubi, ubi->volumes[i], &nt.vi); 183 if (nb) 184 nb->notifier_call(nb, ntype, &nt); 185 else 186 blocking_notifier_call_chain(&ubi_notifiers, ntype, 187 &nt); 188 count += 1; 189 } 190 mutex_unlock(&ubi->device_mutex); 191 192 return count; 193} 194 195/** 196 * ubi_enumerate_volumes - send "add" notification for all existing volumes. 197 * @nb: the notifier to call 198 * 199 * This function walks all UBI devices and volumes and sends the 200 * %UBI_VOLUME_ADDED notification for each volume. If @nb is %NULL, then all 201 * registered notifiers are called, otherwise only the @nb notifier is called. 202 * Returns the number of sent notifications. 203 */ 204int ubi_enumerate_volumes(struct notifier_block *nb) 205{ 206 int i, count = 0; 207 208 /* 209 * Since the @ubi_devices_mutex is locked, and we are not going to 210 * change @ubi_devices, we do not have to lock @ubi_devices_lock. 211 */ 212 for (i = 0; i < UBI_MAX_DEVICES; i++) { 213 struct ubi_device *ubi = ubi_devices[i]; 214 215 if (!ubi) 216 continue; 217 count += ubi_notify_all(ubi, UBI_VOLUME_ADDED, nb); 218 } 219 220 return count; 221} 222 223/** 224 * ubi_get_device - get UBI device. 225 * @ubi_num: UBI device number 226 * 227 * This function returns UBI device description object for UBI device number 228 * @ubi_num, or %NULL if the device does not exist. This function increases the 229 * device reference count to prevent removal of the device. In other words, the 230 * device cannot be removed if its reference count is not zero. 231 */ 232struct ubi_device *ubi_get_device(int ubi_num) 233{ 234 struct ubi_device *ubi; 235 236 spin_lock(&ubi_devices_lock); 237 ubi = ubi_devices[ubi_num]; 238 if (ubi) { 239 ubi_assert(ubi->ref_count >= 0); 240 ubi->ref_count += 1; 241 get_device(&ubi->dev); 242 } 243 spin_unlock(&ubi_devices_lock); 244 245 return ubi; 246} 247 248/** 249 * ubi_put_device - drop an UBI device reference. 250 * @ubi: UBI device description object 251 */ 252void ubi_put_device(struct ubi_device *ubi) 253{ 254 spin_lock(&ubi_devices_lock); 255 ubi->ref_count -= 1; 256 put_device(&ubi->dev); 257 spin_unlock(&ubi_devices_lock); 258} 259 260/** 261 * ubi_get_by_major - get UBI device by character device major number. 262 * @major: major number 263 * 264 * This function is similar to 'ubi_get_device()', but it searches the device 265 * by its major number. 266 */ 267struct ubi_device *ubi_get_by_major(int major) 268{ 269 int i; 270 struct ubi_device *ubi; 271 272 spin_lock(&ubi_devices_lock); 273 for (i = 0; i < UBI_MAX_DEVICES; i++) { 274 ubi = ubi_devices[i]; 275 if (ubi && MAJOR(ubi->cdev.dev) == major) { 276 ubi_assert(ubi->ref_count >= 0); 277 ubi->ref_count += 1; 278 get_device(&ubi->dev); 279 spin_unlock(&ubi_devices_lock); 280 return ubi; 281 } 282 } 283 spin_unlock(&ubi_devices_lock); 284 285 return NULL; 286} 287 288/** 289 * ubi_major2num - get UBI device number by character device major number. 290 * @major: major number 291 * 292 * This function searches UBI device number object by its major number. If UBI 293 * device was not found, this function returns -ENODEV, otherwise the UBI device 294 * number is returned. 295 */ 296int ubi_major2num(int major) 297{ 298 int i, ubi_num = -ENODEV; 299 300 spin_lock(&ubi_devices_lock); 301 for (i = 0; i < UBI_MAX_DEVICES; i++) { 302 struct ubi_device *ubi = ubi_devices[i]; 303 304 if (ubi && MAJOR(ubi->cdev.dev) == major) { 305 ubi_num = ubi->ubi_num; 306 break; 307 } 308 } 309 spin_unlock(&ubi_devices_lock); 310 311 return ubi_num; 312} 313 314/* "Show" method for files in '/<sysfs>/class/ubi/ubiX/' */ 315static ssize_t dev_attribute_show(struct device *dev, 316 struct device_attribute *attr, char *buf) 317{ 318 ssize_t ret; 319 struct ubi_device *ubi; 320 321 /* 322 * The below code looks weird, but it actually makes sense. We get the 323 * UBI device reference from the contained 'struct ubi_device'. But it 324 * is unclear if the device was removed or not yet. Indeed, if the 325 * device was removed before we increased its reference count, 326 * 'ubi_get_device()' will return -ENODEV and we fail. 327 * 328 * Remember, 'struct ubi_device' is freed in the release function, so 329 * we still can use 'ubi->ubi_num'. 330 */ 331 ubi = container_of(dev, struct ubi_device, dev); 332 ubi = ubi_get_device(ubi->ubi_num); 333 if (!ubi) 334 return -ENODEV; 335 336 if (attr == &dev_eraseblock_size) 337 ret = sprintf(buf, "%d\n", ubi->leb_size); 338 else if (attr == &dev_avail_eraseblocks) 339 ret = sprintf(buf, "%d\n", ubi->avail_pebs); 340 else if (attr == &dev_total_eraseblocks) 341 ret = sprintf(buf, "%d\n", ubi->good_peb_count); 342 else if (attr == &dev_volumes_count) 343 ret = sprintf(buf, "%d\n", ubi->vol_count - UBI_INT_VOL_COUNT); 344 else if (attr == &dev_max_ec) 345 ret = sprintf(buf, "%d\n", ubi->max_ec); 346 else if (attr == &dev_reserved_for_bad) 347 ret = sprintf(buf, "%d\n", ubi->beb_rsvd_pebs); 348 else if (attr == &dev_bad_peb_count) 349 ret = sprintf(buf, "%d\n", ubi->bad_peb_count); 350 else if (attr == &dev_max_vol_count) 351 ret = sprintf(buf, "%d\n", ubi->vtbl_slots); 352 else if (attr == &dev_min_io_size) 353 ret = sprintf(buf, "%d\n", ubi->min_io_size); 354 else if (attr == &dev_bgt_enabled) 355 ret = sprintf(buf, "%d\n", ubi->thread_enabled); 356 else if (attr == &dev_mtd_num) 357 ret = sprintf(buf, "%d\n", ubi->mtd->index); 358 else 359 ret = -EINVAL; 360 361 ubi_put_device(ubi); 362 return ret; 363} 364 365static void dev_release(struct device *dev) 366{ 367 struct ubi_device *ubi = container_of(dev, struct ubi_device, dev); 368 369 kfree(ubi); 370} 371 372/** 373 * ubi_sysfs_init - initialize sysfs for an UBI device. 374 * @ubi: UBI device description object 375 * @ref: set to %1 on exit in case of failure if a reference to @ubi->dev was 376 * taken 377 * 378 * This function returns zero in case of success and a negative error code in 379 * case of failure. 380 */ 381static int ubi_sysfs_init(struct ubi_device *ubi, int *ref) 382{ 383 int err; 384 385 ubi->dev.release = dev_release; 386 ubi->dev.devt = ubi->cdev.dev; 387 ubi->dev.class = ubi_class; 388 dev_set_name(&ubi->dev, UBI_NAME_STR"%d", ubi->ubi_num); 389 err = device_register(&ubi->dev); 390 if (err) 391 return err; 392 393 *ref = 1; 394 err = device_create_file(&ubi->dev, &dev_eraseblock_size); 395 if (err) 396 return err; 397 err = device_create_file(&ubi->dev, &dev_avail_eraseblocks); 398 if (err) 399 return err; 400 err = device_create_file(&ubi->dev, &dev_total_eraseblocks); 401 if (err) 402 return err; 403 err = device_create_file(&ubi->dev, &dev_volumes_count); 404 if (err) 405 return err; 406 err = device_create_file(&ubi->dev, &dev_max_ec); 407 if (err) 408 return err; 409 err = device_create_file(&ubi->dev, &dev_reserved_for_bad); 410 if (err) 411 return err; 412 err = device_create_file(&ubi->dev, &dev_bad_peb_count); 413 if (err) 414 return err; 415 err = device_create_file(&ubi->dev, &dev_max_vol_count); 416 if (err) 417 return err; 418 err = device_create_file(&ubi->dev, &dev_min_io_size); 419 if (err) 420 return err; 421 err = device_create_file(&ubi->dev, &dev_bgt_enabled); 422 if (err) 423 return err; 424 err = device_create_file(&ubi->dev, &dev_mtd_num); 425 return err; 426} 427 428/** 429 * ubi_sysfs_close - close sysfs for an UBI device. 430 * @ubi: UBI device description object 431 */ 432static void ubi_sysfs_close(struct ubi_device *ubi) 433{ 434 device_remove_file(&ubi->dev, &dev_mtd_num); 435 device_remove_file(&ubi->dev, &dev_bgt_enabled); 436 device_remove_file(&ubi->dev, &dev_min_io_size); 437 device_remove_file(&ubi->dev, &dev_max_vol_count); 438 device_remove_file(&ubi->dev, &dev_bad_peb_count); 439 device_remove_file(&ubi->dev, &dev_reserved_for_bad); 440 device_remove_file(&ubi->dev, &dev_max_ec); 441 device_remove_file(&ubi->dev, &dev_volumes_count); 442 device_remove_file(&ubi->dev, &dev_total_eraseblocks); 443 device_remove_file(&ubi->dev, &dev_avail_eraseblocks); 444 device_remove_file(&ubi->dev, &dev_eraseblock_size); 445 device_unregister(&ubi->dev); 446} 447 448/** 449 * kill_volumes - destroy all user volumes. 450 * @ubi: UBI device description object 451 */ 452static void kill_volumes(struct ubi_device *ubi) 453{ 454 int i; 455 456 for (i = 0; i < ubi->vtbl_slots; i++) 457 if (ubi->volumes[i]) 458 ubi_free_volume(ubi, ubi->volumes[i]); 459} 460 461/** 462 * uif_init - initialize user interfaces for an UBI device. 463 * @ubi: UBI device description object 464 * @ref: set to %1 on exit in case of failure if a reference to @ubi->dev was 465 * taken, otherwise set to %0 466 * 467 * This function initializes various user interfaces for an UBI device. If the 468 * initialization fails at an early stage, this function frees all the 469 * resources it allocated, returns an error, and @ref is set to %0. However, 470 * if the initialization fails after the UBI device was registered in the 471 * driver core subsystem, this function takes a reference to @ubi->dev, because 472 * otherwise the release function ('dev_release()') would free whole @ubi 473 * object. The @ref argument is set to %1 in this case. The caller has to put 474 * this reference. 475 * 476 * This function returns zero in case of success and a negative error code in 477 * case of failure. 478 */ 479static int uif_init(struct ubi_device *ubi, int *ref) 480{ 481 int i, err; 482 dev_t dev; 483 484 *ref = 0; 485 sprintf(ubi->ubi_name, UBI_NAME_STR "%d", ubi->ubi_num); 486 487 /* 488 * Major numbers for the UBI character devices are allocated 489 * dynamically. Major numbers of volume character devices are 490 * equivalent to ones of the corresponding UBI character device. Minor 491 * numbers of UBI character devices are 0, while minor numbers of 492 * volume character devices start from 1. Thus, we allocate one major 493 * number and ubi->vtbl_slots + 1 minor numbers. 494 */ 495 err = alloc_chrdev_region(&dev, 0, ubi->vtbl_slots + 1, ubi->ubi_name); 496 if (err) { 497 ubi_err("cannot register UBI character devices"); 498 return err; 499 } 500 501 ubi_assert(MINOR(dev) == 0); 502 cdev_init(&ubi->cdev, &ubi_cdev_operations); 503 dbg_gen("%s major is %u", ubi->ubi_name, MAJOR(dev)); 504 ubi->cdev.owner = THIS_MODULE; 505 506 err = cdev_add(&ubi->cdev, dev, 1); 507 if (err) { 508 ubi_err("cannot add character device"); 509 goto out_unreg; 510 } 511 512 err = ubi_sysfs_init(ubi, ref); 513 if (err) 514 goto out_sysfs; 515 516 for (i = 0; i < ubi->vtbl_slots; i++) 517 if (ubi->volumes[i]) { 518 err = ubi_add_volume(ubi, ubi->volumes[i]); 519 if (err) { 520 ubi_err("cannot add volume %d", i); 521 goto out_volumes; 522 } 523 } 524 525 return 0; 526 527out_volumes: 528 kill_volumes(ubi); 529out_sysfs: 530 if (*ref) 531 get_device(&ubi->dev); 532 ubi_sysfs_close(ubi); 533 cdev_del(&ubi->cdev); 534out_unreg: 535 unregister_chrdev_region(ubi->cdev.dev, ubi->vtbl_slots + 1); 536 ubi_err("cannot initialize UBI %s, error %d", ubi->ubi_name, err); 537 return err; 538} 539 540/** 541 * uif_close - close user interfaces for an UBI device. 542 * @ubi: UBI device description object 543 * 544 * Note, since this function un-registers UBI volume device objects (@vol->dev), 545 * the memory allocated voe the volumes is freed as well (in the release 546 * function). 547 */ 548static void uif_close(struct ubi_device *ubi) 549{ 550 kill_volumes(ubi); 551 ubi_sysfs_close(ubi); 552 cdev_del(&ubi->cdev); 553 unregister_chrdev_region(ubi->cdev.dev, ubi->vtbl_slots + 1); 554} 555 556/** 557 * free_internal_volumes - free internal volumes. 558 * @ubi: UBI device description object 559 */ 560static void free_internal_volumes(struct ubi_device *ubi) 561{ 562 int i; 563 564 for (i = ubi->vtbl_slots; 565 i < ubi->vtbl_slots + UBI_INT_VOL_COUNT; i++) { 566 kfree(ubi->volumes[i]->eba_tbl); 567 kfree(ubi->volumes[i]); 568 } 569} 570 571/** 572 * attach_by_scanning - attach an MTD device using scanning method. 573 * @ubi: UBI device descriptor 574 * 575 * This function returns zero in case of success and a negative error code in 576 * case of failure. 577 * 578 * Note, currently this is the only method to attach UBI devices. Hopefully in 579 * the future we'll have more scalable attaching methods and avoid full media 580 * scanning. But even in this case scanning will be needed as a fall-back 581 * attaching method if there are some on-flash table corruptions. 582 */ 583static int attach_by_scanning(struct ubi_device *ubi) 584{ 585 int err; 586 struct ubi_scan_info *si; 587 588 si = ubi_scan(ubi); 589 if (IS_ERR(si)) 590 return PTR_ERR(si); 591 592 ubi->bad_peb_count = si->bad_peb_count; 593 ubi->good_peb_count = ubi->peb_count - ubi->bad_peb_count; 594 ubi->max_ec = si->max_ec; 595 ubi->mean_ec = si->mean_ec; 596 ubi_msg("max. sequence number: %llu", si->max_sqnum); 597 598 err = ubi_read_volume_table(ubi, si); 599 if (err) 600 goto out_si; 601 602 err = ubi_wl_init_scan(ubi, si); 603 if (err) 604 goto out_vtbl; 605 606 err = ubi_eba_init_scan(ubi, si); 607 if (err) 608 goto out_wl; 609 610 ubi_scan_destroy_si(si); 611 return 0; 612 613out_wl: 614 ubi_wl_close(ubi); 615out_vtbl: 616 free_internal_volumes(ubi); 617 vfree(ubi->vtbl); 618out_si: 619 ubi_scan_destroy_si(si); 620 return err; 621} 622 623/** 624 * io_init - initialize I/O sub-system for a given UBI device. 625 * @ubi: UBI device description object 626 * 627 * If @ubi->vid_hdr_offset or @ubi->leb_start is zero, default offsets are 628 * assumed: 629 * o EC header is always at offset zero - this cannot be changed; 630 * o VID header starts just after the EC header at the closest address 631 * aligned to @io->hdrs_min_io_size; 632 * o data starts just after the VID header at the closest address aligned to 633 * @io->min_io_size 634 * 635 * This function returns zero in case of success and a negative error code in 636 * case of failure. 637 */ 638static int io_init(struct ubi_device *ubi) 639{ 640 if (ubi->mtd->numeraseregions != 0) { 641 /* 642 * Some flashes have several erase regions. Different regions 643 * may have different eraseblock size and other 644 * characteristics. It looks like mostly multi-region flashes 645 * have one "main" region and one or more small regions to 646 * store boot loader code or boot parameters or whatever. I 647 * guess we should just pick the largest region. But this is 648 * not implemented. 649 */ 650 ubi_err("multiple regions, not implemented"); 651 return -EINVAL; 652 } 653 654 if (ubi->vid_hdr_offset < 0) 655 return -EINVAL; 656 657 /* 658 * Note, in this implementation we support MTD devices with 0x7FFFFFFF 659 * physical eraseblocks maximum. 660 */ 661 662 ubi->peb_size = ubi->mtd->erasesize; 663 ubi->peb_count = mtd_div_by_eb(ubi->mtd->size, ubi->mtd); 664 ubi->flash_size = ubi->mtd->size; 665 666 if (ubi->mtd->block_isbad && ubi->mtd->block_markbad) 667 ubi->bad_allowed = 1; 668 669 if (ubi->mtd->type == MTD_NORFLASH) { 670 ubi_assert(ubi->mtd->writesize == 1); 671 ubi->nor_flash = 1; 672 } 673 674 ubi->min_io_size = ubi->mtd->writesize; 675 ubi->hdrs_min_io_size = ubi->mtd->writesize >> ubi->mtd->subpage_sft; 676 677 /* 678 * Make sure minimal I/O unit is power of 2. Note, there is no 679 * fundamental reason for this assumption. It is just an optimization 680 * which allows us to avoid costly division operations. 681 */ 682 if (!is_power_of_2(ubi->min_io_size)) { 683 ubi_err("min. I/O unit (%d) is not power of 2", 684 ubi->min_io_size); 685 return -EINVAL; 686 } 687 688 ubi_assert(ubi->hdrs_min_io_size > 0); 689 ubi_assert(ubi->hdrs_min_io_size <= ubi->min_io_size); 690 ubi_assert(ubi->min_io_size % ubi->hdrs_min_io_size == 0); 691 692 /* Calculate default aligned sizes of EC and VID headers */ 693 ubi->ec_hdr_alsize = ALIGN(UBI_EC_HDR_SIZE, ubi->hdrs_min_io_size); 694 ubi->vid_hdr_alsize = ALIGN(UBI_VID_HDR_SIZE, ubi->hdrs_min_io_size); 695 696 dbg_msg("min_io_size %d", ubi->min_io_size); 697 dbg_msg("hdrs_min_io_size %d", ubi->hdrs_min_io_size); 698 dbg_msg("ec_hdr_alsize %d", ubi->ec_hdr_alsize); 699 dbg_msg("vid_hdr_alsize %d", ubi->vid_hdr_alsize); 700 701 if (ubi->vid_hdr_offset == 0) 702 /* Default offset */ 703 ubi->vid_hdr_offset = ubi->vid_hdr_aloffset = 704 ubi->ec_hdr_alsize; 705 else { 706 ubi->vid_hdr_aloffset = ubi->vid_hdr_offset & 707 ~(ubi->hdrs_min_io_size - 1); 708 ubi->vid_hdr_shift = ubi->vid_hdr_offset - 709 ubi->vid_hdr_aloffset; 710 } 711 712 /* Similar for the data offset */ 713 ubi->leb_start = ubi->vid_hdr_offset + UBI_EC_HDR_SIZE; 714 ubi->leb_start = ALIGN(ubi->leb_start, ubi->min_io_size); 715 716 dbg_msg("vid_hdr_offset %d", ubi->vid_hdr_offset); 717 dbg_msg("vid_hdr_aloffset %d", ubi->vid_hdr_aloffset); 718 dbg_msg("vid_hdr_shift %d", ubi->vid_hdr_shift); 719 dbg_msg("leb_start %d", ubi->leb_start); 720 721 /* The shift must be aligned to 32-bit boundary */ 722 if (ubi->vid_hdr_shift % 4) { 723 ubi_err("unaligned VID header shift %d", 724 ubi->vid_hdr_shift); 725 return -EINVAL; 726 } 727 728 /* Check sanity */ 729 if (ubi->vid_hdr_offset < UBI_EC_HDR_SIZE || 730 ubi->leb_start < ubi->vid_hdr_offset + UBI_VID_HDR_SIZE || 731 ubi->leb_start > ubi->peb_size - UBI_VID_HDR_SIZE || 732 ubi->leb_start & (ubi->min_io_size - 1)) { 733 ubi_err("bad VID header (%d) or data offsets (%d)", 734 ubi->vid_hdr_offset, ubi->leb_start); 735 return -EINVAL; 736 } 737 738 /* 739 * Set maximum amount of physical erroneous eraseblocks to be 10%. 740 * Erroneous PEB are those which have read errors. 741 */ 742 ubi->max_erroneous = ubi->peb_count / 10; 743 if (ubi->max_erroneous < 16) 744 ubi->max_erroneous = 16; 745 dbg_msg("max_erroneous %d", ubi->max_erroneous); 746 747 /* 748 * It may happen that EC and VID headers are situated in one minimal 749 * I/O unit. In this case we can only accept this UBI image in 750 * read-only mode. 751 */ 752 if (ubi->vid_hdr_offset + UBI_VID_HDR_SIZE <= ubi->hdrs_min_io_size) { 753 ubi_warn("EC and VID headers are in the same minimal I/O unit, " 754 "switch to read-only mode"); 755 ubi->ro_mode = 1; 756 } 757 758 ubi->leb_size = ubi->peb_size - ubi->leb_start; 759 760 if (!(ubi->mtd->flags & MTD_WRITEABLE)) { 761 ubi_msg("MTD device %d is write-protected, attach in " 762 "read-only mode", ubi->mtd->index); 763 ubi->ro_mode = 1; 764 } 765 766 ubi_msg("physical eraseblock size: %d bytes (%d KiB)", 767 ubi->peb_size, ubi->peb_size >> 10); 768 ubi_msg("logical eraseblock size: %d bytes", ubi->leb_size); 769 ubi_msg("smallest flash I/O unit: %d", ubi->min_io_size); 770 if (ubi->hdrs_min_io_size != ubi->min_io_size) 771 ubi_msg("sub-page size: %d", 772 ubi->hdrs_min_io_size); 773 ubi_msg("VID header offset: %d (aligned %d)", 774 ubi->vid_hdr_offset, ubi->vid_hdr_aloffset); 775 ubi_msg("data offset: %d", ubi->leb_start); 776 777 /* 778 * Note, ideally, we have to initialize ubi->bad_peb_count here. But 779 * unfortunately, MTD does not provide this information. We should loop 780 * over all physical eraseblocks and invoke mtd->block_is_bad() for 781 * each physical eraseblock. So, we skip ubi->bad_peb_count 782 * uninitialized and initialize it after scanning. 783 */ 784 785 return 0; 786} 787 788/** 789 * autoresize - re-size the volume which has the "auto-resize" flag set. 790 * @ubi: UBI device description object 791 * @vol_id: ID of the volume to re-size 792 * 793 * This function re-sizes the volume marked by the @UBI_VTBL_AUTORESIZE_FLG in 794 * the volume table to the largest possible size. See comments in ubi-header.h 795 * for more description of the flag. Returns zero in case of success and a 796 * negative error code in case of failure. 797 */ 798static int autoresize(struct ubi_device *ubi, int vol_id) 799{ 800 struct ubi_volume_desc desc; 801 struct ubi_volume *vol = ubi->volumes[vol_id]; 802 int err, old_reserved_pebs = vol->reserved_pebs; 803 804 /* 805 * Clear the auto-resize flag in the volume in-memory copy of the 806 * volume table, and 'ubi_resize_volume()' will propagate this change 807 * to the flash. 808 */ 809 ubi->vtbl[vol_id].flags &= ~UBI_VTBL_AUTORESIZE_FLG; 810 811 if (ubi->avail_pebs == 0) { 812 struct ubi_vtbl_record vtbl_rec; 813 814 /* 815 * No available PEBs to re-size the volume, clear the flag on 816 * flash and exit. 817 */ 818 memcpy(&vtbl_rec, &ubi->vtbl[vol_id], 819 sizeof(struct ubi_vtbl_record)); 820 err = ubi_change_vtbl_record(ubi, vol_id, &vtbl_rec); 821 if (err) 822 ubi_err("cannot clean auto-resize flag for volume %d", 823 vol_id); 824 } else { 825 desc.vol = vol; 826 err = ubi_resize_volume(&desc, 827 old_reserved_pebs + ubi->avail_pebs); 828 if (err) 829 ubi_err("cannot auto-resize volume %d", vol_id); 830 } 831 832 if (err) 833 return err; 834 835 ubi_msg("volume %d (\"%s\") re-sized from %d to %d LEBs", vol_id, 836 vol->name, old_reserved_pebs, vol->reserved_pebs); 837 return 0; 838} 839 840/** 841 * ubi_attach_mtd_dev - attach an MTD device. 842 * @mtd: MTD device description object 843 * @ubi_num: number to assign to the new UBI device 844 * @vid_hdr_offset: VID header offset 845 * 846 * This function attaches MTD device @mtd_dev to UBI and assign @ubi_num number 847 * to the newly created UBI device, unless @ubi_num is %UBI_DEV_NUM_AUTO, in 848 * which case this function finds a vacant device number and assigns it 849 * automatically. Returns the new UBI device number in case of success and a 850 * negative error code in case of failure. 851 * 852 * Note, the invocations of this function has to be serialized by the 853 * @ubi_devices_mutex. 854 */ 855int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num, int vid_hdr_offset) 856{ 857 struct ubi_device *ubi; 858 int i, err, ref = 0; 859 860 /* 861 * Check if we already have the same MTD device attached. 862 * 863 * Note, this function assumes that UBI devices creations and deletions 864 * are serialized, so it does not take the &ubi_devices_lock. 865 */ 866 for (i = 0; i < UBI_MAX_DEVICES; i++) { 867 ubi = ubi_devices[i]; 868 if (ubi && mtd->index == ubi->mtd->index) { 869 dbg_err("mtd%d is already attached to ubi%d", 870 mtd->index, i); 871 return -EEXIST; 872 } 873 } 874 875 /* 876 * Make sure this MTD device is not emulated on top of an UBI volume 877 * already. Well, generally this recursion works fine, but there are 878 * different problems like the UBI module takes a reference to itself 879 * by attaching (and thus, opening) the emulated MTD device. This 880 * results in inability to unload the module. And in general it makes 881 * no sense to attach emulated MTD devices, so we prohibit this. 882 */ 883 if (mtd->type == MTD_UBIVOLUME) { 884 ubi_err("refuse attaching mtd%d - it is already emulated on " 885 "top of UBI", mtd->index); 886 return -EINVAL; 887 } 888 889 if (ubi_num == UBI_DEV_NUM_AUTO) { 890 /* Search for an empty slot in the @ubi_devices array */ 891 for (ubi_num = 0; ubi_num < UBI_MAX_DEVICES; ubi_num++) 892 if (!ubi_devices[ubi_num]) 893 break; 894 if (ubi_num == UBI_MAX_DEVICES) { 895 dbg_err("only %d UBI devices may be created", 896 UBI_MAX_DEVICES); 897 return -ENFILE; 898 } 899 } else { 900 if (ubi_num >= UBI_MAX_DEVICES) 901 return -EINVAL; 902 903 /* Make sure ubi_num is not busy */ 904 if (ubi_devices[ubi_num]) { 905 dbg_err("ubi%d already exists", ubi_num); 906 return -EEXIST; 907 } 908 } 909 910 ubi = kzalloc(sizeof(struct ubi_device), GFP_KERNEL); 911 if (!ubi) 912 return -ENOMEM; 913 914 ubi->mtd = mtd; 915 ubi->ubi_num = ubi_num; 916 ubi->vid_hdr_offset = vid_hdr_offset; 917 ubi->autoresize_vol_id = -1; 918 919 mutex_init(&ubi->buf_mutex); 920 mutex_init(&ubi->ckvol_mutex); 921 mutex_init(&ubi->device_mutex); 922 spin_lock_init(&ubi->volumes_lock); 923 924 ubi_msg("attaching mtd%d to ubi%d", mtd->index, ubi_num); 925 926 err = io_init(ubi); 927 if (err) 928 goto out_free; 929 930 err = -ENOMEM; 931 ubi->peb_buf1 = vmalloc(ubi->peb_size); 932 if (!ubi->peb_buf1) 933 goto out_free; 934 935 ubi->peb_buf2 = vmalloc(ubi->peb_size); 936 if (!ubi->peb_buf2) 937 goto out_free; 938 939#ifdef CONFIG_MTD_UBI_DEBUG_PARANOID 940 mutex_init(&ubi->dbg_buf_mutex); 941 ubi->dbg_peb_buf = vmalloc(ubi->peb_size); 942 if (!ubi->dbg_peb_buf) 943 goto out_free; 944#endif 945 946 err = attach_by_scanning(ubi); 947 if (err) { 948 dbg_err("failed to attach by scanning, error %d", err); 949 goto out_free; 950 } 951 952 if (ubi->autoresize_vol_id != -1) { 953 err = autoresize(ubi, ubi->autoresize_vol_id); 954 if (err) 955 goto out_detach; 956 } 957 958 err = uif_init(ubi, &ref); 959 if (err) 960 goto out_detach; 961 962 ubi->bgt_thread = kthread_create(ubi_thread, ubi, ubi->bgt_name); 963 if (IS_ERR(ubi->bgt_thread)) { 964 err = PTR_ERR(ubi->bgt_thread); 965 ubi_err("cannot spawn \"%s\", error %d", ubi->bgt_name, 966 err); 967 goto out_uif; 968 } 969 970 ubi_msg("attached mtd%d to ubi%d", mtd->index, ubi_num); 971 ubi_msg("MTD device name: \"%s\"", mtd->name); 972 ubi_msg("MTD device size: %llu MiB", ubi->flash_size >> 20); 973 ubi_msg("number of good PEBs: %d", ubi->good_peb_count); 974 ubi_msg("number of bad PEBs: %d", ubi->bad_peb_count); 975 ubi_msg("max. allowed volumes: %d", ubi->vtbl_slots); 976 ubi_msg("wear-leveling threshold: %d", CONFIG_MTD_UBI_WL_THRESHOLD); 977 ubi_msg("number of internal volumes: %d", UBI_INT_VOL_COUNT); 978 ubi_msg("number of user volumes: %d", 979 ubi->vol_count - UBI_INT_VOL_COUNT); 980 ubi_msg("available PEBs: %d", ubi->avail_pebs); 981 ubi_msg("total number of reserved PEBs: %d", ubi->rsvd_pebs); 982 ubi_msg("number of PEBs reserved for bad PEB handling: %d", 983 ubi->beb_rsvd_pebs); 984 ubi_msg("max/mean erase counter: %d/%d", ubi->max_ec, ubi->mean_ec); 985 ubi_msg("image sequence number: %d", ubi->image_seq); 986 987 /* 988 * The below lock makes sure we do not race with 'ubi_thread()' which 989 * checks @ubi->thread_enabled. Otherwise we may fail to wake it up. 990 */ 991 spin_lock(&ubi->wl_lock); 992 if (!DBG_DISABLE_BGT) 993 ubi->thread_enabled = 1; 994 wake_up_process(ubi->bgt_thread); 995 spin_unlock(&ubi->wl_lock); 996 997 ubi_devices[ubi_num] = ubi; 998 ubi_notify_all(ubi, UBI_VOLUME_ADDED, NULL); 999 return ubi_num; 1000 1001out_uif: 1002 uif_close(ubi); 1003out_detach: 1004 ubi_wl_close(ubi); 1005 free_internal_volumes(ubi); 1006 vfree(ubi->vtbl); 1007out_free: 1008 vfree(ubi->peb_buf1); 1009 vfree(ubi->peb_buf2); 1010#ifdef CONFIG_MTD_UBI_DEBUG_PARANOID 1011 vfree(ubi->dbg_peb_buf); 1012#endif 1013 if (ref) 1014 put_device(&ubi->dev); 1015 else 1016 kfree(ubi); 1017 return err; 1018} 1019 1020/** 1021 * ubi_detach_mtd_dev - detach an MTD device. 1022 * @ubi_num: UBI device number to detach from 1023 * @anyway: detach MTD even if device reference count is not zero 1024 * 1025 * This function destroys an UBI device number @ubi_num and detaches the 1026 * underlying MTD device. Returns zero in case of success and %-EBUSY if the 1027 * UBI device is busy and cannot be destroyed, and %-EINVAL if it does not 1028 * exist. 1029 * 1030 * Note, the invocations of this function has to be serialized by the 1031 * @ubi_devices_mutex. 1032 */ 1033int ubi_detach_mtd_dev(int ubi_num, int anyway) 1034{ 1035 struct ubi_device *ubi; 1036 1037 if (ubi_num < 0 || ubi_num >= UBI_MAX_DEVICES) 1038 return -EINVAL; 1039 1040 ubi = ubi_get_device(ubi_num); 1041 if (!ubi) 1042 return -EINVAL; 1043 1044 spin_lock(&ubi_devices_lock); 1045 put_device(&ubi->dev); 1046 ubi->ref_count -= 1; 1047 if (ubi->ref_count) { 1048 if (!anyway) { 1049 spin_unlock(&ubi_devices_lock); 1050 return -EBUSY; 1051 } 1052 /* This may only happen if there is a bug */ 1053 ubi_err("%s reference count %d, destroy anyway", 1054 ubi->ubi_name, ubi->ref_count); 1055 } 1056 ubi_devices[ubi_num] = NULL; 1057 spin_unlock(&ubi_devices_lock); 1058 1059 ubi_assert(ubi_num == ubi->ubi_num); 1060 ubi_notify_all(ubi, UBI_VOLUME_REMOVED, NULL); 1061 dbg_msg("detaching mtd%d from ubi%d", ubi->mtd->index, ubi_num); 1062 1063 /* 1064 * Before freeing anything, we have to stop the background thread to 1065 * prevent it from doing anything on this device while we are freeing. 1066 */ 1067 if (ubi->bgt_thread) 1068 kthread_stop(ubi->bgt_thread); 1069 1070 /* 1071 * Get a reference to the device in order to prevent 'dev_release()' 1072 * from freeing the @ubi object. 1073 */ 1074 get_device(&ubi->dev); 1075 1076 uif_close(ubi); 1077 ubi_wl_close(ubi); 1078 free_internal_volumes(ubi); 1079 vfree(ubi->vtbl); 1080 put_mtd_device(ubi->mtd); 1081 vfree(ubi->peb_buf1); 1082 vfree(ubi->peb_buf2); 1083#ifdef CONFIG_MTD_UBI_DEBUG_PARANOID 1084 vfree(ubi->dbg_peb_buf); 1085#endif 1086 ubi_msg("mtd%d is detached from ubi%d", ubi->mtd->index, ubi->ubi_num); 1087 put_device(&ubi->dev); 1088 return 0; 1089} 1090 1091/** 1092 * open_mtd_by_chdev - open an MTD device by its character device node path. 1093 * @mtd_dev: MTD character device node path 1094 * 1095 * This helper function opens an MTD device by its character node device path. 1096 * Returns MTD device description object in case of success and a negative 1097 * error code in case of failure. 1098 */ 1099static struct mtd_info * __init open_mtd_by_chdev(const char *mtd_dev) 1100{ 1101 int err, major, minor, mode; 1102 struct path path; 1103 1104 /* Probably this is an MTD character device node path */ 1105 err = kern_path(mtd_dev, LOOKUP_FOLLOW, &path); 1106 if (err) 1107 return ERR_PTR(err); 1108 1109 /* MTD device number is defined by the major / minor numbers */ 1110 major = imajor(path.dentry->d_inode); 1111 minor = iminor(path.dentry->d_inode); 1112 mode = path.dentry->d_inode->i_mode; 1113 path_put(&path); 1114 if (major != MTD_CHAR_MAJOR || !S_ISCHR(mode)) 1115 return ERR_PTR(-EINVAL); 1116 1117 if (minor & 1) 1118 /* 1119 * Just do not think the "/dev/mtdrX" devices support is need, 1120 * so do not support them to avoid doing extra work. 1121 */ 1122 return ERR_PTR(-EINVAL); 1123 1124 return get_mtd_device(NULL, minor / 2); 1125} 1126 1127/** 1128 * open_mtd_device - open MTD device by name, character device path, or number. 1129 * @mtd_dev: name, character device node path, or MTD device device number 1130 * 1131 * This function tries to open and MTD device described by @mtd_dev string, 1132 * which is first treated as ASCII MTD device number, and if it is not true, it 1133 * is treated as MTD device name, and if that is also not true, it is treated 1134 * as MTD character device node path. Returns MTD device description object in 1135 * case of success and a negative error code in case of failure. 1136 */ 1137static struct mtd_info * __init open_mtd_device(const char *mtd_dev) 1138{ 1139 struct mtd_info *mtd; 1140 int mtd_num; 1141 char *endp; 1142 1143 mtd_num = simple_strtoul(mtd_dev, &endp, 0); 1144 if (*endp != '\0' || mtd_dev == endp) { 1145 /* 1146 * This does not look like an ASCII integer, probably this is 1147 * MTD device name. 1148 */ 1149 mtd = get_mtd_device_nm(mtd_dev); 1150 if (IS_ERR(mtd) && PTR_ERR(mtd) == -ENODEV) 1151 /* Probably this is an MTD character device node path */ 1152 mtd = open_mtd_by_chdev(mtd_dev); 1153 } else 1154 mtd = get_mtd_device(NULL, mtd_num); 1155 1156 return mtd; 1157} 1158 1159static int __init ubi_init(void) 1160{ 1161 int err, i, k; 1162 1163 /* Ensure that EC and VID headers have correct size */ 1164 BUILD_BUG_ON(sizeof(struct ubi_ec_hdr) != 64); 1165 BUILD_BUG_ON(sizeof(struct ubi_vid_hdr) != 64); 1166 1167 if (mtd_devs > UBI_MAX_DEVICES) { 1168 ubi_err("too many MTD devices, maximum is %d", UBI_MAX_DEVICES); 1169 return -EINVAL; 1170 } 1171 1172 /* Create base sysfs directory and sysfs files */ 1173 ubi_class = class_create(THIS_MODULE, UBI_NAME_STR); 1174 if (IS_ERR(ubi_class)) { 1175 err = PTR_ERR(ubi_class); 1176 ubi_err("cannot create UBI class"); 1177 goto out; 1178 } 1179 1180 err = class_create_file(ubi_class, &ubi_version); 1181 if (err) { 1182 ubi_err("cannot create sysfs file"); 1183 goto out_class; 1184 } 1185 1186 err = misc_register(&ubi_ctrl_cdev); 1187 if (err) { 1188 ubi_err("cannot register device"); 1189 goto out_version; 1190 } 1191 1192 ubi_wl_entry_slab = kmem_cache_create("ubi_wl_entry_slab", 1193 sizeof(struct ubi_wl_entry), 1194 0, 0, NULL); 1195 if (!ubi_wl_entry_slab) 1196 goto out_dev_unreg; 1197 1198 /* Attach MTD devices */ 1199 for (i = 0; i < mtd_devs; i++) { 1200 struct mtd_dev_param *p = &mtd_dev_param[i]; 1201 struct mtd_info *mtd; 1202 1203 cond_resched(); 1204 1205 mtd = open_mtd_device(p->name); 1206 if (IS_ERR(mtd)) { 1207 err = PTR_ERR(mtd); 1208 goto out_detach; 1209 } 1210 1211 mutex_lock(&ubi_devices_mutex); 1212 err = ubi_attach_mtd_dev(mtd, UBI_DEV_NUM_AUTO, 1213 p->vid_hdr_offs); 1214 mutex_unlock(&ubi_devices_mutex); 1215 if (err < 0) { 1216 ubi_err("cannot attach mtd%d", mtd->index); 1217 put_mtd_device(mtd); 1218 1219 /* 1220 * Originally UBI stopped initializing on any error. 1221 * However, later on it was found out that this 1222 * behavior is not very good when UBI is compiled into 1223 * the kernel and the MTD devices to attach are passed 1224 * through the command line. Indeed, UBI failure 1225 * stopped whole boot sequence. 1226 * 1227 * To fix this, we changed the behavior for the 1228 * non-module case, but preserved the old behavior for 1229 * the module case, just for compatibility. This is a 1230 * little inconsistent, though. 1231 */ 1232 if (ubi_is_module()) 1233 goto out_detach; 1234 } 1235 } 1236 1237 return 0; 1238 1239out_detach: 1240 for (k = 0; k < i; k++) 1241 if (ubi_devices[k]) { 1242 mutex_lock(&ubi_devices_mutex); 1243 ubi_detach_mtd_dev(ubi_devices[k]->ubi_num, 1); 1244 mutex_unlock(&ubi_devices_mutex); 1245 } 1246 kmem_cache_destroy(ubi_wl_entry_slab); 1247out_dev_unreg: 1248 misc_deregister(&ubi_ctrl_cdev); 1249out_version: 1250 class_remove_file(ubi_class, &ubi_version); 1251out_class: 1252 class_destroy(ubi_class); 1253out: 1254 ubi_err("UBI error: cannot initialize UBI, error %d", err); 1255 return err; 1256} 1257module_init(ubi_init); 1258 1259static void __exit ubi_exit(void) 1260{ 1261 int i; 1262 1263 for (i = 0; i < UBI_MAX_DEVICES; i++) 1264 if (ubi_devices[i]) { 1265 mutex_lock(&ubi_devices_mutex); 1266 ubi_detach_mtd_dev(ubi_devices[i]->ubi_num, 1); 1267 mutex_unlock(&ubi_devices_mutex); 1268 } 1269 kmem_cache_destroy(ubi_wl_entry_slab); 1270 misc_deregister(&ubi_ctrl_cdev); 1271 class_remove_file(ubi_class, &ubi_version); 1272 class_destroy(ubi_class); 1273} 1274module_exit(ubi_exit); 1275 1276/** 1277 * bytes_str_to_int - convert a number of bytes string into an integer. 1278 * @str: the string to convert 1279 * 1280 * This function returns positive resulting integer in case of success and a 1281 * negative error code in case of failure. 1282 */ 1283static int __init bytes_str_to_int(const char *str) 1284{ 1285 char *endp; 1286 unsigned long result; 1287 1288 result = simple_strtoul(str, &endp, 0); 1289 if (str == endp || result >= INT_MAX) { 1290 printk(KERN_ERR "UBI error: incorrect bytes count: \"%s\"\n", 1291 str); 1292 return -EINVAL; 1293 } 1294 1295 switch (*endp) { 1296 case 'G': 1297 result *= 1024; 1298 case 'M': 1299 result *= 1024; 1300 case 'K': 1301 result *= 1024; 1302 if (endp[1] == 'i' && endp[2] == 'B') 1303 endp += 2; 1304 case '\0': 1305 break; 1306 default: 1307 printk(KERN_ERR "UBI error: incorrect bytes count: \"%s\"\n", 1308 str); 1309 return -EINVAL; 1310 } 1311 1312 return result; 1313} 1314 1315/** 1316 * ubi_mtd_param_parse - parse the 'mtd=' UBI parameter. 1317 * @val: the parameter value to parse 1318 * @kp: not used 1319 * 1320 * This function returns zero in case of success and a negative error code in 1321 * case of error. 1322 */ 1323static int __init ubi_mtd_param_parse(const char *val, struct kernel_param *kp) 1324{ 1325 int i, len; 1326 struct mtd_dev_param *p; 1327 char buf[MTD_PARAM_LEN_MAX]; 1328 char *pbuf = &buf[0]; 1329 char *tokens[2] = {NULL, NULL}; 1330 1331 if (!val) 1332 return -EINVAL; 1333 1334 if (mtd_devs == UBI_MAX_DEVICES) { 1335 printk(KERN_ERR "UBI error: too many parameters, max. is %d\n", 1336 UBI_MAX_DEVICES); 1337 return -EINVAL; 1338 } 1339 1340 len = strnlen(val, MTD_PARAM_LEN_MAX); 1341 if (len == MTD_PARAM_LEN_MAX) { 1342 printk(KERN_ERR "UBI error: parameter \"%s\" is too long, " 1343 "max. is %d\n", val, MTD_PARAM_LEN_MAX); 1344 return -EINVAL; 1345 } 1346 1347 if (len == 0) { 1348 printk(KERN_WARNING "UBI warning: empty 'mtd=' parameter - " 1349 "ignored\n"); 1350 return 0; 1351 } 1352 1353 strcpy(buf, val); 1354 1355 /* Get rid of the final newline */ 1356 if (buf[len - 1] == '\n') 1357 buf[len - 1] = '\0'; 1358 1359 for (i = 0; i < 2; i++) 1360 tokens[i] = strsep(&pbuf, ","); 1361 1362 if (pbuf) { 1363 printk(KERN_ERR "UBI error: too many arguments at \"%s\"\n", 1364 val); 1365 return -EINVAL; 1366 } 1367 1368 p = &mtd_dev_param[mtd_devs]; 1369 strcpy(&p->name[0], tokens[0]); 1370 1371 if (tokens[1]) 1372 p->vid_hdr_offs = bytes_str_to_int(tokens[1]); 1373 1374 if (p->vid_hdr_offs < 0) 1375 return p->vid_hdr_offs; 1376 1377 mtd_devs += 1; 1378 return 0; 1379} 1380 1381module_param_call(mtd, ubi_mtd_param_parse, NULL, NULL, 000); 1382MODULE_PARM_DESC(mtd, "MTD devices to attach. Parameter format: " 1383 "mtd=<name|num|path>[,<vid_hdr_offs>].\n" 1384 "Multiple \"mtd\" parameters may be specified.\n" 1385 "MTD devices may be specified by their number, name, or " 1386 "path to the MTD character device node.\n" 1387 "Optional \"vid_hdr_offs\" parameter specifies UBI VID " 1388 "header position to be used by UBI.\n" 1389 "Example 1: mtd=/dev/mtd0 - attach MTD device " 1390 "/dev/mtd0.\n" 1391 "Example 2: mtd=content,1984 mtd=4 - attach MTD device " 1392 "with name \"content\" using VID header offset 1984, and " 1393 "MTD device number 4 with default VID header offset."); 1394 1395MODULE_VERSION(__stringify(UBI_VERSION)); 1396MODULE_DESCRIPTION("UBI - Unsorted Block Images"); 1397MODULE_AUTHOR("Artem Bityutskiy"); 1398MODULE_LICENSE("GPL"); 1399