drivers/mtd/ubi/build.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Copyright (c) International Business Machines Corp., 2006
   4  * Copyright (c) Nokia Corporation, 2007
   5  *
   6  * Author: Artem Bityutskiy (Битюцкий Артём),
   7  *         Frank Haverkamp
   8  */
   9
  10 /*
  11  * This file includes UBI initialization and building of UBI devices.
  12  *
  13  * When UBI is initialized, it attaches all the MTD devices specified as the
  14  * module load parameters or the kernel boot parameters. If MTD devices were
  15  * specified, UBI does not attach any MTD device, but it is possible to do
  16  * later using the "UBI control device".
  17  */
  18
  19 #include <linux/err.h>
  20 #include <linux/module.h>
  21 #include <linux/moduleparam.h>
  22 #include <linux/stringify.h>
  23 #include <linux/namei.h>
  24 #include <linux/stat.h>
  25 #include <linux/miscdevice.h>
  26 #include <linux/mtd/partitions.h>
  27 #include <linux/log2.h>
  28 #include <linux/kthread.h>
  29 #include <linux/kernel.h>
  30 #include <linux/of.h>
  31 #include <linux/slab.h>
  32 #include <linux/major.h>
  33 #include "ubi.h"
  34
  35 /* Maximum length of the 'mtd=' parameter */
  36 #define MTD_PARAM_LEN_MAX 64
  37
  38 /* Maximum number of comma-separated items in the 'mtd=' parameter */
  39 #define MTD_PARAM_MAX_COUNT 6
  40
  41 /* Maximum value for the number of bad PEBs per 1024 PEBs */
  42 #define MAX_MTD_UBI_BEB_LIMIT 768
  43
  44 #ifdef CONFIG_MTD_UBI_MODULE
  45 #define ubi_is_module() 1
  46 #else
  47 #define ubi_is_module() 0
  48 #endif
  49
  50 /**
  51  * struct mtd_dev_param - MTD device parameter description data structure.
  52  * @name: MTD character device node path, MTD device name, or MTD device number
  53  *        string
  54  * @ubi_num: UBI number
  55  * @vid_hdr_offs: VID header offset
  56  * @max_beb_per1024: maximum expected number of bad PEBs per 1024 PEBs
  57  * @enable_fm: enable fastmap when value is non-zero
  58  * @need_resv_pool: reserve pool->max_size pebs when value is none-zero
  59  */
  60 struct mtd_dev_param {
  61         char name[MTD_PARAM_LEN_MAX];
  62         int ubi_num;
  63         int vid_hdr_offs;
  64         int max_beb_per1024;
  65         int enable_fm;
  66         int need_resv_pool;
  67 };
  68
  69 /* Numbers of elements set in the @mtd_dev_param array */
  70 static int mtd_devs;
  71
  72 /* MTD devices specification parameters */
  73 static struct mtd_dev_param mtd_dev_param[UBI_MAX_DEVICES];
  74 #ifdef CONFIG_MTD_UBI_FASTMAP
  75 /* UBI module parameter to enable fastmap automatically on non-fastmap images */
  76 static bool fm_autoconvert;
  77 static bool fm_debug;
  78 #endif
  79
  80 /* Slab cache for wear-leveling entries */
  81 struct kmem_cache *ubi_wl_entry_slab;
  82
  83 /* UBI control character device */
  84 static struct miscdevice ubi_ctrl_cdev = {
  85         .minor = MISC_DYNAMIC_MINOR,
  86         .name = "ubi_ctrl",
  87         .fops = &ubi_ctrl_cdev_operations,
  88 };
  89
  90 /* All UBI devices in system */
  91 static struct ubi_device *ubi_devices[UBI_MAX_DEVICES];
  92
  93 /* Serializes UBI devices creations and removals */
  94 DEFINE_MUTEX(ubi_devices_mutex);
  95
  96 /* Protects @ubi_devices, @ubi->ref_count and @ubi->is_dead */
  97 static DEFINE_SPINLOCK(ubi_devices_lock);
  98
  99 /* "Show" method for files in '/<sysfs>/class/ubi/' */
 100 /* UBI version attribute ('/<sysfs>/class/ubi/version') */
 101 static ssize_t version_show(const struct class *class, const struct class_attribute *attr,
 102                             char *buf)
 103 {
 104         return sprintf(buf, "%d\n", UBI_VERSION);
 105 }
 106 static CLASS_ATTR_RO(version);
 107
 108 static struct attribute *ubi_class_attrs[] = {
 109         &class_attr_version.attr,
 110         NULL,
 111 };
 112 ATTRIBUTE_GROUPS(ubi_class);
 113
 114 /* Root UBI "class" object (corresponds to '/<sysfs>/class/ubi/') */
 115 const struct class ubi_class = {
 116         .name           = UBI_NAME_STR,
 117         .class_groups   = ubi_class_groups,
 118 };
 119
 120 static ssize_t dev_attribute_show(struct device *dev,
 121                                   struct device_attribute *attr, char *buf);
 122
 123 /* UBI device attributes (correspond to files in '/<sysfs>/class/ubi/ubiX') */
 124 static struct device_attribute dev_eraseblock_size =
 125         __ATTR(eraseblock_size, S_IRUGO, dev_attribute_show, NULL);
 126 static struct device_attribute dev_avail_eraseblocks =
 127         __ATTR(avail_eraseblocks, S_IRUGO, dev_attribute_show, NULL);
 128 static struct device_attribute dev_total_eraseblocks =
 129         __ATTR(total_eraseblocks, S_IRUGO, dev_attribute_show, NULL);
 130 static struct device_attribute dev_volumes_count =
 131         __ATTR(volumes_count, S_IRUGO, dev_attribute_show, NULL);
 132 static struct device_attribute dev_max_ec =
 133         __ATTR(max_ec, S_IRUGO, dev_attribute_show, NULL);
 134 static struct device_attribute dev_reserved_for_bad =
 135         __ATTR(reserved_for_bad, S_IRUGO, dev_attribute_show, NULL);
 136 static struct device_attribute dev_bad_peb_count =
 137         __ATTR(bad_peb_count, S_IRUGO, dev_attribute_show, NULL);
 138 static struct device_attribute dev_max_vol_count =
 139         __ATTR(max_vol_count, S_IRUGO, dev_attribute_show, NULL);
 140 static struct device_attribute dev_min_io_size =
 141         __ATTR(min_io_size, S_IRUGO, dev_attribute_show, NULL);
 142 static struct device_attribute dev_bgt_enabled =
 143         __ATTR(bgt_enabled, S_IRUGO, dev_attribute_show, NULL);
 144 static struct device_attribute dev_mtd_num =
 145         __ATTR(mtd_num, S_IRUGO, dev_attribute_show, NULL);
 146 static struct device_attribute dev_ro_mode =
 147         __ATTR(ro_mode, S_IRUGO, dev_attribute_show, NULL);
 148
 149 /**
 150  * ubi_volume_notify - send a volume change notification.
 151  * @ubi: UBI device description object
 152  * @vol: volume description object of the changed volume
 153  * @ntype: notification type to send (%UBI_VOLUME_ADDED, etc)
 154  *
 155  * This is a helper function which notifies all subscribers about a volume
 156  * change event (creation, removal, re-sizing, re-naming, updating). Returns
 157  * zero in case of success and a negative error code in case of failure.
 158  */
 159 int ubi_volume_notify(struct ubi_device *ubi, struct ubi_volume *vol, int ntype)
 160 {
 161         int ret;
 162         struct ubi_notification nt;
 163
 164         ubi_do_get_device_info(ubi, &nt.di);
 165         ubi_do_get_volume_info(ubi, vol, &nt.vi);
 166
 167         switch (ntype) {
 168         case UBI_VOLUME_ADDED:
 169         case UBI_VOLUME_REMOVED:
 170         case UBI_VOLUME_RESIZED:
 171         case UBI_VOLUME_RENAMED:
 172                 ret = ubi_update_fastmap(ubi);
 173                 if (ret)
 174                         ubi_msg(ubi, "Unable to write a new fastmap: %i", ret);
 175         }
 176
 177         return blocking_notifier_call_chain(&ubi_notifiers, ntype, &nt);
 178 }
 179
 180 /**
 181  * ubi_notify_all - send a notification to all volumes.
 182  * @ubi: UBI device description object
 183  * @ntype: notification type to send (%UBI_VOLUME_ADDED, etc)
 184  * @nb: the notifier to call
 185  *
 186  * This function walks all volumes of UBI device @ubi and sends the @ntype
 187  * notification for each volume. If @nb is %NULL, then all registered notifiers
 188  * are called, otherwise only the @nb notifier is called. Returns the number of
 189  * sent notifications.
 190  */
 191 int ubi_notify_all(struct ubi_device *ubi, int ntype, struct notifier_block *nb)
 192 {
 193         struct ubi_notification nt;
 194         int i, count = 0;
 195
 196         ubi_do_get_device_info(ubi, &nt.di);
 197
 198         mutex_lock(&ubi->device_mutex);
 199         for (i = 0; i < ubi->vtbl_slots; i++) {
 200                 /*
 201                  * Since the @ubi->device is locked, and we are not going to
 202                  * change @ubi->volumes, we do not have to lock
 203                  * @ubi->volumes_lock.
 204                  */
 205                 if (!ubi->volumes[i])
 206                         continue;
 207
 208                 ubi_do_get_volume_info(ubi, ubi->volumes[i], &nt.vi);
 209                 if (nb)
 210                         nb->notifier_call(nb, ntype, &nt);
 211                 else
 212                         blocking_notifier_call_chain(&ubi_notifiers, ntype,
 213                                                      &nt);
 214                 count += 1;
 215         }
 216         mutex_unlock(&ubi->device_mutex);
 217
 218         return count;
 219 }
 220
 221 /**
 222  * ubi_enumerate_volumes - send "add" notification for all existing volumes.
 223  * @nb: the notifier to call
 224  *
 225  * This function walks all UBI devices and volumes and sends the
 226  * %UBI_VOLUME_ADDED notification for each volume. If @nb is %NULL, then all
 227  * registered notifiers are called, otherwise only the @nb notifier is called.
 228  * Returns the number of sent notifications.
 229  */
 230 int ubi_enumerate_volumes(struct notifier_block *nb)
 231 {
 232         int i, count = 0;
 233
 234         /*
 235          * Since the @ubi_devices_mutex is locked, and we are not going to
 236          * change @ubi_devices, we do not have to lock @ubi_devices_lock.
 237          */
 238         for (i = 0; i < UBI_MAX_DEVICES; i++) {
 239                 struct ubi_device *ubi = ubi_devices[i];
 240
 241                 if (!ubi)
 242                         continue;
 243                 count += ubi_notify_all(ubi, UBI_VOLUME_ADDED, nb);
 244         }
 245
 246         return count;
 247 }
 248
 249 /**
 250  * ubi_get_device - get UBI device.
 251  * @ubi_num: UBI device number
 252  *
 253  * This function returns UBI device description object for UBI device number
 254  * @ubi_num, or %NULL if the device does not exist. This function increases the
 255  * device reference count to prevent removal of the device. In other words, the
 256  * device cannot be removed if its reference count is not zero.
 257  */
 258 struct ubi_device *ubi_get_device(int ubi_num)
 259 {
 260         struct ubi_device *ubi;
 261
 262         spin_lock(&ubi_devices_lock);
 263         ubi = ubi_devices[ubi_num];
 264         if (ubi && ubi->is_dead)
 265                 ubi = NULL;
 266
 267         if (ubi) {
 268                 ubi_assert(ubi->ref_count >= 0);
 269                 ubi->ref_count += 1;
 270                 get_device(&ubi->dev);
 271         }
 272         spin_unlock(&ubi_devices_lock);
 273
 274         return ubi;
 275 }
 276
 277 /**
 278  * ubi_put_device - drop an UBI device reference.
 279  * @ubi: UBI device description object
 280  */
 281 void ubi_put_device(struct ubi_device *ubi)
 282 {
 283         spin_lock(&ubi_devices_lock);
 284         ubi->ref_count -= 1;
 285         put_device(&ubi->dev);
 286         spin_unlock(&ubi_devices_lock);
 287 }
 288
 289 /**
 290  * ubi_get_by_major - get UBI device by character device major number.
 291  * @major: major number
 292  *
 293  * This function is similar to 'ubi_get_device()', but it searches the device
 294  * by its major number.
 295  */
 296 struct ubi_device *ubi_get_by_major(int major)
 297 {
 298         int i;
 299         struct ubi_device *ubi;
 300
 301         spin_lock(&ubi_devices_lock);
 302         for (i = 0; i < UBI_MAX_DEVICES; i++) {
 303                 ubi = ubi_devices[i];
 304                 if (ubi && !ubi->is_dead && MAJOR(ubi->cdev.dev) == major) {
 305                         ubi_assert(ubi->ref_count >= 0);
 306                         ubi->ref_count += 1;
 307                         get_device(&ubi->dev);
 308                         spin_unlock(&ubi_devices_lock);
 309                         return ubi;
 310                 }
 311         }
 312         spin_unlock(&ubi_devices_lock);
 313
 314         return NULL;
 315 }
 316
 317 /**
 318  * ubi_major2num - get UBI device number by character device major number.
 319  * @major: major number
 320  *
 321  * This function searches UBI device number object by its major number. If UBI
 322  * device was not found, this function returns -ENODEV, otherwise the UBI device
 323  * number is returned.
 324  */
 325 int ubi_major2num(int major)
 326 {
 327         int i, ubi_num = -ENODEV;
 328
 329         spin_lock(&ubi_devices_lock);
 330         for (i = 0; i < UBI_MAX_DEVICES; i++) {
 331                 struct ubi_device *ubi = ubi_devices[i];
 332
 333                 if (ubi && !ubi->is_dead && MAJOR(ubi->cdev.dev) == major) {
 334                         ubi_num = ubi->ubi_num;
 335                         break;
 336                 }
 337         }
 338         spin_unlock(&ubi_devices_lock);
 339
 340         return ubi_num;
 341 }
 342
 343 /* "Show" method for files in '/<sysfs>/class/ubi/ubiX/' */
 344 static ssize_t dev_attribute_show(struct device *dev,
 345                                   struct device_attribute *attr, char *buf)
 346 {
 347         ssize_t ret;
 348         struct ubi_device *ubi;
 349
 350         /*
 351          * The below code looks weird, but it actually makes sense. We get the
 352          * UBI device reference from the contained 'struct ubi_device'. But it
 353          * is unclear if the device was removed or not yet. Indeed, if the
 354          * device was removed before we increased its reference count,
 355          * 'ubi_get_device()' will return -ENODEV and we fail.
 356          *
 357          * Remember, 'struct ubi_device' is freed in the release function, so
 358          * we still can use 'ubi->ubi_num'.
 359          */
 360         ubi = container_of(dev, struct ubi_device, dev);
 361
 362         if (attr == &dev_eraseblock_size)
 363                 ret = sprintf(buf, "%d\n", ubi->leb_size);
 364         else if (attr == &dev_avail_eraseblocks)
 365                 ret = sprintf(buf, "%d\n", ubi->avail_pebs);
 366         else if (attr == &dev_total_eraseblocks)
 367                 ret = sprintf(buf, "%d\n", ubi->good_peb_count);
 368         else if (attr == &dev_volumes_count)
 369                 ret = sprintf(buf, "%d\n", ubi->vol_count - UBI_INT_VOL_COUNT);
 370         else if (attr == &dev_max_ec)
 371                 ret = sprintf(buf, "%d\n", ubi->max_ec);
 372         else if (attr == &dev_reserved_for_bad)
 373                 ret = sprintf(buf, "%d\n", ubi->beb_rsvd_pebs);
 374         else if (attr == &dev_bad_peb_count)
 375                 ret = sprintf(buf, "%d\n", ubi->bad_peb_count);
 376         else if (attr == &dev_max_vol_count)
 377                 ret = sprintf(buf, "%d\n", ubi->vtbl_slots);
 378         else if (attr == &dev_min_io_size)
 379                 ret = sprintf(buf, "%d\n", ubi->min_io_size);
 380         else if (attr == &dev_bgt_enabled)
 381                 ret = sprintf(buf, "%d\n", ubi->thread_enabled);
 382         else if (attr == &dev_mtd_num)
 383                 ret = sprintf(buf, "%d\n", ubi->mtd->index);
 384         else if (attr == &dev_ro_mode)
 385                 ret = sprintf(buf, "%d\n", ubi->ro_mode);
 386         else
 387                 ret = -EINVAL;
 388
 389         return ret;
 390 }
 391
 392 static struct attribute *ubi_dev_attrs[] = {
 393         &dev_eraseblock_size.attr,
 394         &dev_avail_eraseblocks.attr,
 395         &dev_total_eraseblocks.attr,
 396         &dev_volumes_count.attr,
 397         &dev_max_ec.attr,
 398         &dev_reserved_for_bad.attr,
 399         &dev_bad_peb_count.attr,
 400         &dev_max_vol_count.attr,
 401         &dev_min_io_size.attr,
 402         &dev_bgt_enabled.attr,
 403         &dev_mtd_num.attr,
 404         &dev_ro_mode.attr,
 405         NULL
 406 };
 407 ATTRIBUTE_GROUPS(ubi_dev);
 408
 409 static void dev_release(struct device *dev)
 410 {
 411         struct ubi_device *ubi = container_of(dev, struct ubi_device, dev);
 412
 413         kfree(ubi);
 414 }
 415
 416 /**
 417  * kill_volumes - destroy all user volumes.
 418  * @ubi: UBI device description object
 419  */
 420 static void kill_volumes(struct ubi_device *ubi)
 421 {
 422         int i;
 423
 424         for (i = 0; i < ubi->vtbl_slots; i++)
 425                 if (ubi->volumes[i])
 426                         ubi_free_volume(ubi, ubi->volumes[i]);
 427 }
 428
 429 /**
 430  * uif_init - initialize user interfaces for an UBI device.
 431  * @ubi: UBI device description object
 432  *
 433  * This function initializes various user interfaces for an UBI device. If the
 434  * initialization fails at an early stage, this function frees all the
 435  * resources it allocated, returns an error.
 436  *
 437  * This function returns zero in case of success and a negative error code in
 438  * case of failure.
 439  */
 440 static int uif_init(struct ubi_device *ubi)
 441 {
 442         int i, err;
 443         dev_t dev;
 444
 445         sprintf(ubi->ubi_name, UBI_NAME_STR "%d", ubi->ubi_num);
 446
 447         /*
 448          * Major numbers for the UBI character devices are allocated
 449          * dynamically. Major numbers of volume character devices are
 450          * equivalent to ones of the corresponding UBI character device. Minor
 451          * numbers of UBI character devices are 0, while minor numbers of
 452          * volume character devices start from 1. Thus, we allocate one major
 453          * number and ubi->vtbl_slots + 1 minor numbers.
 454          */
 455         err = alloc_chrdev_region(&dev, 0, ubi->vtbl_slots + 1, ubi->ubi_name);
 456         if (err) {
 457                 ubi_err(ubi, "cannot register UBI character devices");
 458                 return err;
 459         }
 460
 461         ubi->dev.devt = dev;
 462
 463         ubi_assert(MINOR(dev) == 0);
 464         cdev_init(&ubi->cdev, &ubi_cdev_operations);
 465         dbg_gen("%s major is %u", ubi->ubi_name, MAJOR(dev));
 466         ubi->cdev.owner = THIS_MODULE;
 467
 468         dev_set_name(&ubi->dev, UBI_NAME_STR "%d", ubi->ubi_num);
 469         err = cdev_device_add(&ubi->cdev, &ubi->dev);
 470         if (err)
 471                 goto out_unreg;
 472
 473         for (i = 0; i < ubi->vtbl_slots; i++)
 474                 if (ubi->volumes[i]) {
 475                         err = ubi_add_volume(ubi, ubi->volumes[i]);
 476                         if (err) {
 477                                 ubi_err(ubi, "cannot add volume %d", i);
 478                                 ubi->volumes[i] = NULL;
 479                                 goto out_volumes;
 480                         }
 481                 }
 482
 483         return 0;
 484
 485 out_volumes:
 486         kill_volumes(ubi);
 487         cdev_device_del(&ubi->cdev, &ubi->dev);
 488 out_unreg:
 489         unregister_chrdev_region(ubi->cdev.dev, ubi->vtbl_slots + 1);
 490         ubi_err(ubi, "cannot initialize UBI %s, error %d",
 491                 ubi->ubi_name, err);
 492         return err;
 493 }
 494
 495 /**
 496  * uif_close - close user interfaces for an UBI device.
 497  * @ubi: UBI device description object
 498  *
 499  * Note, since this function un-registers UBI volume device objects (@vol->dev),
 500  * the memory allocated voe the volumes is freed as well (in the release
 501  * function).
 502  */
 503 static void uif_close(struct ubi_device *ubi)
 504 {
 505         kill_volumes(ubi);
 506         cdev_device_del(&ubi->cdev, &ubi->dev);
 507         unregister_chrdev_region(ubi->cdev.dev, ubi->vtbl_slots + 1);
 508 }
 509
 510 /**
 511  * ubi_free_volumes_from - free volumes from specific index.
 512  * @ubi: UBI device description object
 513  * @from: the start index used for volume free.
 514  */
 515 static void ubi_free_volumes_from(struct ubi_device *ubi, int from)
 516 {
 517         int i;
 518
 519         for (i = from; i < ubi->vtbl_slots + UBI_INT_VOL_COUNT; i++) {
 520                 if (!ubi->volumes[i] || ubi->volumes[i]->is_dead)
 521                         continue;
 522                 ubi_eba_replace_table(ubi->volumes[i], NULL);
 523                 ubi_fastmap_destroy_checkmap(ubi->volumes[i]);
 524                 kfree(ubi->volumes[i]);
 525                 ubi->volumes[i] = NULL;
 526         }
 527 }
 528
 529 /**
 530  * ubi_free_all_volumes - free all volumes.
 531  * @ubi: UBI device description object
 532  */
 533 void ubi_free_all_volumes(struct ubi_device *ubi)
 534 {
 535         ubi_free_volumes_from(ubi, 0);
 536 }
 537
 538 /**
 539  * ubi_free_internal_volumes - free internal volumes.
 540  * @ubi: UBI device description object
 541  */
 542 void ubi_free_internal_volumes(struct ubi_device *ubi)
 543 {
 544         ubi_free_volumes_from(ubi, ubi->vtbl_slots);
 545 }
 546
 547 static int get_bad_peb_limit(const struct ubi_device *ubi, int max_beb_per1024)
 548 {
 549         int limit, device_pebs;
 550         uint64_t device_size;
 551
 552         if (!max_beb_per1024) {
 553                 /*
 554                  * Since max_beb_per1024 has not been set by the user in either
 555                  * the cmdline or Kconfig, use mtd_max_bad_blocks to set the
 556                  * limit if it is supported by the device.
 557                  */
 558                 limit = mtd_max_bad_blocks(ubi->mtd, 0, ubi->mtd->size);
 559                 if (limit < 0)
 560                         return 0;
 561                 return limit;
 562         }
 563
 564         /*
 565          * Here we are using size of the entire flash chip and
 566          * not just the MTD partition size because the maximum
 567          * number of bad eraseblocks is a percentage of the
 568          * whole device and bad eraseblocks are not fairly
 569          * distributed over the flash chip. So the worst case
 570          * is that all the bad eraseblocks of the chip are in
 571          * the MTD partition we are attaching (ubi->mtd).
 572          */
 573         device_size = mtd_get_device_size(ubi->mtd);
 574         device_pebs = mtd_div_by_eb(device_size, ubi->mtd);
 575         limit = mult_frac(device_pebs, max_beb_per1024, 1024);
 576
 577         /* Round it up */
 578         if (mult_frac(limit, 1024, max_beb_per1024) < device_pebs)
 579                 limit += 1;
 580
 581         return limit;
 582 }
 583
 584 /**
 585  * io_init - initialize I/O sub-system for a given UBI device.
 586  * @ubi: UBI device description object
 587  * @max_beb_per1024: maximum expected number of bad PEB per 1024 PEBs
 588  *
 589  * If @ubi->vid_hdr_offset or @ubi->leb_start is zero, default offsets are
 590  * assumed:
 591  *   o EC header is always at offset zero - this cannot be changed;
 592  *   o VID header starts just after the EC header at the closest address
 593  *     aligned to @io->hdrs_min_io_size;
 594  *   o data starts just after the VID header at the closest address aligned to
 595  *     @io->min_io_size
 596  *
 597  * This function returns zero in case of success and a negative error code in
 598  * case of failure.
 599  */
 600 static int io_init(struct ubi_device *ubi, int max_beb_per1024)
 601 {
 602         dbg_gen("sizeof(struct ubi_ainf_peb) %zu", sizeof(struct ubi_ainf_peb));
 603         dbg_gen("sizeof(struct ubi_wl_entry) %zu", sizeof(struct ubi_wl_entry));
 604
 605         if (ubi->mtd->numeraseregions != 0) {
 606                 /*
 607                  * Some flashes have several erase regions. Different regions
 608                  * may have different eraseblock size and other
 609                  * characteristics. It looks like mostly multi-region flashes
 610                  * have one "main" region and one or more small regions to
 611                  * store boot loader code or boot parameters or whatever. I
 612                  * guess we should just pick the largest region. But this is
 613                  * not implemented.
 614                  */
 615                 ubi_err(ubi, "multiple regions, not implemented");
 616                 return -EINVAL;
 617         }
 618
 619         if (ubi->vid_hdr_offset < 0)
 620                 return -EINVAL;
 621
 622         /*
 623          * Note, in this implementation we support MTD devices with 0x7FFFFFFF
 624          * physical eraseblocks maximum.
 625          */
 626
 627         ubi->peb_size   = ubi->mtd->erasesize;
 628         ubi->peb_count  = mtd_div_by_eb(ubi->mtd->size, ubi->mtd);
 629         ubi->flash_size = ubi->mtd->size;
 630
 631         if (mtd_can_have_bb(ubi->mtd)) {
 632                 ubi->bad_allowed = 1;
 633                 ubi->bad_peb_limit = get_bad_peb_limit(ubi, max_beb_per1024);
 634         }
 635
 636         if (ubi->mtd->type == MTD_NORFLASH)
 637                 ubi->nor_flash = 1;
 638
 639         ubi->min_io_size = ubi->mtd->writesize;
 640         ubi->hdrs_min_io_size = ubi->mtd->writesize >> ubi->mtd->subpage_sft;
 641
 642         /*
 643          * Make sure minimal I/O unit is power of 2. Note, there is no
 644          * fundamental reason for this assumption. It is just an optimization
 645          * which allows us to avoid costly division operations.
 646          */
 647         if (!is_power_of_2(ubi->min_io_size)) {
 648                 ubi_err(ubi, "min. I/O unit (%d) is not power of 2",
 649                         ubi->min_io_size);
 650                 return -EINVAL;
 651         }
 652
 653         ubi_assert(ubi->hdrs_min_io_size > 0);
 654         ubi_assert(ubi->hdrs_min_io_size <= ubi->min_io_size);
 655         ubi_assert(ubi->min_io_size % ubi->hdrs_min_io_size == 0);
 656
 657         ubi->max_write_size = ubi->mtd->writebufsize;
 658         /*
 659          * Maximum write size has to be greater or equivalent to min. I/O
 660          * size, and be multiple of min. I/O size.
 661          */
 662         if (ubi->max_write_size < ubi->min_io_size ||
 663             ubi->max_write_size % ubi->min_io_size ||
 664             !is_power_of_2(ubi->max_write_size)) {
 665                 ubi_err(ubi, "bad write buffer size %d for %d min. I/O unit",
 666                         ubi->max_write_size, ubi->min_io_size);
 667                 return -EINVAL;
 668         }
 669
 670         /* Calculate default aligned sizes of EC and VID headers */
 671         ubi->ec_hdr_alsize = ALIGN(UBI_EC_HDR_SIZE, ubi->hdrs_min_io_size);
 672         ubi->vid_hdr_alsize = ALIGN(UBI_VID_HDR_SIZE, ubi->hdrs_min_io_size);
 673
 674         dbg_gen("min_io_size      %d", ubi->min_io_size);
 675         dbg_gen("max_write_size   %d", ubi->max_write_size);
 676         dbg_gen("hdrs_min_io_size %d", ubi->hdrs_min_io_size);
 677         dbg_gen("ec_hdr_alsize    %d", ubi->ec_hdr_alsize);
 678         dbg_gen("vid_hdr_alsize   %d", ubi->vid_hdr_alsize);
 679
 680         if (ubi->vid_hdr_offset == 0)
 681                 /* Default offset */
 682                 ubi->vid_hdr_offset = ubi->vid_hdr_aloffset =
 683                                       ubi->ec_hdr_alsize;
 684         else {
 685                 ubi->vid_hdr_aloffset = ubi->vid_hdr_offset &
 686                                                 ~(ubi->hdrs_min_io_size - 1);
 687                 ubi->vid_hdr_shift = ubi->vid_hdr_offset -
 688                                                 ubi->vid_hdr_aloffset;
 689         }
 690
 691         /*
 692          * Memory allocation for VID header is ubi->vid_hdr_alsize
 693          * which is described in comments in io.c.
 694          * Make sure VID header shift + UBI_VID_HDR_SIZE not exceeds
 695          * ubi->vid_hdr_alsize, so that all vid header operations
 696          * won't access memory out of bounds.
 697          */
 698         if ((ubi->vid_hdr_shift + UBI_VID_HDR_SIZE) > ubi->vid_hdr_alsize) {
 699                 ubi_err(ubi, "Invalid VID header offset %d, VID header shift(%d)"
 700                         " + VID header size(%zu) > VID header aligned size(%d).",
 701                         ubi->vid_hdr_offset, ubi->vid_hdr_shift,
 702                         UBI_VID_HDR_SIZE, ubi->vid_hdr_alsize);
 703                 return -EINVAL;
 704         }
 705
 706         /* Similar for the data offset */
 707         ubi->leb_start = ubi->vid_hdr_offset + UBI_VID_HDR_SIZE;
 708         ubi->leb_start = ALIGN(ubi->leb_start, ubi->min_io_size);
 709
 710         dbg_gen("vid_hdr_offset   %d", ubi->vid_hdr_offset);
 711         dbg_gen("vid_hdr_aloffset %d", ubi->vid_hdr_aloffset);
 712         dbg_gen("vid_hdr_shift    %d", ubi->vid_hdr_shift);
 713         dbg_gen("leb_start        %d", ubi->leb_start);
 714
 715         /* The shift must be aligned to 32-bit boundary */
 716         if (ubi->vid_hdr_shift % 4) {
 717                 ubi_err(ubi, "unaligned VID header shift %d",
 718                         ubi->vid_hdr_shift);
 719                 return -EINVAL;
 720         }
 721
 722         /* Check sanity */
 723         if (ubi->vid_hdr_offset < UBI_EC_HDR_SIZE ||
 724             ubi->leb_start < ubi->vid_hdr_offset + UBI_VID_HDR_SIZE ||
 725             ubi->leb_start > ubi->peb_size - UBI_VID_HDR_SIZE ||
 726             ubi->leb_start & (ubi->min_io_size - 1)) {
 727                 ubi_err(ubi, "bad VID header (%d) or data offsets (%d)",
 728                         ubi->vid_hdr_offset, ubi->leb_start);
 729                 return -EINVAL;
 730         }
 731
 732         /*
 733          * Set maximum amount of physical erroneous eraseblocks to be 10%.
 734          * Erroneous PEB are those which have read errors.
 735          */
 736         ubi->max_erroneous = ubi->peb_count / 10;
 737         if (ubi->max_erroneous < 16)
 738                 ubi->max_erroneous = 16;
 739         dbg_gen("max_erroneous    %d", ubi->max_erroneous);
 740
 741         /*
 742          * It may happen that EC and VID headers are situated in one minimal
 743          * I/O unit. In this case we can only accept this UBI image in
 744          * read-only mode.
 745          */
 746         if (ubi->vid_hdr_offset + UBI_VID_HDR_SIZE <= ubi->hdrs_min_io_size) {
 747                 ubi_warn(ubi, "EC and VID headers are in the same minimal I/O unit, switch to read-only mode");
 748                 ubi->ro_mode = 1;
 749         }
 750
 751         ubi->leb_size = ubi->peb_size - ubi->leb_start;
 752
 753         if (!(ubi->mtd->flags & MTD_WRITEABLE)) {
 754                 ubi_msg(ubi, "MTD device %d is write-protected, attach in read-only mode",
 755                         ubi->mtd->index);
 756                 ubi->ro_mode = 1;
 757         }
 758
 759         /*
 760          * Note, ideally, we have to initialize @ubi->bad_peb_count here. But
 761          * unfortunately, MTD does not provide this information. We should loop
 762          * over all physical eraseblocks and invoke mtd->block_is_bad() for
 763          * each physical eraseblock. So, we leave @ubi->bad_peb_count
 764          * uninitialized so far.
 765          */
 766
 767         return 0;
 768 }
 769
 770 /**
 771  * autoresize - re-size the volume which has the "auto-resize" flag set.
 772  * @ubi: UBI device description object
 773  * @vol_id: ID of the volume to re-size
 774  *
 775  * This function re-sizes the volume marked by the %UBI_VTBL_AUTORESIZE_FLG in
 776  * the volume table to the largest possible size. See comments in ubi-header.h
 777  * for more description of the flag. Returns zero in case of success and a
 778  * negative error code in case of failure.
 779  */
 780 static int autoresize(struct ubi_device *ubi, int vol_id)
 781 {
 782         struct ubi_volume_desc desc;
 783         struct ubi_volume *vol = ubi->volumes[vol_id];
 784         int err, old_reserved_pebs = vol->reserved_pebs;
 785
 786         if (ubi->ro_mode) {
 787                 ubi_warn(ubi, "skip auto-resize because of R/O mode");
 788                 return 0;
 789         }
 790
 791         /*
 792          * Clear the auto-resize flag in the volume in-memory copy of the
 793          * volume table, and 'ubi_resize_volume()' will propagate this change
 794          * to the flash.
 795          */
 796         ubi->vtbl[vol_id].flags &= ~UBI_VTBL_AUTORESIZE_FLG;
 797
 798         if (ubi->avail_pebs == 0) {
 799                 struct ubi_vtbl_record vtbl_rec;
 800
 801                 /*
 802                  * No available PEBs to re-size the volume, clear the flag on
 803                  * flash and exit.
 804                  */
 805                 vtbl_rec = ubi->vtbl[vol_id];
 806                 err = ubi_change_vtbl_record(ubi, vol_id, &vtbl_rec);
 807                 if (err)
 808                         ubi_err(ubi, "cannot clean auto-resize flag for volume %d",
 809                                 vol_id);
 810         } else {
 811                 desc.vol = vol;
 812                 err = ubi_resize_volume(&desc,
 813                                         old_reserved_pebs + ubi->avail_pebs);
 814                 if (err)
 815                         ubi_err(ubi, "cannot auto-resize volume %d",
 816                                 vol_id);
 817         }
 818
 819         if (err)
 820                 return err;
 821
 822         ubi_msg(ubi, "volume %d (\"%s\") re-sized from %d to %d LEBs",
 823                 vol_id, vol->name, old_reserved_pebs, vol->reserved_pebs);
 824         return 0;
 825 }
 826
 827 /**
 828  * ubi_attach_mtd_dev - attach an MTD device.
 829  * @mtd: MTD device description object
 830  * @ubi_num: number to assign to the new UBI device
 831  * @vid_hdr_offset: VID header offset
 832  * @max_beb_per1024: maximum expected number of bad PEB per 1024 PEBs
 833  * @disable_fm: whether disable fastmap
 834  * @need_resv_pool: whether reserve pebs to fill fm_pool
 835  *
 836  * This function attaches MTD device @mtd_dev to UBI and assign @ubi_num number
 837  * to the newly created UBI device, unless @ubi_num is %UBI_DEV_NUM_AUTO, in
 838  * which case this function finds a vacant device number and assigns it
 839  * automatically. Returns the new UBI device number in case of success and a
 840  * negative error code in case of failure.
 841  *
 842  * If @disable_fm is true, ubi doesn't create new fastmap even the module param
 843  * 'fm_autoconvert' is set, and existed old fastmap will be destroyed after
 844  * doing full scanning.
 845  *
 846  * Note, the invocations of this function has to be serialized by the
 847  * @ubi_devices_mutex.
 848  */
 849 int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num,
 850                        int vid_hdr_offset, int max_beb_per1024, bool disable_fm,
 851                        bool need_resv_pool)
 852 {
 853         struct ubi_device *ubi;
 854         int i, err;
 855
 856         if (max_beb_per1024 < 0 || max_beb_per1024 > MAX_MTD_UBI_BEB_LIMIT)
 857                 return -EINVAL;
 858
 859         if (!max_beb_per1024)
 860                 max_beb_per1024 = CONFIG_MTD_UBI_BEB_LIMIT;
 861
 862         /*
 863          * Check if we already have the same MTD device attached.
 864          *
 865          * Note, this function assumes that UBI devices creations and deletions
 866          * are serialized, so it does not take the &ubi_devices_lock.
 867          */
 868         for (i = 0; i < UBI_MAX_DEVICES; i++) {
 869                 ubi = ubi_devices[i];
 870                 if (ubi && mtd->index == ubi->mtd->index) {
 871                         pr_err("ubi: mtd%d is already attached to ubi%d\n",
 872                                 mtd->index, i);
 873                         return -EEXIST;
 874                 }
 875         }
 876
 877         /*
 878          * Make sure this MTD device is not emulated on top of an UBI volume
 879          * already. Well, generally this recursion works fine, but there are
 880          * different problems like the UBI module takes a reference to itself
 881          * by attaching (and thus, opening) the emulated MTD device. This
 882          * results in inability to unload the module. And in general it makes
 883          * no sense to attach emulated MTD devices, so we prohibit this.
 884          */
 885         if (mtd->type == MTD_UBIVOLUME) {
 886                 pr_err("ubi: refuse attaching mtd%d - it is already emulated on top of UBI\n",
 887                         mtd->index);
 888                 return -EINVAL;
 889         }
 890
 891         /*
 892          * Both UBI and UBIFS have been designed for SLC NAND and NOR flashes.
 893          * MLC NAND is different and needs special care, otherwise UBI or UBIFS
 894          * will die soon and you will lose all your data.
 895          * Relax this rule if the partition we're attaching to operates in SLC
 896          * mode.
 897          */
 898         if (mtd->type == MTD_MLCNANDFLASH &&
 899             !(mtd->flags & MTD_SLC_ON_MLC_EMULATION)) {
 900                 pr_err("ubi: refuse attaching mtd%d - MLC NAND is not supported\n",
 901                         mtd->index);
 902                 return -EINVAL;
 903         }
 904
 905         /* UBI cannot work on flashes with zero erasesize. */
 906         if (!mtd->erasesize) {
 907                 pr_err("ubi: refuse attaching mtd%d - zero erasesize flash is not supported\n",
 908                         mtd->index);
 909                 return -EINVAL;
 910         }
 911
 912         if (ubi_num == UBI_DEV_NUM_AUTO) {
 913                 /* Search for an empty slot in the @ubi_devices array */
 914                 for (ubi_num = 0; ubi_num < UBI_MAX_DEVICES; ubi_num++)
 915                         if (!ubi_devices[ubi_num])
 916                                 break;
 917                 if (ubi_num == UBI_MAX_DEVICES) {
 918                         pr_err("ubi: only %d UBI devices may be created\n",
 919                                 UBI_MAX_DEVICES);
 920                         return -ENFILE;
 921                 }
 922         } else {
 923                 if (ubi_num >= UBI_MAX_DEVICES)
 924                         return -EINVAL;
 925
 926                 /* Make sure ubi_num is not busy */
 927                 if (ubi_devices[ubi_num]) {
 928                         pr_err("ubi: ubi%i already exists\n", ubi_num);
 929                         return -EEXIST;
 930                 }
 931         }
 932
 933         ubi = kzalloc(sizeof(struct ubi_device), GFP_KERNEL);
 934         if (!ubi)
 935                 return -ENOMEM;
 936
 937         device_initialize(&ubi->dev);
 938         ubi->dev.release = dev_release;
 939         ubi->dev.class = &ubi_class;
 940         ubi->dev.groups = ubi_dev_groups;
 941         ubi->dev.parent = &mtd->dev;
 942
 943         ubi->mtd = mtd;
 944         ubi->ubi_num = ubi_num;
 945         ubi->vid_hdr_offset = vid_hdr_offset;
 946         ubi->autoresize_vol_id = -1;
 947
 948 #ifdef CONFIG_MTD_UBI_FASTMAP
 949         ubi->fm_pool.used = ubi->fm_pool.size = 0;
 950         ubi->fm_wl_pool.used = ubi->fm_wl_pool.size = 0;
 951
 952         /*
 953          * fm_pool.max_size is 5% of the total number of PEBs but it's also
 954          * between UBI_FM_MAX_POOL_SIZE and UBI_FM_MIN_POOL_SIZE.
 955          */
 956         ubi->fm_pool.max_size = min(((int)mtd_div_by_eb(ubi->mtd->size,
 957                 ubi->mtd) / 100) * 5, UBI_FM_MAX_POOL_SIZE);
 958         ubi->fm_pool.max_size = max(ubi->fm_pool.max_size,
 959                 UBI_FM_MIN_POOL_SIZE);
 960
 961         ubi->fm_wl_pool.max_size = ubi->fm_pool.max_size / 2;
 962         ubi->fm_pool_rsv_cnt = need_resv_pool ? ubi->fm_pool.max_size : 0;
 963         ubi->fm_disabled = (!fm_autoconvert || disable_fm) ? 1 : 0;
 964         if (fm_debug)
 965                 ubi_enable_dbg_chk_fastmap(ubi);
 966
 967         if (!ubi->fm_disabled && (int)mtd_div_by_eb(ubi->mtd->size, ubi->mtd)
 968             <= UBI_FM_MAX_START) {
 969                 ubi_err(ubi, "More than %i PEBs are needed for fastmap, sorry.",
 970                         UBI_FM_MAX_START);
 971                 ubi->fm_disabled = 1;
 972         }
 973
 974         ubi_msg(ubi, "default fastmap pool size: %d", ubi->fm_pool.max_size);
 975         ubi_msg(ubi, "default fastmap WL pool size: %d",
 976                 ubi->fm_wl_pool.max_size);
 977 #else
 978         ubi->fm_disabled = 1;
 979 #endif
 980         mutex_init(&ubi->buf_mutex);
 981         mutex_init(&ubi->ckvol_mutex);
 982         mutex_init(&ubi->device_mutex);
 983         spin_lock_init(&ubi->volumes_lock);
 984         init_rwsem(&ubi->fm_protect);
 985         init_rwsem(&ubi->fm_eba_sem);
 986
 987         ubi_msg(ubi, "attaching mtd%d", mtd->index);
 988
 989         err = io_init(ubi, max_beb_per1024);
 990         if (err)
 991                 goto out_free;
 992
 993         err = -ENOMEM;
 994         ubi->peb_buf = vmalloc(ubi->peb_size);
 995         if (!ubi->peb_buf)
 996                 goto out_free;
 997
 998 #ifdef CONFIG_MTD_UBI_FASTMAP
 999         ubi->fm_size = ubi_calc_fm_size(ubi);
1000         ubi->fm_buf = vzalloc(ubi->fm_size);
1001         if (!ubi->fm_buf)
1002                 goto out_free;
1003 #endif
1004         err = ubi_attach(ubi, disable_fm ? 1 : 0);
1005         if (err) {
1006                 ubi_err(ubi, "failed to attach mtd%d, error %d",
1007                         mtd->index, err);
1008                 goto out_free;
1009         }
1010
1011         if (ubi->autoresize_vol_id != -1) {
1012                 err = autoresize(ubi, ubi->autoresize_vol_id);
1013                 if (err)
1014                         goto out_detach;
1015         }
1016
1017         err = uif_init(ubi);
1018         if (err)
1019                 goto out_detach;
1020
1021         err = ubi_debugfs_init_dev(ubi);
1022         if (err)
1023                 goto out_uif;
1024
1025         ubi->bgt_thread = kthread_create(ubi_thread, ubi, "%s", ubi->bgt_name);
1026         if (IS_ERR(ubi->bgt_thread)) {
1027                 err = PTR_ERR(ubi->bgt_thread);
1028                 ubi_err(ubi, "cannot spawn \"%s\", error %d",
1029                         ubi->bgt_name, err);
1030                 goto out_debugfs;
1031         }
1032
1033         ubi_msg(ubi, "attached mtd%d (name \"%s\", size %llu MiB)",
1034                 mtd->index, mtd->name, ubi->flash_size >> 20);
1035         ubi_msg(ubi, "PEB size: %d bytes (%d KiB), LEB size: %d bytes",
1036                 ubi->peb_size, ubi->peb_size >> 10, ubi->leb_size);
1037         ubi_msg(ubi, "min./max. I/O unit sizes: %d/%d, sub-page size %d",
1038                 ubi->min_io_size, ubi->max_write_size, ubi->hdrs_min_io_size);
1039         ubi_msg(ubi, "VID header offset: %d (aligned %d), data offset: %d",
1040                 ubi->vid_hdr_offset, ubi->vid_hdr_aloffset, ubi->leb_start);
1041         ubi_msg(ubi, "good PEBs: %d, bad PEBs: %d, corrupted PEBs: %d",
1042                 ubi->good_peb_count, ubi->bad_peb_count, ubi->corr_peb_count);
1043         ubi_msg(ubi, "user volume: %d, internal volumes: %d, max. volumes count: %d",
1044                 ubi->vol_count - UBI_INT_VOL_COUNT, UBI_INT_VOL_COUNT,
1045                 ubi->vtbl_slots);
1046         ubi_msg(ubi, "max/mean erase counter: %d/%d, WL threshold: %d, image sequence number: %u",
1047                 ubi->max_ec, ubi->mean_ec, CONFIG_MTD_UBI_WL_THRESHOLD,
1048                 ubi->image_seq);
1049         ubi_msg(ubi, "available PEBs: %d, total reserved PEBs: %d, PEBs reserved for bad PEB handling: %d",
1050                 ubi->avail_pebs, ubi->rsvd_pebs, ubi->beb_rsvd_pebs);
1051
1052         /*
1053          * The below lock makes sure we do not race with 'ubi_thread()' which
1054          * checks @ubi->thread_enabled. Otherwise we may fail to wake it up.
1055          */
1056         spin_lock(&ubi->wl_lock);
1057         ubi->thread_enabled = 1;
1058         wake_up_process(ubi->bgt_thread);
1059         spin_unlock(&ubi->wl_lock);
1060
1061         ubi_devices[ubi_num] = ubi;
1062         ubi_notify_all(ubi, UBI_VOLUME_ADDED, NULL);
1063         return ubi_num;
1064
1065 out_debugfs:
1066         ubi_debugfs_exit_dev(ubi);
1067 out_uif:
1068         uif_close(ubi);
1069 out_detach:
1070         ubi_wl_close(ubi);
1071         ubi_free_all_volumes(ubi);
1072         vfree(ubi->vtbl);
1073 out_free:
1074         vfree(ubi->peb_buf);
1075         vfree(ubi->fm_buf);
1076         put_device(&ubi->dev);
1077         return err;
1078 }
1079
1080 /**
1081  * ubi_detach_mtd_dev - detach an MTD device.
1082  * @ubi_num: UBI device number to detach from
1083  * @anyway: detach MTD even if device reference count is not zero
1084  *
1085  * This function destroys an UBI device number @ubi_num and detaches the
1086  * underlying MTD device. Returns zero in case of success and %-EBUSY if the
1087  * UBI device is busy and cannot be destroyed, and %-EINVAL if it does not
1088  * exist.
1089  *
1090  * Note, the invocations of this function has to be serialized by the
1091  * @ubi_devices_mutex.
1092  */
1093 int ubi_detach_mtd_dev(int ubi_num, int anyway)
1094 {
1095         struct ubi_device *ubi;
1096
1097         if (ubi_num < 0 || ubi_num >= UBI_MAX_DEVICES)
1098                 return -EINVAL;
1099
1100         ubi = ubi_get_device(ubi_num);
1101         if (!ubi)
1102                 return -EINVAL;
1103
1104         spin_lock(&ubi_devices_lock);
1105         ubi->ref_count -= 1;
1106         if (ubi->ref_count) {
1107                 if (!anyway) {
1108                         spin_unlock(&ubi_devices_lock);
1109                         return -EBUSY;
1110                 }
1111                 /* This may only happen if there is a bug */
1112                 ubi_err(ubi, "%s reference count %d, destroy anyway",
1113                         ubi->ubi_name, ubi->ref_count);
1114         }
1115         ubi->is_dead = true;
1116         spin_unlock(&ubi_devices_lock);
1117
1118         ubi_notify_all(ubi, UBI_VOLUME_SHUTDOWN, NULL);
1119
1120         spin_lock(&ubi_devices_lock);
1121         put_device(&ubi->dev);
1122         ubi_devices[ubi_num] = NULL;
1123         spin_unlock(&ubi_devices_lock);
1124
1125         ubi_assert(ubi_num == ubi->ubi_num);
1126         ubi_notify_all(ubi, UBI_VOLUME_REMOVED, NULL);
1127         ubi_msg(ubi, "detaching mtd%d", ubi->mtd->index);
1128 #ifdef CONFIG_MTD_UBI_FASTMAP
1129         /* If we don't write a new fastmap at detach time we lose all
1130          * EC updates that have been made since the last written fastmap.
1131          * In case of fastmap debugging we omit the update to simulate an
1132          * unclean shutdown. */
1133         if (!ubi_dbg_chk_fastmap(ubi))
1134                 ubi_update_fastmap(ubi);
1135 #endif
1136         /*
1137          * Before freeing anything, we have to stop the background thread to
1138          * prevent it from doing anything on this device while we are freeing.
1139          */
1140         if (ubi->bgt_thread)
1141                 kthread_stop(ubi->bgt_thread);
1142
1143 #ifdef CONFIG_MTD_UBI_FASTMAP
1144         cancel_work_sync(&ubi->fm_work);
1145 #endif
1146         ubi_debugfs_exit_dev(ubi);
1147         uif_close(ubi);
1148
1149         ubi_wl_close(ubi);
1150         ubi_free_internal_volumes(ubi);
1151         vfree(ubi->vtbl);
1152         vfree(ubi->peb_buf);
1153         vfree(ubi->fm_buf);
1154         ubi_msg(ubi, "mtd%d is detached", ubi->mtd->index);
1155         put_mtd_device(ubi->mtd);
1156         put_device(&ubi->dev);
1157         return 0;
1158 }
1159
1160 /**
1161  * open_mtd_by_chdev - open an MTD device by its character device node path.
1162  * @mtd_dev: MTD character device node path
1163  *
1164  * This helper function opens an MTD device by its character node device path.
1165  * Returns MTD device description object in case of success and a negative
1166  * error code in case of failure.
1167  */
1168 static struct mtd_info * __init open_mtd_by_chdev(const char *mtd_dev)
1169 {
1170         int err, minor;
1171         struct path path;
1172         struct kstat stat;
1173
1174         /* Probably this is an MTD character device node path */
1175         err = kern_path(mtd_dev, LOOKUP_FOLLOW, &path);
1176         if (err)
1177                 return ERR_PTR(err);
1178
1179         err = vfs_getattr(&path, &stat, STATX_TYPE, AT_STATX_SYNC_AS_STAT);
1180         path_put(&path);
1181         if (err)
1182                 return ERR_PTR(err);
1183
1184         /* MTD device number is defined by the major / minor numbers */
1185         if (MAJOR(stat.rdev) != MTD_CHAR_MAJOR || !S_ISCHR(stat.mode))
1186                 return ERR_PTR(-EINVAL);
1187
1188         minor = MINOR(stat.rdev);
1189
1190         if (minor & 1)
1191                 /*
1192                  * Just do not think the "/dev/mtdrX" devices support is need,
1193                  * so do not support them to avoid doing extra work.
1194                  */
1195                 return ERR_PTR(-EINVAL);
1196
1197         return get_mtd_device(NULL, minor / 2);
1198 }
1199
1200 /**
1201  * open_mtd_device - open MTD device by name, character device path, or number.
1202  * @mtd_dev: name, character device node path, or MTD device device number
1203  *
1204  * This function tries to open and MTD device described by @mtd_dev string,
1205  * which is first treated as ASCII MTD device number, and if it is not true, it
1206  * is treated as MTD device name, and if that is also not true, it is treated
1207  * as MTD character device node path. Returns MTD device description object in
1208  * case of success and a negative error code in case of failure.
1209  */
1210 static struct mtd_info * __init open_mtd_device(const char *mtd_dev)
1211 {
1212         struct mtd_info *mtd;
1213         int mtd_num;
1214         char *endp;
1215
1216         mtd_num = simple_strtoul(mtd_dev, &endp, 0);
1217         if (*endp != '\0' || mtd_dev == endp) {
1218                 /*
1219                  * This does not look like an ASCII integer, probably this is
1220                  * MTD device name.
1221                  */
1222                 mtd = get_mtd_device_nm(mtd_dev);
1223                 if (PTR_ERR(mtd) == -ENODEV)
1224                         /* Probably this is an MTD character device node path */
1225                         mtd = open_mtd_by_chdev(mtd_dev);
1226         } else
1227                 mtd = get_mtd_device(NULL, mtd_num);
1228
1229         return mtd;
1230 }
1231
1232 static void ubi_notify_add(struct mtd_info *mtd)
1233 {
1234         struct device_node *np = mtd_get_of_node(mtd);
1235         int err;
1236
1237         if (!of_device_is_compatible(np, "linux,ubi"))
1238                 return;
1239
1240         /*
1241          * we are already holding &mtd_table_mutex, but still need
1242          * to bump refcount
1243          */
1244         err = __get_mtd_device(mtd);
1245         if (err)
1246                 return;
1247
1248         /* called while holding mtd_table_mutex */
1249         mutex_lock_nested(&ubi_devices_mutex, SINGLE_DEPTH_NESTING);
1250         err = ubi_attach_mtd_dev(mtd, UBI_DEV_NUM_AUTO, 0, 0, false, false);
1251         mutex_unlock(&ubi_devices_mutex);
1252         if (err < 0)
1253                 __put_mtd_device(mtd);
1254 }
1255
1256 static void ubi_notify_remove(struct mtd_info *mtd)
1257 {
1258         /* do nothing for now */
1259 }
1260
1261 static struct mtd_notifier ubi_mtd_notifier = {
1262         .add = ubi_notify_add,
1263         .remove = ubi_notify_remove,
1264 };
1265
1266 static int __init ubi_init_attach(void)
1267 {
1268         int err, i, k;
1269
1270         /* Attach MTD devices */
1271         for (i = 0; i < mtd_devs; i++) {
1272                 struct mtd_dev_param *p = &mtd_dev_param[i];
1273                 struct mtd_info *mtd;
1274
1275                 cond_resched();
1276
1277                 mtd = open_mtd_device(p->name);
1278                 if (IS_ERR(mtd)) {
1279                         err = PTR_ERR(mtd);
1280                         pr_err("UBI error: cannot open mtd %s, error %d\n",
1281                                p->name, err);
1282                         /* See comment below re-ubi_is_module(). */
1283                         if (ubi_is_module())
1284                                 goto out_detach;
1285                         continue;
1286                 }
1287
1288                 mutex_lock(&ubi_devices_mutex);
1289                 err = ubi_attach_mtd_dev(mtd, p->ubi_num,
1290                                          p->vid_hdr_offs, p->max_beb_per1024,
1291                                          p->enable_fm == 0,
1292                                          p->need_resv_pool != 0);
1293                 mutex_unlock(&ubi_devices_mutex);
1294                 if (err < 0) {
1295                         pr_err("UBI error: cannot attach mtd%d\n",
1296                                mtd->index);
1297                         put_mtd_device(mtd);
1298
1299                         /*
1300                          * Originally UBI stopped initializing on any error.
1301                          * However, later on it was found out that this
1302                          * behavior is not very good when UBI is compiled into
1303                          * the kernel and the MTD devices to attach are passed
1304                          * through the command line. Indeed, UBI failure
1305                          * stopped whole boot sequence.
1306                          *
1307                          * To fix this, we changed the behavior for the
1308                          * non-module case, but preserved the old behavior for
1309                          * the module case, just for compatibility. This is a
1310                          * little inconsistent, though.
1311                          */
1312                         if (ubi_is_module())
1313                                 goto out_detach;
1314                 }
1315         }
1316
1317         return 0;
1318
1319 out_detach:
1320         for (k = 0; k < i; k++)
1321                 if (ubi_devices[k]) {
1322                         mutex_lock(&ubi_devices_mutex);
1323                         ubi_detach_mtd_dev(ubi_devices[k]->ubi_num, 1);
1324                         mutex_unlock(&ubi_devices_mutex);
1325                 }
1326         return err;
1327 }
1328 #ifndef CONFIG_MTD_UBI_MODULE
1329 late_initcall(ubi_init_attach);
1330 #endif
1331
1332 static int __init ubi_init(void)
1333 {
1334         int err;
1335
1336         /* Ensure that EC and VID headers have correct size */
1337         BUILD_BUG_ON(sizeof(struct ubi_ec_hdr) != 64);
1338         BUILD_BUG_ON(sizeof(struct ubi_vid_hdr) != 64);
1339
1340         if (mtd_devs > UBI_MAX_DEVICES) {
1341                 pr_err("UBI error: too many MTD devices, maximum is %d\n",
1342                        UBI_MAX_DEVICES);
1343                 return -EINVAL;
1344         }
1345
1346         /* Create base sysfs directory and sysfs files */
1347         err = class_register(&ubi_class);
1348         if (err < 0)
1349                 return err;
1350
1351         err = misc_register(&ubi_ctrl_cdev);
1352         if (err) {
1353                 pr_err("UBI error: cannot register device\n");
1354                 goto out;
1355         }
1356
1357         ubi_wl_entry_slab = kmem_cache_create("ubi_wl_entry_slab",
1358                                               sizeof(struct ubi_wl_entry),
1359                                               0, 0, NULL);
1360         if (!ubi_wl_entry_slab) {
1361                 err = -ENOMEM;
1362                 goto out_dev_unreg;
1363         }
1364
1365         err = ubi_debugfs_init();
1366         if (err)
1367                 goto out_slab;
1368
1369         err = ubiblock_init();
1370         if (err) {
1371                 pr_err("UBI error: block: cannot initialize, error %d\n", err);
1372
1373                 /* See comment above re-ubi_is_module(). */
1374                 if (ubi_is_module())
1375                         goto out_debugfs;
1376         }
1377
1378         register_mtd_user(&ubi_mtd_notifier);
1379
1380         if (ubi_is_module()) {
1381                 err = ubi_init_attach();
1382                 if (err)
1383                         goto out_mtd_notifier;
1384         }
1385
1386         return 0;
1387
1388 out_mtd_notifier:
1389         unregister_mtd_user(&ubi_mtd_notifier);
1390         ubiblock_exit();
1391 out_debugfs:
1392         ubi_debugfs_exit();
1393 out_slab:
1394         kmem_cache_destroy(ubi_wl_entry_slab);
1395 out_dev_unreg:
1396         misc_deregister(&ubi_ctrl_cdev);
1397 out:
1398         class_unregister(&ubi_class);
1399         pr_err("UBI error: cannot initialize UBI, error %d\n", err);
1400         return err;
1401 }
1402 device_initcall(ubi_init);
1403
1404
1405 static void __exit ubi_exit(void)
1406 {
1407         int i;
1408
1409         ubiblock_exit();
1410         unregister_mtd_user(&ubi_mtd_notifier);
1411
1412         for (i = 0; i < UBI_MAX_DEVICES; i++)
1413                 if (ubi_devices[i]) {
1414                         mutex_lock(&ubi_devices_mutex);
1415                         ubi_detach_mtd_dev(ubi_devices[i]->ubi_num, 1);
1416                         mutex_unlock(&ubi_devices_mutex);
1417                 }
1418         ubi_debugfs_exit();
1419         kmem_cache_destroy(ubi_wl_entry_slab);
1420         misc_deregister(&ubi_ctrl_cdev);
1421         class_unregister(&ubi_class);
1422 }
1423 module_exit(ubi_exit);
1424
1425 /**
1426  * bytes_str_to_int - convert a number of bytes string into an integer.
1427  * @str: the string to convert
1428  *
1429  * This function returns positive resulting integer in case of success and a
1430  * negative error code in case of failure.
1431  */
1432 static int bytes_str_to_int(const char *str)
1433 {
1434         char *endp;
1435         unsigned long result;
1436
1437         result = simple_strtoul(str, &endp, 0);
1438         if (str == endp || result >= INT_MAX) {
1439                 pr_err("UBI error: incorrect bytes count: \"%s\"\n", str);
1440                 return -EINVAL;
1441         }
1442
1443         switch (*endp) {
1444         case 'G':
1445                 result *= 1024;
1446                 fallthrough;
1447         case 'M':
1448                 result *= 1024;
1449                 fallthrough;
1450         case 'K':
1451                 result *= 1024;
1452                 break;
1453         case '\0':
1454                 break;
1455         default:
1456                 pr_err("UBI error: incorrect bytes count: \"%s\"\n", str);
1457                 return -EINVAL;
1458         }
1459
1460         return result;
1461 }
1462
1463 /**
1464  * ubi_mtd_param_parse - parse the 'mtd=' UBI parameter.
1465  * @val: the parameter value to parse
1466  * @kp: not used
1467  *
1468  * This function returns zero in case of success and a negative error code in
1469  * case of error.
1470  */
1471 static int ubi_mtd_param_parse(const char *val, const struct kernel_param *kp)
1472 {
1473         int i, len;
1474         struct mtd_dev_param *p;
1475         char buf[MTD_PARAM_LEN_MAX];
1476         char *pbuf = &buf[0];
1477         char *tokens[MTD_PARAM_MAX_COUNT], *token;
1478
1479         if (!val)
1480                 return -EINVAL;
1481
1482         if (mtd_devs == UBI_MAX_DEVICES) {
1483                 pr_err("UBI error: too many parameters, max. is %d\n",
1484                        UBI_MAX_DEVICES);
1485                 return -EINVAL;
1486         }
1487
1488         len = strnlen(val, MTD_PARAM_LEN_MAX);
1489         if (len == MTD_PARAM_LEN_MAX) {
1490                 pr_err("UBI error: parameter \"%s\" is too long, max. is %d\n",
1491                        val, MTD_PARAM_LEN_MAX);
1492                 return -EINVAL;
1493         }
1494
1495         if (len == 0) {
1496                 pr_warn("UBI warning: empty 'mtd=' parameter - ignored\n");
1497                 return 0;
1498         }
1499
1500         strcpy(buf, val);
1501
1502         /* Get rid of the final newline */
1503         if (buf[len - 1] == '\n')
1504                 buf[len - 1] = '\0';
1505
1506         for (i = 0; i < MTD_PARAM_MAX_COUNT; i++)
1507                 tokens[i] = strsep(&pbuf, ",");
1508
1509         if (pbuf) {
1510                 pr_err("UBI error: too many arguments at \"%s\"\n", val);
1511                 return -EINVAL;
1512         }
1513
1514         p = &mtd_dev_param[mtd_devs];
1515         strcpy(&p->name[0], tokens[0]);
1516
1517         token = tokens[1];
1518         if (token) {
1519                 p->vid_hdr_offs = bytes_str_to_int(token);
1520
1521                 if (p->vid_hdr_offs < 0)
1522                         return p->vid_hdr_offs;
1523         }
1524
1525         token = tokens[2];
1526         if (token) {
1527                 int err = kstrtoint(token, 10, &p->max_beb_per1024);
1528
1529                 if (err) {
1530                         pr_err("UBI error: bad value for max_beb_per1024 parameter: %s\n",
1531                                token);
1532                         return -EINVAL;
1533                 }
1534         }
1535
1536         token = tokens[3];
1537         if (token) {
1538                 int err = kstrtoint(token, 10, &p->ubi_num);
1539
1540                 if (err) {
1541                         pr_err("UBI error: bad value for ubi_num parameter: %s\n",
1542                                token);
1543                         return -EINVAL;
1544                 }
1545         } else
1546                 p->ubi_num = UBI_DEV_NUM_AUTO;
1547
1548         token = tokens[4];
1549         if (token) {
1550                 int err = kstrtoint(token, 10, &p->enable_fm);
1551
1552                 if (err) {
1553                         pr_err("UBI error: bad value for enable_fm parameter: %s\n",
1554                                 token);
1555                         return -EINVAL;
1556                 }
1557         } else
1558                 p->enable_fm = 0;
1559
1560         token = tokens[5];
1561         if (token) {
1562                 int err = kstrtoint(token, 10, &p->need_resv_pool);
1563
1564                 if (err) {
1565                         pr_err("UBI error: bad value for need_resv_pool parameter: %s\n",
1566                                 token);
1567                         return -EINVAL;
1568                 }
1569         } else
1570                 p->need_resv_pool = 0;
1571
1572         mtd_devs += 1;
1573         return 0;
1574 }
1575
1576 module_param_call(mtd, ubi_mtd_param_parse, NULL, NULL, 0400);
1577 MODULE_PARM_DESC(mtd, "MTD devices to attach. Parameter format: mtd=<name|num|path>[,<vid_hdr_offs>[,max_beb_per1024[,ubi_num]]].\n"
1578                       "Multiple \"mtd\" parameters may be specified.\n"
1579                       "MTD devices may be specified by their number, name, or path to the MTD character device node.\n"
1580                       "Optional \"vid_hdr_offs\" parameter specifies UBI VID header position to be used by UBI. (default value if 0)\n"
1581                       "Optional \"max_beb_per1024\" parameter specifies the maximum expected bad eraseblock per 1024 eraseblocks. (default value ("
1582                       __stringify(CONFIG_MTD_UBI_BEB_LIMIT) ") if 0)\n"
1583                       "Optional \"ubi_num\" parameter specifies UBI device number which have to be assigned to the newly created UBI device (assigned automatically by default)\n"
1584                       "Optional \"enable_fm\" parameter determines whether to enable fastmap during attach. If the value is non-zero, fastmap is enabled. Default value is 0.\n"
1585                       "Optional \"need_resv_pool\" parameter determines whether to reserve pool->max_size pebs during attach. If the value is non-zero, peb reservation is enabled. Default value is 0.\n"
1586                       "\n"
1587                       "Example 1: mtd=/dev/mtd0 - attach MTD device /dev/mtd0.\n"
1588                       "Example 2: mtd=content,1984 mtd=4 - attach MTD device with name \"content\" using VID header offset 1984, and MTD device number 4 with default VID header offset.\n"
1589                       "Example 3: mtd=/dev/mtd1,0,25 - attach MTD device /dev/mtd1 using default VID header offset and reserve 25*nand_size_in_blocks/1024 erase blocks for bad block handling.\n"
1590                       "Example 4: mtd=/dev/mtd1,0,0,5 - attach MTD device /dev/mtd1 to UBI 5 and using default values for the other fields.\n"
1591                       "example 5: mtd=1,0,0,5 mtd=2,0,0,6,1 - attach MTD device /dev/mtd1 to UBI 5 and disable fastmap; attach MTD device /dev/mtd2 to UBI 6 and enable fastmap.(only works when fastmap is enabled and fm_autoconvert=Y).\n"
1592                       "\t(e.g. if the NAND *chipset* has 4096 PEB, 100 will be reserved for this UBI device).");
1593 #ifdef CONFIG_MTD_UBI_FASTMAP
1594 module_param(fm_autoconvert, bool, 0644);
1595 MODULE_PARM_DESC(fm_autoconvert, "Set this parameter to enable fastmap automatically on images without a fastmap.");
1596 module_param(fm_debug, bool, 0);
1597 MODULE_PARM_DESC(fm_debug, "Set this parameter to enable fastmap debugging by default. Warning, this will make fastmap slow!");
1598 #endif
1599 MODULE_VERSION(__stringify(UBI_VERSION));
1600 MODULE_DESCRIPTION("UBI - Unsorted Block Images");
1601 MODULE_AUTHOR("Artem Bityutskiy");
1602 MODULE_LICENSE("GPL");