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