Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 45175476ae2dbebc860d5cf486f2916044343513

Authored by Linus Torvalds 2013-07-06 03:09:48 +0800

Exists in smarc-imx_3.14.28_1.0.0_ga and in 1 other branch

Merge tag 'upstream-3.11-rc1' of git://git.infradead.org/linux-ubi

Pull ubi fixes from Artem Bityutskiy:
 "A couple of fixes and clean-ups, allow for assigning user-defined UBI
  device numbers when attaching MTD devices by using the "mtd=" module
  parameter"

* tag 'upstream-3.11-rc1' of git://git.infradead.org/linux-ubi:
  UBI: support ubi_num on mtd.ubi command line
  UBI: fastmap break out of used PEB search
  UBI: document UBI_IOCVOLUP better in user header
  UBI: do not abort init when ubi.mtd devices cannot be found
  UBI: drop redundant "UBI error" string

Showing 3 changed files Inline Diff

drivers/mtd/ubi/build.c
drivers/mtd/ubi/fastmap.c
include/uapi/mtd/ubi-user.h

drivers/mtd/ubi/build.c

Diff comments View file @ 4517547

 /*
  * Copyright (c) International Business Machines Corp., 2006
  * Copyright (c) Nokia Corporation, 2007
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
  * the GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  *
  * Author: Artem Bityutskiy (Битюцкий Артём),
  *         Frank Haverkamp
  */
 /*
  * This file includes UBI initialization and building of UBI devices.
  *
  * When UBI is initialized, it attaches all the MTD devices specified as the
  * module load parameters or the kernel boot parameters. If MTD devices were
  * specified, UBI does not attach any MTD device, but it is possible to do
  * later using the "UBI control device".
  */
 #include <linux/err.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/stringify.h>
 #include <linux/namei.h>
 #include <linux/stat.h>
 #include <linux/miscdevice.h>
 #include <linux/mtd/partitions.h>
 #include <linux/log2.h>
 #include <linux/kthread.h>
 #include <linux/kernel.h>
 #include <linux/slab.h>
 #include "ubi.h"
 /* Maximum length of the 'mtd=' parameter */
 #define MTD_PARAM_LEN_MAX 64
 /* Maximum number of comma-separated items in the 'mtd=' parameter */
-#define MTD_PARAM_MAX_COUNT 3
+#define MTD_PARAM_MAX_COUNT 4
 /* Maximum value for the number of bad PEBs per 1024 PEBs */
 #define MAX_MTD_UBI_BEB_LIMIT 768
 #ifdef CONFIG_MTD_UBI_MODULE
 #define ubi_is_module() 1
 #else
 #define ubi_is_module() 0
 #endif
 /**
  * struct mtd_dev_param - MTD device parameter description data structure.
  * @name: MTD character device node path, MTD device name, or MTD device number
  *        string
  * @vid_hdr_offs: VID header offset
  * @max_beb_per1024: maximum expected number of bad PEBs per 1024 PEBs
  */
 struct mtd_dev_param {
 	char name[MTD_PARAM_LEN_MAX];
+	int ubi_num;
 	int vid_hdr_offs;
 	int max_beb_per1024;
 };
 /* Numbers of elements set in the @mtd_dev_param array */
 static int __initdata mtd_devs;
 /* MTD devices specification parameters */
 static struct mtd_dev_param __initdata mtd_dev_param[UBI_MAX_DEVICES];
 #ifdef CONFIG_MTD_UBI_FASTMAP
 /* UBI module parameter to enable fastmap automatically on non-fastmap images */
 static bool fm_autoconvert;
 #endif
 /* Root UBI "class" object (corresponds to '/<sysfs>/class/ubi/') */
 struct class *ubi_class;
 /* Slab cache for wear-leveling entries */
 struct kmem_cache *ubi_wl_entry_slab;
 /* UBI control character device */
 static struct miscdevice ubi_ctrl_cdev = {
 	.minor = MISC_DYNAMIC_MINOR,
 	.name = "ubi_ctrl",
 	.fops = &ubi_ctrl_cdev_operations,
 };
 /* All UBI devices in system */
 static struct ubi_device *ubi_devices[UBI_MAX_DEVICES];
 /* Serializes UBI devices creations and removals */
 DEFINE_MUTEX(ubi_devices_mutex);
 /* Protects @ubi_devices and @ubi->ref_count */
 static DEFINE_SPINLOCK(ubi_devices_lock);
 /* "Show" method for files in '/<sysfs>/class/ubi/' */
 static ssize_t ubi_version_show(struct class *class,
 				struct class_attribute *attr, char *buf)
 {
 	return sprintf(buf, "%d\n", UBI_VERSION);
 }
 /* UBI version attribute ('/<sysfs>/class/ubi/version') */
 static struct class_attribute ubi_version =
 	__ATTR(version, S_IRUGO, ubi_version_show, NULL);
 static ssize_t dev_attribute_show(struct device *dev,
 				  struct device_attribute *attr, char *buf);
 /* UBI device attributes (correspond to files in '/<sysfs>/class/ubi/ubiX') */
 static struct device_attribute dev_eraseblock_size =
 	__ATTR(eraseblock_size, S_IRUGO, dev_attribute_show, NULL);
 static struct device_attribute dev_avail_eraseblocks =
 	__ATTR(avail_eraseblocks, S_IRUGO, dev_attribute_show, NULL);
 static struct device_attribute dev_total_eraseblocks =
 	__ATTR(total_eraseblocks, S_IRUGO, dev_attribute_show, NULL);
 static struct device_attribute dev_volumes_count =
 	__ATTR(volumes_count, S_IRUGO, dev_attribute_show, NULL);
 static struct device_attribute dev_max_ec =
 	__ATTR(max_ec, S_IRUGO, dev_attribute_show, NULL);
 static struct device_attribute dev_reserved_for_bad =
 	__ATTR(reserved_for_bad, S_IRUGO, dev_attribute_show, NULL);
 static struct device_attribute dev_bad_peb_count =
 	__ATTR(bad_peb_count, S_IRUGO, dev_attribute_show, NULL);
 static struct device_attribute dev_max_vol_count =
 	__ATTR(max_vol_count, S_IRUGO, dev_attribute_show, NULL);
 static struct device_attribute dev_min_io_size =
 	__ATTR(min_io_size, S_IRUGO, dev_attribute_show, NULL);
 static struct device_attribute dev_bgt_enabled =
 	__ATTR(bgt_enabled, S_IRUGO, dev_attribute_show, NULL);
 static struct device_attribute dev_mtd_num =
 	__ATTR(mtd_num, S_IRUGO, dev_attribute_show, NULL);
 /**
  * ubi_volume_notify - send a volume change notification.
  * @ubi: UBI device description object
  * @vol: volume description object of the changed volume
  * @ntype: notification type to send (%UBI_VOLUME_ADDED, etc)
  *
  * This is a helper function which notifies all subscribers about a volume
  * change event (creation, removal, re-sizing, re-naming, updating). Returns
  * zero in case of success and a negative error code in case of failure.
  */
 int ubi_volume_notify(struct ubi_device *ubi, struct ubi_volume *vol, int ntype)
 {
 	struct ubi_notification nt;
 	ubi_do_get_device_info(ubi, &nt.di);
 	ubi_do_get_volume_info(ubi, vol, &nt.vi);
 #ifdef CONFIG_MTD_UBI_FASTMAP
 	switch (ntype) {
 	case UBI_VOLUME_ADDED:
 	case UBI_VOLUME_REMOVED:
 	case UBI_VOLUME_RESIZED:
 	case UBI_VOLUME_RENAMED:
 		if (ubi_update_fastmap(ubi)) {
 			ubi_err("Unable to update fastmap!");
 			ubi_ro_mode(ubi);
 		}
 	}
 #endif
 	return blocking_notifier_call_chain(&ubi_notifiers, ntype, &nt);
 }
 /**
  * ubi_notify_all - send a notification to all volumes.
  * @ubi: UBI device description object
  * @ntype: notification type to send (%UBI_VOLUME_ADDED, etc)
  * @nb: the notifier to call
  *
  * This function walks all volumes of UBI device @ubi and sends the @ntype
  * notification for each volume. If @nb is %NULL, then all registered notifiers
  * are called, otherwise only the @nb notifier is called. Returns the number of
  * sent notifications.
  */
 int ubi_notify_all(struct ubi_device *ubi, int ntype, struct notifier_block *nb)
 {
 	struct ubi_notification nt;
 	int i, count = 0;
 	ubi_do_get_device_info(ubi, &nt.di);
 	mutex_lock(&ubi->device_mutex);
 	for (i = 0; i < ubi->vtbl_slots; i++) {
 		/*
 		 * Since the @ubi->device is locked, and we are not going to
 		 * change @ubi->volumes, we do not have to lock
 		 * @ubi->volumes_lock.
 		 */
 		if (!ubi->volumes[i])
 			continue;
 		ubi_do_get_volume_info(ubi, ubi->volumes[i], &nt.vi);
 		if (nb)
 			nb->notifier_call(nb, ntype, &nt);
 		else
 			blocking_notifier_call_chain(&ubi_notifiers, ntype,
 						     &nt);
 		count += 1;
 	}
 	mutex_unlock(&ubi->device_mutex);
 	return count;
 }
 /**
  * ubi_enumerate_volumes - send "add" notification for all existing volumes.
  * @nb: the notifier to call
  *
  * This function walks all UBI devices and volumes and sends the
  * %UBI_VOLUME_ADDED notification for each volume. If @nb is %NULL, then all
  * registered notifiers are called, otherwise only the @nb notifier is called.
  * Returns the number of sent notifications.
  */
 int ubi_enumerate_volumes(struct notifier_block *nb)
 {
 	int i, count = 0;
 	/*
 	 * Since the @ubi_devices_mutex is locked, and we are not going to
 	 * change @ubi_devices, we do not have to lock @ubi_devices_lock.
 	 */
 	for (i = 0; i < UBI_MAX_DEVICES; i++) {
 		struct ubi_device *ubi = ubi_devices[i];
 		if (!ubi)
 			continue;
 		count += ubi_notify_all(ubi, UBI_VOLUME_ADDED, nb);
 	}
 	return count;
 }
 /**
  * ubi_get_device - get UBI device.
  * @ubi_num: UBI device number
  *
  * This function returns UBI device description object for UBI device number
  * @ubi_num, or %NULL if the device does not exist. This function increases the
  * device reference count to prevent removal of the device. In other words, the
  * device cannot be removed if its reference count is not zero.
  */
 struct ubi_device *ubi_get_device(int ubi_num)
 {
 	struct ubi_device *ubi;
 	spin_lock(&ubi_devices_lock);
 	ubi = ubi_devices[ubi_num];
 	if (ubi) {
 		ubi_assert(ubi->ref_count >= 0);
 		ubi->ref_count += 1;
 		get_device(&ubi->dev);
 	}
 	spin_unlock(&ubi_devices_lock);
 	return ubi;
 }
 /**
  * ubi_put_device - drop an UBI device reference.
  * @ubi: UBI device description object
  */
 void ubi_put_device(struct ubi_device *ubi)
 {
 	spin_lock(&ubi_devices_lock);
 	ubi->ref_count -= 1;
 	put_device(&ubi->dev);
 	spin_unlock(&ubi_devices_lock);
 }
 /**
  * ubi_get_by_major - get UBI device by character device major number.
  * @major: major number
  *
  * This function is similar to 'ubi_get_device()', but it searches the device
  * by its major number.
  */
 struct ubi_device *ubi_get_by_major(int major)
 {
 	int i;
 	struct ubi_device *ubi;
 	spin_lock(&ubi_devices_lock);
 	for (i = 0; i < UBI_MAX_DEVICES; i++) {
 		ubi = ubi_devices[i];
 		if (ubi && MAJOR(ubi->cdev.dev) == major) {
 			ubi_assert(ubi->ref_count >= 0);
 			ubi->ref_count += 1;
 			get_device(&ubi->dev);
 			spin_unlock(&ubi_devices_lock);
 			return ubi;
 		}
 	}
 	spin_unlock(&ubi_devices_lock);
 	return NULL;
 }
 /**
  * ubi_major2num - get UBI device number by character device major number.
  * @major: major number
  *
  * This function searches UBI device number object by its major number. If UBI
  * device was not found, this function returns -ENODEV, otherwise the UBI device
  * number is returned.
  */
 int ubi_major2num(int major)
 {
 	int i, ubi_num = -ENODEV;
 	spin_lock(&ubi_devices_lock);
 	for (i = 0; i < UBI_MAX_DEVICES; i++) {
 		struct ubi_device *ubi = ubi_devices[i];
 		if (ubi && MAJOR(ubi->cdev.dev) == major) {
 			ubi_num = ubi->ubi_num;
 			break;
 		}
 	}
 	spin_unlock(&ubi_devices_lock);
 	return ubi_num;
 }
 /* "Show" method for files in '/<sysfs>/class/ubi/ubiX/' */
 static ssize_t dev_attribute_show(struct device *dev,
 				  struct device_attribute *attr, char *buf)
 {
 	ssize_t ret;
 	struct ubi_device *ubi;
 	/*
 	 * The below code looks weird, but it actually makes sense. We get the
 	 * UBI device reference from the contained 'struct ubi_device'. But it
 	 * is unclear if the device was removed or not yet. Indeed, if the
 	 * device was removed before we increased its reference count,
 	 * 'ubi_get_device()' will return -ENODEV and we fail.
 	 *
 	 * Remember, 'struct ubi_device' is freed in the release function, so
 	 * we still can use 'ubi->ubi_num'.
 	 */
 	ubi = container_of(dev, struct ubi_device, dev);
 	ubi = ubi_get_device(ubi->ubi_num);
 	if (!ubi)
 		return -ENODEV;
 	if (attr == &dev_eraseblock_size)
 		ret = sprintf(buf, "%d\n", ubi->leb_size);
 	else if (attr == &dev_avail_eraseblocks)
 		ret = sprintf(buf, "%d\n", ubi->avail_pebs);
 	else if (attr == &dev_total_eraseblocks)
 		ret = sprintf(buf, "%d\n", ubi->good_peb_count);
 	else if (attr == &dev_volumes_count)
 		ret = sprintf(buf, "%d\n", ubi->vol_count - UBI_INT_VOL_COUNT);
 	else if (attr == &dev_max_ec)
 		ret = sprintf(buf, "%d\n", ubi->max_ec);
 	else if (attr == &dev_reserved_for_bad)
 		ret = sprintf(buf, "%d\n", ubi->beb_rsvd_pebs);
 	else if (attr == &dev_bad_peb_count)
 		ret = sprintf(buf, "%d\n", ubi->bad_peb_count);
 	else if (attr == &dev_max_vol_count)
 		ret = sprintf(buf, "%d\n", ubi->vtbl_slots);
 	else if (attr == &dev_min_io_size)
 		ret = sprintf(buf, "%d\n", ubi->min_io_size);
 	else if (attr == &dev_bgt_enabled)
 		ret = sprintf(buf, "%d\n", ubi->thread_enabled);
 	else if (attr == &dev_mtd_num)
 		ret = sprintf(buf, "%d\n", ubi->mtd->index);
 	else
 		ret = -EINVAL;
 	ubi_put_device(ubi);
 	return ret;
 }
 static void dev_release(struct device *dev)
 {
 	struct ubi_device *ubi = container_of(dev, struct ubi_device, dev);
 	kfree(ubi);
 }
 /**
  * ubi_sysfs_init - initialize sysfs for an UBI device.
  * @ubi: UBI device description object
  * @ref: set to %1 on exit in case of failure if a reference to @ubi->dev was
  *       taken
  *
  * This function returns zero in case of success and a negative error code in
  * case of failure.
  */
 static int ubi_sysfs_init(struct ubi_device *ubi, int *ref)
 {
 	int err;
 	ubi->dev.release = dev_release;
 	ubi->dev.devt = ubi->cdev.dev;
 	ubi->dev.class = ubi_class;
 	dev_set_name(&ubi->dev, UBI_NAME_STR"%d", ubi->ubi_num);
 	err = device_register(&ubi->dev);
 	if (err)
 		return err;
 	*ref = 1;
 	err = device_create_file(&ubi->dev, &dev_eraseblock_size);
 	if (err)
 		return err;
 	err = device_create_file(&ubi->dev, &dev_avail_eraseblocks);
 	if (err)
 		return err;
 	err = device_create_file(&ubi->dev, &dev_total_eraseblocks);
 	if (err)
 		return err;
 	err = device_create_file(&ubi->dev, &dev_volumes_count);
 	if (err)
 		return err;
 	err = device_create_file(&ubi->dev, &dev_max_ec);
 	if (err)
 		return err;
 	err = device_create_file(&ubi->dev, &dev_reserved_for_bad);
 	if (err)
 		return err;
 	err = device_create_file(&ubi->dev, &dev_bad_peb_count);
 	if (err)
 		return err;
 	err = device_create_file(&ubi->dev, &dev_max_vol_count);
 	if (err)
 		return err;
 	err = device_create_file(&ubi->dev, &dev_min_io_size);
 	if (err)
 		return err;
 	err = device_create_file(&ubi->dev, &dev_bgt_enabled);
 	if (err)
 		return err;
 	err = device_create_file(&ubi->dev, &dev_mtd_num);
 	return err;
 }
 /**
  * ubi_sysfs_close - close sysfs for an UBI device.
  * @ubi: UBI device description object
  */
 static void ubi_sysfs_close(struct ubi_device *ubi)
 {
 	device_remove_file(&ubi->dev, &dev_mtd_num);
 	device_remove_file(&ubi->dev, &dev_bgt_enabled);
 	device_remove_file(&ubi->dev, &dev_min_io_size);
 	device_remove_file(&ubi->dev, &dev_max_vol_count);
 	device_remove_file(&ubi->dev, &dev_bad_peb_count);
 	device_remove_file(&ubi->dev, &dev_reserved_for_bad);
 	device_remove_file(&ubi->dev, &dev_max_ec);
 	device_remove_file(&ubi->dev, &dev_volumes_count);
 	device_remove_file(&ubi->dev, &dev_total_eraseblocks);
 	device_remove_file(&ubi->dev, &dev_avail_eraseblocks);
 	device_remove_file(&ubi->dev, &dev_eraseblock_size);
 	device_unregister(&ubi->dev);
 }
 /**
  * kill_volumes - destroy all user volumes.
  * @ubi: UBI device description object
  */
 static void kill_volumes(struct ubi_device *ubi)
 {
 	int i;
 	for (i = 0; i < ubi->vtbl_slots; i++)
 		if (ubi->volumes[i])
 			ubi_free_volume(ubi, ubi->volumes[i]);
 }
 /**
  * uif_init - initialize user interfaces for an UBI device.
  * @ubi: UBI device description object
  * @ref: set to %1 on exit in case of failure if a reference to @ubi->dev was
  *       taken, otherwise set to %0
  *
  * This function initializes various user interfaces for an UBI device. If the
  * initialization fails at an early stage, this function frees all the
  * resources it allocated, returns an error, and @ref is set to %0. However,
  * if the initialization fails after the UBI device was registered in the
  * driver core subsystem, this function takes a reference to @ubi->dev, because
  * otherwise the release function ('dev_release()') would free whole @ubi
  * object. The @ref argument is set to %1 in this case. The caller has to put
  * this reference.
  *
  * This function returns zero in case of success and a negative error code in
  * case of failure.
  */
 static int uif_init(struct ubi_device *ubi, int *ref)
 {
 	int i, err;
 	dev_t dev;
 	*ref = 0;
 	sprintf(ubi->ubi_name, UBI_NAME_STR "%d", ubi->ubi_num);
 	/*
 	 * Major numbers for the UBI character devices are allocated
 	 * dynamically. Major numbers of volume character devices are
 	 * equivalent to ones of the corresponding UBI character device. Minor
 	 * numbers of UBI character devices are 0, while minor numbers of
 	 * volume character devices start from 1. Thus, we allocate one major
 	 * number and ubi->vtbl_slots + 1 minor numbers.
 	 */
 	err = alloc_chrdev_region(&dev, 0, ubi->vtbl_slots + 1, ubi->ubi_name);
 	if (err) {
 		ubi_err("cannot register UBI character devices");
 		return err;
 	}
 	ubi_assert(MINOR(dev) == 0);
 	cdev_init(&ubi->cdev, &ubi_cdev_operations);
 	dbg_gen("%s major is %u", ubi->ubi_name, MAJOR(dev));
 	ubi->cdev.owner = THIS_MODULE;
 	err = cdev_add(&ubi->cdev, dev, 1);
 	if (err) {
 		ubi_err("cannot add character device");
 		goto out_unreg;
 	}
 	err = ubi_sysfs_init(ubi, ref);
 	if (err)
 		goto out_sysfs;
 	for (i = 0; i < ubi->vtbl_slots; i++)
 		if (ubi->volumes[i]) {
 			err = ubi_add_volume(ubi, ubi->volumes[i]);
 			if (err) {
 				ubi_err("cannot add volume %d", i);
 				goto out_volumes;
 			}
 		}
 	return 0;
 out_volumes:
 	kill_volumes(ubi);
 out_sysfs:
 	if (*ref)
 		get_device(&ubi->dev);
 	ubi_sysfs_close(ubi);
 	cdev_del(&ubi->cdev);
 out_unreg:
 	unregister_chrdev_region(ubi->cdev.dev, ubi->vtbl_slots + 1);
 	ubi_err("cannot initialize UBI %s, error %d", ubi->ubi_name, err);
 	return err;
 }
 /**
  * uif_close - close user interfaces for an UBI device.
  * @ubi: UBI device description object
  *
  * Note, since this function un-registers UBI volume device objects (@vol->dev),
  * the memory allocated voe the volumes is freed as well (in the release
  * function).
  */
 static void uif_close(struct ubi_device *ubi)
 {
 	kill_volumes(ubi);
 	ubi_sysfs_close(ubi);
 	cdev_del(&ubi->cdev);
 	unregister_chrdev_region(ubi->cdev.dev, ubi->vtbl_slots + 1);
 }
 /**
  * ubi_free_internal_volumes - free internal volumes.
  * @ubi: UBI device description object
  */
 void ubi_free_internal_volumes(struct ubi_device *ubi)
 {
 	int i;
 	for (i = ubi->vtbl_slots;
 	     i < ubi->vtbl_slots + UBI_INT_VOL_COUNT; i++) {
 		kfree(ubi->volumes[i]->eba_tbl);
 		kfree(ubi->volumes[i]);
 	}
 }
 static int get_bad_peb_limit(const struct ubi_device *ubi, int max_beb_per1024)
 {
 	int limit, device_pebs;
 	uint64_t device_size;
 	if (!max_beb_per1024)
 		return 0;
 	/*
 	 * Here we are using size of the entire flash chip and
 	 * not just the MTD partition size because the maximum
 	 * number of bad eraseblocks is a percentage of the
 	 * whole device and bad eraseblocks are not fairly
 	 * distributed over the flash chip. So the worst case
 	 * is that all the bad eraseblocks of the chip are in
 	 * the MTD partition we are attaching (ubi->mtd).
 	 */
 	device_size = mtd_get_device_size(ubi->mtd);
 	device_pebs = mtd_div_by_eb(device_size, ubi->mtd);
 	limit = mult_frac(device_pebs, max_beb_per1024, 1024);
 	/* Round it up */
 	if (mult_frac(limit, 1024, max_beb_per1024) < device_pebs)
 		limit += 1;
 	return limit;
 }
 /**
  * io_init - initialize I/O sub-system for a given UBI device.
  * @ubi: UBI device description object
  * @max_beb_per1024: maximum expected number of bad PEB per 1024 PEBs
  *
  * If @ubi->vid_hdr_offset or @ubi->leb_start is zero, default offsets are
  * assumed:
  *   o EC header is always at offset zero - this cannot be changed;
  *   o VID header starts just after the EC header at the closest address
  *     aligned to @io->hdrs_min_io_size;
  *   o data starts just after the VID header at the closest address aligned to
  *     @io->min_io_size
  *
  * This function returns zero in case of success and a negative error code in
  * case of failure.
  */
 static int io_init(struct ubi_device *ubi, int max_beb_per1024)
 {
 	dbg_gen("sizeof(struct ubi_ainf_peb) %zu", sizeof(struct ubi_ainf_peb));
 	dbg_gen("sizeof(struct ubi_wl_entry) %zu", sizeof(struct ubi_wl_entry));
 	if (ubi->mtd->numeraseregions != 0) {
 		/*
 		 * Some flashes have several erase regions. Different regions
 		 * may have different eraseblock size and other
 		 * characteristics. It looks like mostly multi-region flashes
 		 * have one "main" region and one or more small regions to
 		 * store boot loader code or boot parameters or whatever. I
 		 * guess we should just pick the largest region. But this is
 		 * not implemented.
 		 */
 		ubi_err("multiple regions, not implemented");
 		return -EINVAL;
 	}
 	if (ubi->vid_hdr_offset < 0)
 		return -EINVAL;
 	/*
 	 * Note, in this implementation we support MTD devices with 0x7FFFFFFF
 	 * physical eraseblocks maximum.
 	 */
 	ubi->peb_size   = ubi->mtd->erasesize;
 	ubi->peb_count  = mtd_div_by_eb(ubi->mtd->size, ubi->mtd);
 	ubi->flash_size = ubi->mtd->size;
 	if (mtd_can_have_bb(ubi->mtd)) {
 		ubi->bad_allowed = 1;
 		ubi->bad_peb_limit = get_bad_peb_limit(ubi, max_beb_per1024);
 	}
 	if (ubi->mtd->type == MTD_NORFLASH) {
 		ubi_assert(ubi->mtd->writesize == 1);
 		ubi->nor_flash = 1;
 	}
 	ubi->min_io_size = ubi->mtd->writesize;
 	ubi->hdrs_min_io_size = ubi->mtd->writesize >> ubi->mtd->subpage_sft;
 	/*
 	 * Make sure minimal I/O unit is power of 2. Note, there is no
 	 * fundamental reason for this assumption. It is just an optimization
 	 * which allows us to avoid costly division operations.
 	 */
 	if (!is_power_of_2(ubi->min_io_size)) {
 		ubi_err("min. I/O unit (%d) is not power of 2",
 			ubi->min_io_size);
 		return -EINVAL;
 	}
 	ubi_assert(ubi->hdrs_min_io_size > 0);
 	ubi_assert(ubi->hdrs_min_io_size <= ubi->min_io_size);
 	ubi_assert(ubi->min_io_size % ubi->hdrs_min_io_size == 0);
 	ubi->max_write_size = ubi->mtd->writebufsize;
 	/*
 	 * Maximum write size has to be greater or equivalent to min. I/O
 	 * size, and be multiple of min. I/O size.
 	 */
 	if (ubi->max_write_size < ubi->min_io_size ||
 	    ubi->max_write_size % ubi->min_io_size ||
 	    !is_power_of_2(ubi->max_write_size)) {
 		ubi_err("bad write buffer size %d for %d min. I/O unit",
 			ubi->max_write_size, ubi->min_io_size);
 		return -EINVAL;
 	}
 	/* Calculate default aligned sizes of EC and VID headers */
 	ubi->ec_hdr_alsize = ALIGN(UBI_EC_HDR_SIZE, ubi->hdrs_min_io_size);
 	ubi->vid_hdr_alsize = ALIGN(UBI_VID_HDR_SIZE, ubi->hdrs_min_io_size);
 	dbg_gen("min_io_size      %d", ubi->min_io_size);
 	dbg_gen("max_write_size   %d", ubi->max_write_size);
 	dbg_gen("hdrs_min_io_size %d", ubi->hdrs_min_io_size);
 	dbg_gen("ec_hdr_alsize    %d", ubi->ec_hdr_alsize);
 	dbg_gen("vid_hdr_alsize   %d", ubi->vid_hdr_alsize);
 	if (ubi->vid_hdr_offset == 0)
 		/* Default offset */
 		ubi->vid_hdr_offset = ubi->vid_hdr_aloffset =
 				      ubi->ec_hdr_alsize;
 	else {
 		ubi->vid_hdr_aloffset = ubi->vid_hdr_offset &
 						~(ubi->hdrs_min_io_size - 1);
 		ubi->vid_hdr_shift = ubi->vid_hdr_offset -
 						ubi->vid_hdr_aloffset;
 	}
 	/* Similar for the data offset */
 	ubi->leb_start = ubi->vid_hdr_offset + UBI_VID_HDR_SIZE;
 	ubi->leb_start = ALIGN(ubi->leb_start, ubi->min_io_size);
 	dbg_gen("vid_hdr_offset   %d", ubi->vid_hdr_offset);
 	dbg_gen("vid_hdr_aloffset %d", ubi->vid_hdr_aloffset);
 	dbg_gen("vid_hdr_shift    %d", ubi->vid_hdr_shift);
 	dbg_gen("leb_start        %d", ubi->leb_start);
 	/* The shift must be aligned to 32-bit boundary */
 	if (ubi->vid_hdr_shift % 4) {
 		ubi_err("unaligned VID header shift %d",
 			ubi->vid_hdr_shift);
 		return -EINVAL;
 	}
 	/* Check sanity */
 	if (ubi->vid_hdr_offset < UBI_EC_HDR_SIZE ||
 	    ubi->leb_start < ubi->vid_hdr_offset + UBI_VID_HDR_SIZE ||
 	    ubi->leb_start > ubi->peb_size - UBI_VID_HDR_SIZE ||
 	    ubi->leb_start & (ubi->min_io_size - 1)) {
 		ubi_err("bad VID header (%d) or data offsets (%d)",
 			ubi->vid_hdr_offset, ubi->leb_start);
 		return -EINVAL;
 	}
 	/*
 	 * Set maximum amount of physical erroneous eraseblocks to be 10%.
 	 * Erroneous PEB are those which have read errors.
 	 */
 	ubi->max_erroneous = ubi->peb_count / 10;
 	if (ubi->max_erroneous < 16)
 		ubi->max_erroneous = 16;
 	dbg_gen("max_erroneous    %d", ubi->max_erroneous);
 	/*
 	 * It may happen that EC and VID headers are situated in one minimal
 	 * I/O unit. In this case we can only accept this UBI image in
 	 * read-only mode.
 	 */
 	if (ubi->vid_hdr_offset + UBI_VID_HDR_SIZE <= ubi->hdrs_min_io_size) {
 		ubi_warn("EC and VID headers are in the same minimal I/O unit, switch to read-only mode");
 		ubi->ro_mode = 1;
 	}
 	ubi->leb_size = ubi->peb_size - ubi->leb_start;
 	if (!(ubi->mtd->flags & MTD_WRITEABLE)) {
 		ubi_msg("MTD device %d is write-protected, attach in read-only mode",
 			ubi->mtd->index);
 		ubi->ro_mode = 1;
 	}
 	/*
 	 * Note, ideally, we have to initialize @ubi->bad_peb_count here. But
 	 * unfortunately, MTD does not provide this information. We should loop
 	 * over all physical eraseblocks and invoke mtd->block_is_bad() for
 	 * each physical eraseblock. So, we leave @ubi->bad_peb_count
 	 * uninitialized so far.
 	 */
 	return 0;
 }
 /**
  * autoresize - re-size the volume which has the "auto-resize" flag set.
  * @ubi: UBI device description object
  * @vol_id: ID of the volume to re-size
  *
  * This function re-sizes the volume marked by the %UBI_VTBL_AUTORESIZE_FLG in
  * the volume table to the largest possible size. See comments in ubi-header.h
  * for more description of the flag. Returns zero in case of success and a
  * negative error code in case of failure.
  */
 static int autoresize(struct ubi_device *ubi, int vol_id)
 {
 	struct ubi_volume_desc desc;
 	struct ubi_volume *vol = ubi->volumes[vol_id];
 	int err, old_reserved_pebs = vol->reserved_pebs;
 	if (ubi->ro_mode) {
 		ubi_warn("skip auto-resize because of R/O mode");
 		return 0;
 	}
 	/*
 	 * Clear the auto-resize flag in the volume in-memory copy of the
 	 * volume table, and 'ubi_resize_volume()' will propagate this change
 	 * to the flash.
 	 */
 	ubi->vtbl[vol_id].flags &= ~UBI_VTBL_AUTORESIZE_FLG;
 	if (ubi->avail_pebs == 0) {
 		struct ubi_vtbl_record vtbl_rec;
 		/*
 		 * No available PEBs to re-size the volume, clear the flag on
 		 * flash and exit.
 		 */
 		vtbl_rec = ubi->vtbl[vol_id];
 		err = ubi_change_vtbl_record(ubi, vol_id, &vtbl_rec);
 		if (err)
 			ubi_err("cannot clean auto-resize flag for volume %d",
 				vol_id);
 	} else {
 		desc.vol = vol;
 		err = ubi_resize_volume(&desc,
 					old_reserved_pebs + ubi->avail_pebs);
 		if (err)
 			ubi_err("cannot auto-resize volume %d", vol_id);
 	}
 	if (err)
 		return err;
 	ubi_msg("volume %d (\"%s\") re-sized from %d to %d LEBs", vol_id,
 		vol->name, old_reserved_pebs, vol->reserved_pebs);
 	return 0;
 }
 /**
  * ubi_attach_mtd_dev - attach an MTD device.
  * @mtd: MTD device description object
  * @ubi_num: number to assign to the new UBI device
  * @vid_hdr_offset: VID header offset
  * @max_beb_per1024: maximum expected number of bad PEB per 1024 PEBs
  *
  * This function attaches MTD device @mtd_dev to UBI and assign @ubi_num number
  * to the newly created UBI device, unless @ubi_num is %UBI_DEV_NUM_AUTO, in
  * which case this function finds a vacant device number and assigns it
  * automatically. Returns the new UBI device number in case of success and a
  * negative error code in case of failure.
  *
  * Note, the invocations of this function has to be serialized by the
  * @ubi_devices_mutex.
  */
 int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num,
 		       int vid_hdr_offset, int max_beb_per1024)
 {
 	struct ubi_device *ubi;
 	int i, err, ref = 0;
 	if (max_beb_per1024 < 0 || max_beb_per1024 > MAX_MTD_UBI_BEB_LIMIT)
 		return -EINVAL;
 	if (!max_beb_per1024)
 		max_beb_per1024 = CONFIG_MTD_UBI_BEB_LIMIT;
 	/*
 	 * Check if we already have the same MTD device attached.
 	 *
 	 * Note, this function assumes that UBI devices creations and deletions
 	 * are serialized, so it does not take the &ubi_devices_lock.
 	 */
 	for (i = 0; i < UBI_MAX_DEVICES; i++) {
 		ubi = ubi_devices[i];
 		if (ubi && mtd->index == ubi->mtd->index) {
 			ubi_err("mtd%d is already attached to ubi%d",
 				mtd->index, i);
 			return -EEXIST;
 		}
 	}
 	/*
 	 * Make sure this MTD device is not emulated on top of an UBI volume
 	 * already. Well, generally this recursion works fine, but there are
 	 * different problems like the UBI module takes a reference to itself
 	 * by attaching (and thus, opening) the emulated MTD device. This
 	 * results in inability to unload the module. And in general it makes
 	 * no sense to attach emulated MTD devices, so we prohibit this.
 	 */
 	if (mtd->type == MTD_UBIVOLUME) {
 		ubi_err("refuse attaching mtd%d - it is already emulated on top of UBI",
 			mtd->index);
 		return -EINVAL;
 	}
 	if (ubi_num == UBI_DEV_NUM_AUTO) {
 		/* Search for an empty slot in the @ubi_devices array */
 		for (ubi_num = 0; ubi_num < UBI_MAX_DEVICES; ubi_num++)
 			if (!ubi_devices[ubi_num])
 				break;
 		if (ubi_num == UBI_MAX_DEVICES) {
 			ubi_err("only %d UBI devices may be created",
 				UBI_MAX_DEVICES);
 			return -ENFILE;
 		}
 	} else {
 		if (ubi_num >= UBI_MAX_DEVICES)
 			return -EINVAL;
 		/* Make sure ubi_num is not busy */
 		if (ubi_devices[ubi_num]) {
 			ubi_err("ubi%d already exists", ubi_num);
 			return -EEXIST;
 		}
 	}
 	ubi = kzalloc(sizeof(struct ubi_device), GFP_KERNEL);
 	if (!ubi)
 		return -ENOMEM;
 	ubi->mtd = mtd;
 	ubi->ubi_num = ubi_num;
 	ubi->vid_hdr_offset = vid_hdr_offset;
 	ubi->autoresize_vol_id = -1;
 #ifdef CONFIG_MTD_UBI_FASTMAP
 	ubi->fm_pool.used = ubi->fm_pool.size = 0;
 	ubi->fm_wl_pool.used = ubi->fm_wl_pool.size = 0;
 	/*
 	 * fm_pool.max_size is 5% of the total number of PEBs but it's also
 	 * between UBI_FM_MAX_POOL_SIZE and UBI_FM_MIN_POOL_SIZE.
 	 */
 	ubi->fm_pool.max_size = min(((int)mtd_div_by_eb(ubi->mtd->size,
 		ubi->mtd) / 100) * 5, UBI_FM_MAX_POOL_SIZE);
 	if (ubi->fm_pool.max_size < UBI_FM_MIN_POOL_SIZE)
 		ubi->fm_pool.max_size = UBI_FM_MIN_POOL_SIZE;
 	ubi->fm_wl_pool.max_size = UBI_FM_WL_POOL_SIZE;
 	ubi->fm_disabled = !fm_autoconvert;
 	if (!ubi->fm_disabled && (int)mtd_div_by_eb(ubi->mtd->size, ubi->mtd)
 	    <= UBI_FM_MAX_START) {
 		ubi_err("More than %i PEBs are needed for fastmap, sorry.",
 			UBI_FM_MAX_START);
 		ubi->fm_disabled = 1;
 	}
 	ubi_msg("default fastmap pool size: %d", ubi->fm_pool.max_size);
 	ubi_msg("default fastmap WL pool size: %d", ubi->fm_wl_pool.max_size);
 #else
 	ubi->fm_disabled = 1;
 #endif
 	mutex_init(&ubi->buf_mutex);
 	mutex_init(&ubi->ckvol_mutex);
 	mutex_init(&ubi->device_mutex);
 	spin_lock_init(&ubi->volumes_lock);
 	mutex_init(&ubi->fm_mutex);
 	init_rwsem(&ubi->fm_sem);
 	ubi_msg("attaching mtd%d to ubi%d", mtd->index, ubi_num);
 	err = io_init(ubi, max_beb_per1024);
 	if (err)
 		goto out_free;
 	err = -ENOMEM;
 	ubi->peb_buf = vmalloc(ubi->peb_size);
 	if (!ubi->peb_buf)
 		goto out_free;
 #ifdef CONFIG_MTD_UBI_FASTMAP
 	ubi->fm_size = ubi_calc_fm_size(ubi);
 	ubi->fm_buf = vzalloc(ubi->fm_size);
 	if (!ubi->fm_buf)
 		goto out_free;
 #endif
 	err = ubi_attach(ubi, 0);
 	if (err) {
 		ubi_err("failed to attach mtd%d, error %d", mtd->index, err);
 		goto out_free;
 	}
 	if (ubi->autoresize_vol_id != -1) {
 		err = autoresize(ubi, ubi->autoresize_vol_id);
 		if (err)
 			goto out_detach;
 	}
 	err = uif_init(ubi, &ref);
 	if (err)
 		goto out_detach;
 	err = ubi_debugfs_init_dev(ubi);
 	if (err)
 		goto out_uif;
 	ubi->bgt_thread = kthread_create(ubi_thread, ubi, "%s", ubi->bgt_name);
 	if (IS_ERR(ubi->bgt_thread)) {
 		err = PTR_ERR(ubi->bgt_thread);
 		ubi_err("cannot spawn \"%s\", error %d", ubi->bgt_name,
 			err);
 		goto out_debugfs;
 	}
 	ubi_msg("attached mtd%d (name \"%s\", size %llu MiB) to ubi%d",
 		mtd->index, mtd->name, ubi->flash_size >> 20, ubi_num);
 	ubi_msg("PEB size: %d bytes (%d KiB), LEB size: %d bytes",
 		ubi->peb_size, ubi->peb_size >> 10, ubi->leb_size);
 	ubi_msg("min./max. I/O unit sizes: %d/%d, sub-page size %d",
 		ubi->min_io_size, ubi->max_write_size, ubi->hdrs_min_io_size);
 	ubi_msg("VID header offset: %d (aligned %d), data offset: %d",
 		ubi->vid_hdr_offset, ubi->vid_hdr_aloffset, ubi->leb_start);
 	ubi_msg("good PEBs: %d, bad PEBs: %d, corrupted PEBs: %d",
 		ubi->good_peb_count, ubi->bad_peb_count, ubi->corr_peb_count);
 	ubi_msg("user volume: %d, internal volumes: %d, max. volumes count: %d",
 		ubi->vol_count - UBI_INT_VOL_COUNT, UBI_INT_VOL_COUNT,
 		ubi->vtbl_slots);
 	ubi_msg("max/mean erase counter: %d/%d, WL threshold: %d, image sequence number: %u",
 		ubi->max_ec, ubi->mean_ec, CONFIG_MTD_UBI_WL_THRESHOLD,
 		ubi->image_seq);
 	ubi_msg("available PEBs: %d, total reserved PEBs: %d, PEBs reserved for bad PEB handling: %d",
 		ubi->avail_pebs, ubi->rsvd_pebs, ubi->beb_rsvd_pebs);
 	/*
 	 * The below lock makes sure we do not race with 'ubi_thread()' which
 	 * checks @ubi->thread_enabled. Otherwise we may fail to wake it up.
 	 */
 	spin_lock(&ubi->wl_lock);
 	ubi->thread_enabled = 1;
 	wake_up_process(ubi->bgt_thread);
 	spin_unlock(&ubi->wl_lock);
 	ubi_devices[ubi_num] = ubi;
 	ubi_notify_all(ubi, UBI_VOLUME_ADDED, NULL);
 	return ubi_num;
 out_debugfs:
 	ubi_debugfs_exit_dev(ubi);
 out_uif:
 	get_device(&ubi->dev);
 	ubi_assert(ref);
 	uif_close(ubi);
 out_detach:
 	ubi_wl_close(ubi);
 	ubi_free_internal_volumes(ubi);
 	vfree(ubi->vtbl);
 out_free:
 	vfree(ubi->peb_buf);
 	vfree(ubi->fm_buf);
 	if (ref)
 		put_device(&ubi->dev);
 	else
 		kfree(ubi);
 	return err;
 }
 /**
  * ubi_detach_mtd_dev - detach an MTD device.
  * @ubi_num: UBI device number to detach from
  * @anyway: detach MTD even if device reference count is not zero
  *
  * This function destroys an UBI device number @ubi_num and detaches the
  * underlying MTD device. Returns zero in case of success and %-EBUSY if the
  * UBI device is busy and cannot be destroyed, and %-EINVAL if it does not
  * exist.
  *
  * Note, the invocations of this function has to be serialized by the
  * @ubi_devices_mutex.
  */
 int ubi_detach_mtd_dev(int ubi_num, int anyway)
 {
 	struct ubi_device *ubi;
 	if (ubi_num < 0 || ubi_num >= UBI_MAX_DEVICES)
 		return -EINVAL;
 	ubi = ubi_get_device(ubi_num);
 	if (!ubi)
 		return -EINVAL;
 	spin_lock(&ubi_devices_lock);
 	put_device(&ubi->dev);
 	ubi->ref_count -= 1;
 	if (ubi->ref_count) {
 		if (!anyway) {
 			spin_unlock(&ubi_devices_lock);
 			return -EBUSY;
 		}
 		/* This may only happen if there is a bug */
 		ubi_err("%s reference count %d, destroy anyway",
 			ubi->ubi_name, ubi->ref_count);
 	}
 	ubi_devices[ubi_num] = NULL;
 	spin_unlock(&ubi_devices_lock);
 	ubi_assert(ubi_num == ubi->ubi_num);
 	ubi_notify_all(ubi, UBI_VOLUME_REMOVED, NULL);
 	ubi_msg("detaching mtd%d from ubi%d", ubi->mtd->index, ubi_num);
 #ifdef CONFIG_MTD_UBI_FASTMAP
 	/* If we don't write a new fastmap at detach time we lose all
 	 * EC updates that have been made since the last written fastmap. */
 	ubi_update_fastmap(ubi);
 #endif
 	/*
 	 * Before freeing anything, we have to stop the background thread to
 	 * prevent it from doing anything on this device while we are freeing.
 	 */
 	if (ubi->bgt_thread)
 		kthread_stop(ubi->bgt_thread);
 	/*
 	 * Get a reference to the device in order to prevent 'dev_release()'
 	 * from freeing the @ubi object.
 	 */
 	get_device(&ubi->dev);
 	ubi_debugfs_exit_dev(ubi);
 	uif_close(ubi);
 	ubi_wl_close(ubi);
 	ubi_free_internal_volumes(ubi);
 	vfree(ubi->vtbl);
 	put_mtd_device(ubi->mtd);
 	vfree(ubi->peb_buf);
 	vfree(ubi->fm_buf);
 	ubi_msg("mtd%d is detached from ubi%d", ubi->mtd->index, ubi->ubi_num);
 	put_device(&ubi->dev);
 	return 0;
 }
 /**
  * open_mtd_by_chdev - open an MTD device by its character device node path.
  * @mtd_dev: MTD character device node path
  *
  * This helper function opens an MTD device by its character node device path.
  * Returns MTD device description object in case of success and a negative
  * error code in case of failure.
  */
 static struct mtd_info * __init open_mtd_by_chdev(const char *mtd_dev)
 {
 	int err, major, minor, mode;
 	struct path path;
 	/* Probably this is an MTD character device node path */
 	err = kern_path(mtd_dev, LOOKUP_FOLLOW, &path);
 	if (err)
 		return ERR_PTR(err);
 	/* MTD device number is defined by the major / minor numbers */
 	major = imajor(path.dentry->d_inode);
 	minor = iminor(path.dentry->d_inode);
 	mode = path.dentry->d_inode->i_mode;
 	path_put(&path);
 	if (major != MTD_CHAR_MAJOR || !S_ISCHR(mode))
 		return ERR_PTR(-EINVAL);
 	if (minor & 1)
 		/*
 		 * Just do not think the "/dev/mtdrX" devices support is need,
 		 * so do not support them to avoid doing extra work.
 		 */
 		return ERR_PTR(-EINVAL);
 	return get_mtd_device(NULL, minor / 2);
 }
 /**
  * open_mtd_device - open MTD device by name, character device path, or number.
  * @mtd_dev: name, character device node path, or MTD device device number
  *
  * This function tries to open and MTD device described by @mtd_dev string,
  * which is first treated as ASCII MTD device number, and if it is not true, it
  * is treated as MTD device name, and if that is also not true, it is treated
  * as MTD character device node path. Returns MTD device description object in
  * case of success and a negative error code in case of failure.
  */
 static struct mtd_info * __init open_mtd_device(const char *mtd_dev)
 {
 	struct mtd_info *mtd;
 	int mtd_num;
 	char *endp;
 	mtd_num = simple_strtoul(mtd_dev, &endp, 0);
 	if (*endp != '\0' || mtd_dev == endp) {
 		/*
 		 * This does not look like an ASCII integer, probably this is
 		 * MTD device name.
 		 */
 		mtd = get_mtd_device_nm(mtd_dev);
 		if (IS_ERR(mtd) && PTR_ERR(mtd) == -ENODEV)
 			/* Probably this is an MTD character device node path */
 			mtd = open_mtd_by_chdev(mtd_dev);
 	} else
 		mtd = get_mtd_device(NULL, mtd_num);
 	return mtd;
 }
 static int __init ubi_init(void)
 {
 	int err, i, k;
 	/* Ensure that EC and VID headers have correct size */
 	BUILD_BUG_ON(sizeof(struct ubi_ec_hdr) != 64);
 	BUILD_BUG_ON(sizeof(struct ubi_vid_hdr) != 64);
 	if (mtd_devs > UBI_MAX_DEVICES) {
 		ubi_err("too many MTD devices, maximum is %d", UBI_MAX_DEVICES);
 		return -EINVAL;
 	}
 	/* Create base sysfs directory and sysfs files */
 	ubi_class = class_create(THIS_MODULE, UBI_NAME_STR);
 	if (IS_ERR(ubi_class)) {
 		err = PTR_ERR(ubi_class);
 		ubi_err("cannot create UBI class");
 		goto out;
 	}
 	err = class_create_file(ubi_class, &ubi_version);
 	if (err) {
 		ubi_err("cannot create sysfs file");
 		goto out_class;
 	}
 	err = misc_register(&ubi_ctrl_cdev);
 	if (err) {
 		ubi_err("cannot register device");
 		goto out_version;
 	}
 	ubi_wl_entry_slab = kmem_cache_create("ubi_wl_entry_slab",
 					      sizeof(struct ubi_wl_entry),
 					      0, 0, NULL);
 	if (!ubi_wl_entry_slab)
 		goto out_dev_unreg;
 	err = ubi_debugfs_init();
 	if (err)
 		goto out_slab;
 	/* Attach MTD devices */
 	for (i = 0; i < mtd_devs; i++) {
 		struct mtd_dev_param *p = &mtd_dev_param[i];
 		struct mtd_info *mtd;
 		cond_resched();
 		mtd = open_mtd_device(p->name);
 		if (IS_ERR(mtd)) {
 			err = PTR_ERR(mtd);
-			goto out_detach;
+			ubi_err("cannot open mtd %s, error %d", p->name, err);
+			/* See comment below re-ubi_is_module(). */
+			if (ubi_is_module())
+				goto out_detach;
+			continue;
 		}
 		mutex_lock(&ubi_devices_mutex);
-		err = ubi_attach_mtd_dev(mtd, UBI_DEV_NUM_AUTO,
+		err = ubi_attach_mtd_dev(mtd, p->ubi_num,
 					 p->vid_hdr_offs, p->max_beb_per1024);
 		mutex_unlock(&ubi_devices_mutex);
 		if (err < 0) {
 			ubi_err("cannot attach mtd%d", mtd->index);
 			put_mtd_device(mtd);
 			/*
 			 * Originally UBI stopped initializing on any error.
 			 * However, later on it was found out that this
 			 * behavior is not very good when UBI is compiled into
 			 * the kernel and the MTD devices to attach are passed
 			 * through the command line. Indeed, UBI failure
 			 * stopped whole boot sequence.
 			 *
 			 * To fix this, we changed the behavior for the
 			 * non-module case, but preserved the old behavior for
 			 * the module case, just for compatibility. This is a
 			 * little inconsistent, though.
 			 */
 			if (ubi_is_module())
 				goto out_detach;
 		}
 	}
 	return 0;
 out_detach:
 	for (k = 0; k < i; k++)
 		if (ubi_devices[k]) {
 			mutex_lock(&ubi_devices_mutex);
 			ubi_detach_mtd_dev(ubi_devices[k]->ubi_num, 1);
 			mutex_unlock(&ubi_devices_mutex);
 		}
 	ubi_debugfs_exit();
 out_slab:
 	kmem_cache_destroy(ubi_wl_entry_slab);
 out_dev_unreg:
 	misc_deregister(&ubi_ctrl_cdev);
 out_version:
 	class_remove_file(ubi_class, &ubi_version);
 out_class:
 	class_destroy(ubi_class);
 out:
-	ubi_err("UBI error: cannot initialize UBI, error %d", err);
+	ubi_err("cannot initialize UBI, error %d", err);
 	return err;
 }
 late_initcall(ubi_init);
 static void __exit ubi_exit(void)
 {
 	int i;
 	for (i = 0; i < UBI_MAX_DEVICES; i++)
 		if (ubi_devices[i]) {
 			mutex_lock(&ubi_devices_mutex);
 			ubi_detach_mtd_dev(ubi_devices[i]->ubi_num, 1);
 			mutex_unlock(&ubi_devices_mutex);
 		}
 	ubi_debugfs_exit();
 	kmem_cache_destroy(ubi_wl_entry_slab);
 	misc_deregister(&ubi_ctrl_cdev);
 	class_remove_file(ubi_class, &ubi_version);
 	class_destroy(ubi_class);
 }
 module_exit(ubi_exit);
 /**
  * bytes_str_to_int - convert a number of bytes string into an integer.
  * @str: the string to convert
  *
  * This function returns positive resulting integer in case of success and a
  * negative error code in case of failure.
  */
 static int __init bytes_str_to_int(const char *str)
 {
 	char *endp;
 	unsigned long result;
 	result = simple_strtoul(str, &endp, 0);
 	if (str == endp || result >= INT_MAX) {
-		ubi_err("UBI error: incorrect bytes count: \"%s\"\n", str);
+		ubi_err("incorrect bytes count: \"%s\"\n", str);
 		return -EINVAL;
 	}
 	switch (*endp) {
 	case 'G':
 		result *= 1024;
 	case 'M':
 		result *= 1024;
 	case 'K':
 		result *= 1024;
 		if (endp[1] == 'i' && endp[2] == 'B')
 			endp += 2;
 	case '\0':
 		break;
 	default:
-		ubi_err("UBI error: incorrect bytes count: \"%s\"\n", str);
+		ubi_err("incorrect bytes count: \"%s\"\n", str);
 		return -EINVAL;
 	}
 	return result;
 }
 /**
  * ubi_mtd_param_parse - parse the 'mtd=' UBI parameter.
  * @val: the parameter value to parse
  * @kp: not used
  *
  * This function returns zero in case of success and a negative error code in
  * case of error.
  */
 static int __init ubi_mtd_param_parse(const char *val, struct kernel_param *kp)
 {
 	int i, len;
 	struct mtd_dev_param *p;
 	char buf[MTD_PARAM_LEN_MAX];
 	char *pbuf = &buf[0];
-	char *tokens[MTD_PARAM_MAX_COUNT];
+	char *tokens[MTD_PARAM_MAX_COUNT], *token;
 	if (!val)
 		return -EINVAL;
 	if (mtd_devs == UBI_MAX_DEVICES) {
-		ubi_err("UBI error: too many parameters, max. is %d\n",
+		ubi_err("too many parameters, max. is %d\n",
 			UBI_MAX_DEVICES);
 		return -EINVAL;
 	}
 	len = strnlen(val, MTD_PARAM_LEN_MAX);
 	if (len == MTD_PARAM_LEN_MAX) {
-		ubi_err("UBI error: parameter \"%s\" is too long, max. is %d\n",
+		ubi_err("parameter \"%s\" is too long, max. is %d\n",
 			val, MTD_PARAM_LEN_MAX);
 		return -EINVAL;
 	}
 	if (len == 0) {
 		pr_warn("UBI warning: empty 'mtd=' parameter - ignored\n");
 		return 0;
 	}
 	strcpy(buf, val);
 	/* Get rid of the final newline */
 	if (buf[len - 1] == '\n')
 		buf[len - 1] = '\0';
 	for (i = 0; i < MTD_PARAM_MAX_COUNT; i++)
 		tokens[i] = strsep(&pbuf, ",");
 	if (pbuf) {
-		ubi_err("UBI error: too many arguments at \"%s\"\n", val);
+		ubi_err("too many arguments at \"%s\"\n", val);
 		return -EINVAL;
 	}
 	p = &mtd_dev_param[mtd_devs];
 	strcpy(&p->name[0], tokens[0]);
-	if (tokens[1])
+	token = tokens[1];
-		p->vid_hdr_offs = bytes_str_to_int(tokens[1]);
+	if (token) {
+		p->vid_hdr_offs = bytes_str_to_int(token);
-	if (p->vid_hdr_offs < 0)
+		if (p->vid_hdr_offs < 0)
-		return p->vid_hdr_offs;
+			return p->vid_hdr_offs;
+	}
-	if (tokens[2]) {
+	token = tokens[2];
-		int err = kstrtoint(tokens[2], 10, &p->max_beb_per1024);
+	if (token) {
+		int err = kstrtoint(token, 10, &p->max_beb_per1024);
 		if (err) {
-			ubi_err("UBI error: bad value for max_beb_per1024 parameter: %s",
+			ubi_err("bad value for max_beb_per1024 parameter: %s",
-				tokens[2]);
+				token);
 			return -EINVAL;
 		}
 	}
+	token = tokens[3];
+	if (token) {
+		int err = kstrtoint(token, 10, &p->ubi_num);
+		if (err) {
+			ubi_err("bad value for ubi_num parameter: %s", token);
+			return -EINVAL;
+		}
+	} else
+		p->ubi_num = UBI_DEV_NUM_AUTO;
 	mtd_devs += 1;
 	return 0;
 }
 module_param_call(mtd, ubi_mtd_param_parse, NULL, NULL, 000);
-MODULE_PARM_DESC(mtd, "MTD devices to attach. Parameter format: mtd=<name|num|path>[,<vid_hdr_offs>[,max_beb_per1024]].\n"
+MODULE_PARM_DESC(mtd, "MTD devices to attach. Parameter format: mtd=<name|num|path>[,<vid_hdr_offs>[,max_beb_per1024[,ubi_num]]].\n"
 		      "Multiple \"mtd\" parameters may be specified.\n"
 		      "MTD devices may be specified by their number, name, or path to the MTD character device node.\n"
 		      "Optional \"vid_hdr_offs\" parameter specifies UBI VID header position to be used by UBI. (default value if 0)\n"
 		      "Optional \"max_beb_per1024\" parameter specifies the maximum expected bad eraseblock per 1024 eraseblocks. (default value ("
 		      __stringify(CONFIG_MTD_UBI_BEB_LIMIT) ") if 0)\n"
+		      "Optional \"ubi_num\" parameter specifies UBI device number which have to be assigned to the newly created UBI device (assigned automatically by default)\n"
 		      "\n"
 		      "Example 1: mtd=/dev/mtd0 - attach MTD device /dev/mtd0.\n"
 		      "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"
 		      "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"
+		      "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"
 		      "\t(e.g. if the NAND *chipset* has 4096 PEB, 100 will be reserved for this UBI device).");
 #ifdef CONFIG_MTD_UBI_FASTMAP
 module_param(fm_autoconvert, bool, 0644);
 MODULE_PARM_DESC(fm_autoconvert, "Set this parameter to enable fastmap automatically on images without a fastmap.");
 #endif
 MODULE_VERSION(__stringify(UBI_VERSION));
 MODULE_DESCRIPTION("UBI - Unsorted Block Images");
 MODULE_AUTHOR("Artem Bityutskiy");
 MODULE_LICENSE("GPL");

drivers/mtd/ubi/fastmap.c

Diff comments View file @ 4517547

 /*
  * Copyright (c) 2012 Linutronix GmbH
  * Author: Richard Weinberger <richard@nod.at>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; version 2.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
  * the GNU General Public License for more details.
  *
  */
 #include <linux/crc32.h>
 #include "ubi.h"
 /**
  * ubi_calc_fm_size - calculates the fastmap size in bytes for an UBI device.
  * @ubi: UBI device description object
  */
 size_t ubi_calc_fm_size(struct ubi_device *ubi)
 {
 	size_t size;
 	size = sizeof(struct ubi_fm_hdr) + \
 		sizeof(struct ubi_fm_scan_pool) + \
 		sizeof(struct ubi_fm_scan_pool) + \
 		(ubi->peb_count * sizeof(struct ubi_fm_ec)) + \
 		(sizeof(struct ubi_fm_eba) + \
 		(ubi->peb_count * sizeof(__be32))) + \
 		sizeof(struct ubi_fm_volhdr) * UBI_MAX_VOLUMES;
 	return roundup(size, ubi->leb_size);
 }
 /**
  * new_fm_vhdr - allocate a new volume header for fastmap usage.
  * @ubi: UBI device description object
  * @vol_id: the VID of the new header
  *
  * Returns a new struct ubi_vid_hdr on success.
  * NULL indicates out of memory.
  */
 static struct ubi_vid_hdr *new_fm_vhdr(struct ubi_device *ubi, int vol_id)
 {
 	struct ubi_vid_hdr *new;
 	new = ubi_zalloc_vid_hdr(ubi, GFP_KERNEL);
 	if (!new)
 		goto out;
 	new->vol_type = UBI_VID_DYNAMIC;
 	new->vol_id = cpu_to_be32(vol_id);
 	/* UBI implementations without fastmap support have to delete the
 	 * fastmap.
 	 */
 	new->compat = UBI_COMPAT_DELETE;
 out:
 	return new;
 }
 /**
  * add_aeb - create and add a attach erase block to a given list.
  * @ai: UBI attach info object
  * @list: the target list
  * @pnum: PEB number of the new attach erase block
  * @ec: erease counter of the new LEB
  * @scrub: scrub this PEB after attaching
  *
  * Returns 0 on success, < 0 indicates an internal error.
  */
 static int add_aeb(struct ubi_attach_info *ai, struct list_head *list,
 		   int pnum, int ec, int scrub)
 {
 	struct ubi_ainf_peb *aeb;
 	aeb = kmem_cache_alloc(ai->aeb_slab_cache, GFP_KERNEL);
 	if (!aeb)
 		return -ENOMEM;
 	aeb->pnum = pnum;
 	aeb->ec = ec;
 	aeb->lnum = -1;
 	aeb->scrub = scrub;
 	aeb->copy_flag = aeb->sqnum = 0;
 	ai->ec_sum += aeb->ec;
 	ai->ec_count++;
 	if (ai->max_ec < aeb->ec)
 		ai->max_ec = aeb->ec;
 	if (ai->min_ec > aeb->ec)
 		ai->min_ec = aeb->ec;
 	list_add_tail(&aeb->u.list, list);
 	return 0;
 }
 /**
  * add_vol - create and add a new volume to ubi_attach_info.
  * @ai: ubi_attach_info object
  * @vol_id: VID of the new volume
  * @used_ebs: number of used EBS
  * @data_pad: data padding value of the new volume
  * @vol_type: volume type
  * @last_eb_bytes: number of bytes in the last LEB
  *
  * Returns the new struct ubi_ainf_volume on success.
  * NULL indicates an error.
  */
 static struct ubi_ainf_volume *add_vol(struct ubi_attach_info *ai, int vol_id,
 				       int used_ebs, int data_pad, u8 vol_type,
 				       int last_eb_bytes)
 {
 	struct ubi_ainf_volume *av;
 	struct rb_node **p = &ai->volumes.rb_node, *parent = NULL;
 	while (*p) {
 		parent = *p;
 		av = rb_entry(parent, struct ubi_ainf_volume, rb);
 		if (vol_id > av->vol_id)
 			p = &(*p)->rb_left;
 		else if (vol_id > av->vol_id)
 			p = &(*p)->rb_right;
 	}
 	av = kmalloc(sizeof(struct ubi_ainf_volume), GFP_KERNEL);
 	if (!av)
 		goto out;
 	av->highest_lnum = av->leb_count = 0;
 	av->vol_id = vol_id;
 	av->used_ebs = used_ebs;
 	av->data_pad = data_pad;
 	av->last_data_size = last_eb_bytes;
 	av->compat = 0;
 	av->vol_type = vol_type;
 	av->root = RB_ROOT;
 	dbg_bld("found volume (ID %i)", vol_id);
 	rb_link_node(&av->rb, parent, p);
 	rb_insert_color(&av->rb, &ai->volumes);
 out:
 	return av;
 }
 /**
  * assign_aeb_to_av - assigns a SEB to a given ainf_volume and removes it
  * from it's original list.
  * @ai: ubi_attach_info object
  * @aeb: the to be assigned SEB
  * @av: target scan volume
  */
 static void assign_aeb_to_av(struct ubi_attach_info *ai,
 			     struct ubi_ainf_peb *aeb,
 			     struct ubi_ainf_volume *av)
 {
 	struct ubi_ainf_peb *tmp_aeb;
 	struct rb_node **p = &ai->volumes.rb_node, *parent = NULL;
 	p = &av->root.rb_node;
 	while (*p) {
 		parent = *p;
 		tmp_aeb = rb_entry(parent, struct ubi_ainf_peb, u.rb);
 		if (aeb->lnum != tmp_aeb->lnum) {
 			if (aeb->lnum < tmp_aeb->lnum)
 				p = &(*p)->rb_left;
 			else
 				p = &(*p)->rb_right;
 			continue;
 		} else
 			break;
 	}
 	list_del(&aeb->u.list);
 	av->leb_count++;
 	rb_link_node(&aeb->u.rb, parent, p);
 	rb_insert_color(&aeb->u.rb, &av->root);
 }
 /**
  * update_vol - inserts or updates a LEB which was found a pool.
  * @ubi: the UBI device object
  * @ai: attach info object
  * @av: the volume this LEB belongs to
  * @new_vh: the volume header derived from new_aeb
  * @new_aeb: the AEB to be examined
  *
  * Returns 0 on success, < 0 indicates an internal error.
  */
 static int update_vol(struct ubi_device *ubi, struct ubi_attach_info *ai,
 		      struct ubi_ainf_volume *av, struct ubi_vid_hdr *new_vh,
 		      struct ubi_ainf_peb *new_aeb)
 {
 	struct rb_node **p = &av->root.rb_node, *parent = NULL;
 	struct ubi_ainf_peb *aeb, *victim;
 	int cmp_res;
 	while (*p) {
 		parent = *p;
 		aeb = rb_entry(parent, struct ubi_ainf_peb, u.rb);
 		if (be32_to_cpu(new_vh->lnum) != aeb->lnum) {
 			if (be32_to_cpu(new_vh->lnum) < aeb->lnum)
 				p = &(*p)->rb_left;
 			else
 				p = &(*p)->rb_right;
 			continue;
 		}
 		/* This case can happen if the fastmap gets written
 		 * because of a volume change (creation, deletion, ..).
 		 * Then a PEB can be within the persistent EBA and the pool.
 		 */
 		if (aeb->pnum == new_aeb->pnum) {
 			ubi_assert(aeb->lnum == new_aeb->lnum);
 			kmem_cache_free(ai->aeb_slab_cache, new_aeb);
 			return 0;
 		}
 		cmp_res = ubi_compare_lebs(ubi, aeb, new_aeb->pnum, new_vh);
 		if (cmp_res < 0)
 			return cmp_res;
 		/* new_aeb is newer */
 		if (cmp_res & 1) {
 			victim = kmem_cache_alloc(ai->aeb_slab_cache,
 				GFP_KERNEL);
 			if (!victim)
 				return -ENOMEM;
 			victim->ec = aeb->ec;
 			victim->pnum = aeb->pnum;
 			list_add_tail(&victim->u.list, &ai->erase);
 			if (av->highest_lnum == be32_to_cpu(new_vh->lnum))
 				av->last_data_size = \
 					be32_to_cpu(new_vh->data_size);
 			dbg_bld("vol %i: AEB %i's PEB %i is the newer",
 				av->vol_id, aeb->lnum, new_aeb->pnum);
 			aeb->ec = new_aeb->ec;
 			aeb->pnum = new_aeb->pnum;
 			aeb->copy_flag = new_vh->copy_flag;
 			aeb->scrub = new_aeb->scrub;
 			kmem_cache_free(ai->aeb_slab_cache, new_aeb);
 		/* new_aeb is older */
 		} else {
 			dbg_bld("vol %i: AEB %i's PEB %i is old, dropping it",
 				av->vol_id, aeb->lnum, new_aeb->pnum);
 			list_add_tail(&new_aeb->u.list, &ai->erase);
 		}
 		return 0;
 	}
 	/* This LEB is new, let's add it to the volume */
 	if (av->highest_lnum <= be32_to_cpu(new_vh->lnum)) {
 		av->highest_lnum = be32_to_cpu(new_vh->lnum);
 		av->last_data_size = be32_to_cpu(new_vh->data_size);
 	}
 	if (av->vol_type == UBI_STATIC_VOLUME)
 		av->used_ebs = be32_to_cpu(new_vh->used_ebs);
 	av->leb_count++;
 	rb_link_node(&new_aeb->u.rb, parent, p);
 	rb_insert_color(&new_aeb->u.rb, &av->root);
 	return 0;
 }
 /**
  * process_pool_aeb - we found a non-empty PEB in a pool.
  * @ubi: UBI device object
  * @ai: attach info object
  * @new_vh: the volume header derived from new_aeb
  * @new_aeb: the AEB to be examined
  *
  * Returns 0 on success, < 0 indicates an internal error.
  */
 static int process_pool_aeb(struct ubi_device *ubi, struct ubi_attach_info *ai,
 			    struct ubi_vid_hdr *new_vh,
 			    struct ubi_ainf_peb *new_aeb)
 {
 	struct ubi_ainf_volume *av, *tmp_av = NULL;
 	struct rb_node **p = &ai->volumes.rb_node, *parent = NULL;
 	int found = 0;
 	if (be32_to_cpu(new_vh->vol_id) == UBI_FM_SB_VOLUME_ID ||
 		be32_to_cpu(new_vh->vol_id) == UBI_FM_DATA_VOLUME_ID) {
 		kmem_cache_free(ai->aeb_slab_cache, new_aeb);
 		return 0;
 	}
 	/* Find the volume this SEB belongs to */
 	while (*p) {
 		parent = *p;
 		tmp_av = rb_entry(parent, struct ubi_ainf_volume, rb);
 		if (be32_to_cpu(new_vh->vol_id) > tmp_av->vol_id)
 			p = &(*p)->rb_left;
 		else if (be32_to_cpu(new_vh->vol_id) < tmp_av->vol_id)
 			p = &(*p)->rb_right;
 		else {
 			found = 1;
 			break;
 		}
 	}
 	if (found)
 		av = tmp_av;
 	else {
 		ubi_err("orphaned volume in fastmap pool!");
 		return UBI_BAD_FASTMAP;
 	}
 	ubi_assert(be32_to_cpu(new_vh->vol_id) == av->vol_id);
 	return update_vol(ubi, ai, av, new_vh, new_aeb);
 }
 /**
  * unmap_peb - unmap a PEB.
  * If fastmap detects a free PEB in the pool it has to check whether
  * this PEB has been unmapped after writing the fastmap.
  *
  * @ai: UBI attach info object
  * @pnum: The PEB to be unmapped
  */
 static void unmap_peb(struct ubi_attach_info *ai, int pnum)
 {
 	struct ubi_ainf_volume *av;
 	struct rb_node *node, *node2;
 	struct ubi_ainf_peb *aeb;
 	for (node = rb_first(&ai->volumes); node; node = rb_next(node)) {
 		av = rb_entry(node, struct ubi_ainf_volume, rb);
 		for (node2 = rb_first(&av->root); node2;
 		     node2 = rb_next(node2)) {
 			aeb = rb_entry(node2, struct ubi_ainf_peb, u.rb);
 			if (aeb->pnum == pnum) {
 				rb_erase(&aeb->u.rb, &av->root);
 				kmem_cache_free(ai->aeb_slab_cache, aeb);
 				return;
 			}
 		}
 	}
 }
 /**
  * scan_pool - scans a pool for changed (no longer empty PEBs).
  * @ubi: UBI device object
  * @ai: attach info object
  * @pebs: an array of all PEB numbers in the to be scanned pool
  * @pool_size: size of the pool (number of entries in @pebs)
  * @max_sqnum: pointer to the maximal sequence number
  * @eba_orphans: list of PEBs which need to be scanned
  * @free: list of PEBs which are most likely free (and go into @ai->free)
  *
  * Returns 0 on success, if the pool is unusable UBI_BAD_FASTMAP is returned.
  * < 0 indicates an internal error.
  */
 static int scan_pool(struct ubi_device *ubi, struct ubi_attach_info *ai,
 		     int *pebs, int pool_size, unsigned long long *max_sqnum,
 		     struct list_head *eba_orphans, struct list_head *free)
 {
 	struct ubi_vid_hdr *vh;
 	struct ubi_ec_hdr *ech;
 	struct ubi_ainf_peb *new_aeb, *tmp_aeb;
 	int i, pnum, err, found_orphan, ret = 0;
 	ech = kzalloc(ubi->ec_hdr_alsize, GFP_KERNEL);
 	if (!ech)
 		return -ENOMEM;
 	vh = ubi_zalloc_vid_hdr(ubi, GFP_KERNEL);
 	if (!vh) {
 		kfree(ech);
 		return -ENOMEM;
 	}
 	dbg_bld("scanning fastmap pool: size = %i", pool_size);
 	/*
 	 * Now scan all PEBs in the pool to find changes which have been made
 	 * after the creation of the fastmap
 	 */
 	for (i = 0; i < pool_size; i++) {
 		int scrub = 0;
 		pnum = be32_to_cpu(pebs[i]);
 		if (ubi_io_is_bad(ubi, pnum)) {
 			ubi_err("bad PEB in fastmap pool!");
 			ret = UBI_BAD_FASTMAP;
 			goto out;
 		}
 		err = ubi_io_read_ec_hdr(ubi, pnum, ech, 0);
 		if (err && err != UBI_IO_BITFLIPS) {
 			ubi_err("unable to read EC header! PEB:%i err:%i",
 				pnum, err);
 			ret = err > 0 ? UBI_BAD_FASTMAP : err;
 			goto out;
 		} else if (ret == UBI_IO_BITFLIPS)
 			scrub = 1;
 		if (be32_to_cpu(ech->image_seq) != ubi->image_seq) {
 			ubi_err("bad image seq: 0x%x, expected: 0x%x",
 				be32_to_cpu(ech->image_seq), ubi->image_seq);
 			err = UBI_BAD_FASTMAP;
 			goto out;
 		}
 		err = ubi_io_read_vid_hdr(ubi, pnum, vh, 0);
 		if (err == UBI_IO_FF || err == UBI_IO_FF_BITFLIPS) {
 			unsigned long long ec = be64_to_cpu(ech->ec);
 			unmap_peb(ai, pnum);
 			dbg_bld("Adding PEB to free: %i", pnum);
 			if (err == UBI_IO_FF_BITFLIPS)
 				add_aeb(ai, free, pnum, ec, 1);
 			else
 				add_aeb(ai, free, pnum, ec, 0);
 			continue;
 		} else if (err == 0 || err == UBI_IO_BITFLIPS) {
 			dbg_bld("Found non empty PEB:%i in pool", pnum);
 			if (err == UBI_IO_BITFLIPS)
 				scrub = 1;
 			found_orphan = 0;
 			list_for_each_entry(tmp_aeb, eba_orphans, u.list) {
 				if (tmp_aeb->pnum == pnum) {
 					found_orphan = 1;
 					break;
 				}
 			}
 			if (found_orphan) {
 				kmem_cache_free(ai->aeb_slab_cache, tmp_aeb);
 				list_del(&tmp_aeb->u.list);
 			}
 			new_aeb = kmem_cache_alloc(ai->aeb_slab_cache,
 						   GFP_KERNEL);
 			if (!new_aeb) {
 				ret = -ENOMEM;
 				goto out;
 			}
 			new_aeb->ec = be64_to_cpu(ech->ec);
 			new_aeb->pnum = pnum;
 			new_aeb->lnum = be32_to_cpu(vh->lnum);
 			new_aeb->sqnum = be64_to_cpu(vh->sqnum);
 			new_aeb->copy_flag = vh->copy_flag;
 			new_aeb->scrub = scrub;
 			if (*max_sqnum < new_aeb->sqnum)
 				*max_sqnum = new_aeb->sqnum;
 			err = process_pool_aeb(ubi, ai, vh, new_aeb);
 			if (err) {
 				ret = err > 0 ? UBI_BAD_FASTMAP : err;
 				goto out;
 			}
 		} else {
 			/* We are paranoid and fall back to scanning mode */
 			ubi_err("fastmap pool PEBs contains damaged PEBs!");
 			ret = err > 0 ? UBI_BAD_FASTMAP : err;
 			goto out;
 		}
 	}
 out:
 	ubi_free_vid_hdr(ubi, vh);
 	kfree(ech);
 	return ret;
 }
 /**
  * count_fastmap_pebs - Counts the PEBs found by fastmap.
  * @ai: The UBI attach info object
  */
 static int count_fastmap_pebs(struct ubi_attach_info *ai)
 {
 	struct ubi_ainf_peb *aeb;
 	struct ubi_ainf_volume *av;
 	struct rb_node *rb1, *rb2;
 	int n = 0;
 	list_for_each_entry(aeb, &ai->erase, u.list)
 		n++;
 	list_for_each_entry(aeb, &ai->free, u.list)
 		n++;
 	 ubi_rb_for_each_entry(rb1, av, &ai->volumes, rb)
 		ubi_rb_for_each_entry(rb2, aeb, &av->root, u.rb)
 			n++;
 	return n;
 }
 /**
  * ubi_attach_fastmap - creates ubi_attach_info from a fastmap.
  * @ubi: UBI device object
  * @ai: UBI attach info object
  * @fm: the fastmap to be attached
  *
  * Returns 0 on success, UBI_BAD_FASTMAP if the found fastmap was unusable.
  * < 0 indicates an internal error.
  */
 static int ubi_attach_fastmap(struct ubi_device *ubi,
 			      struct ubi_attach_info *ai,
 			      struct ubi_fastmap_layout *fm)
 {
 	struct list_head used, eba_orphans, free;
 	struct ubi_ainf_volume *av;
 	struct ubi_ainf_peb *aeb, *tmp_aeb, *_tmp_aeb;
 	struct ubi_ec_hdr *ech;
 	struct ubi_fm_sb *fmsb;
 	struct ubi_fm_hdr *fmhdr;
 	struct ubi_fm_scan_pool *fmpl1, *fmpl2;
 	struct ubi_fm_ec *fmec;
 	struct ubi_fm_volhdr *fmvhdr;
 	struct ubi_fm_eba *fm_eba;
 	int ret, i, j, pool_size, wl_pool_size;
 	size_t fm_pos = 0, fm_size = ubi->fm_size;
 	unsigned long long max_sqnum = 0;
 	void *fm_raw = ubi->fm_buf;
 	INIT_LIST_HEAD(&used);
 	INIT_LIST_HEAD(&free);
 	INIT_LIST_HEAD(&eba_orphans);
 	INIT_LIST_HEAD(&ai->corr);
 	INIT_LIST_HEAD(&ai->free);
 	INIT_LIST_HEAD(&ai->erase);
 	INIT_LIST_HEAD(&ai->alien);
 	ai->volumes = RB_ROOT;
 	ai->min_ec = UBI_MAX_ERASECOUNTER;
 	ai->aeb_slab_cache = kmem_cache_create("ubi_ainf_peb_slab",
 					       sizeof(struct ubi_ainf_peb),
 					       0, 0, NULL);
 	if (!ai->aeb_slab_cache) {
 		ret = -ENOMEM;
 		goto fail;
 	}
 	fmsb = (struct ubi_fm_sb *)(fm_raw);
 	ai->max_sqnum = fmsb->sqnum;
 	fm_pos += sizeof(struct ubi_fm_sb);
 	if (fm_pos >= fm_size)
 		goto fail_bad;
 	fmhdr = (struct ubi_fm_hdr *)(fm_raw + fm_pos);
 	fm_pos += sizeof(*fmhdr);
 	if (fm_pos >= fm_size)
 		goto fail_bad;
 	if (be32_to_cpu(fmhdr->magic) != UBI_FM_HDR_MAGIC) {
 		ubi_err("bad fastmap header magic: 0x%x, expected: 0x%x",
 			be32_to_cpu(fmhdr->magic), UBI_FM_HDR_MAGIC);
 		goto fail_bad;
 	}
 	fmpl1 = (struct ubi_fm_scan_pool *)(fm_raw + fm_pos);
 	fm_pos += sizeof(*fmpl1);
 	if (fm_pos >= fm_size)
 		goto fail_bad;
 	if (be32_to_cpu(fmpl1->magic) != UBI_FM_POOL_MAGIC) {
 		ubi_err("bad fastmap pool magic: 0x%x, expected: 0x%x",
 			be32_to_cpu(fmpl1->magic), UBI_FM_POOL_MAGIC);
 		goto fail_bad;
 	}
 	fmpl2 = (struct ubi_fm_scan_pool *)(fm_raw + fm_pos);
 	fm_pos += sizeof(*fmpl2);
 	if (fm_pos >= fm_size)
 		goto fail_bad;
 	if (be32_to_cpu(fmpl2->magic) != UBI_FM_POOL_MAGIC) {
 		ubi_err("bad fastmap pool magic: 0x%x, expected: 0x%x",
 			be32_to_cpu(fmpl2->magic), UBI_FM_POOL_MAGIC);
 		goto fail_bad;
 	}
 	pool_size = be16_to_cpu(fmpl1->size);
 	wl_pool_size = be16_to_cpu(fmpl2->size);
 	fm->max_pool_size = be16_to_cpu(fmpl1->max_size);
 	fm->max_wl_pool_size = be16_to_cpu(fmpl2->max_size);
 	if (pool_size > UBI_FM_MAX_POOL_SIZE || pool_size < 0) {
 		ubi_err("bad pool size: %i", pool_size);
 		goto fail_bad;
 	}
 	if (wl_pool_size > UBI_FM_MAX_POOL_SIZE || wl_pool_size < 0) {
 		ubi_err("bad WL pool size: %i", wl_pool_size);
 		goto fail_bad;
 	}
 	if (fm->max_pool_size > UBI_FM_MAX_POOL_SIZE ||
 	    fm->max_pool_size < 0) {
 		ubi_err("bad maximal pool size: %i", fm->max_pool_size);
 		goto fail_bad;
 	}
 	if (fm->max_wl_pool_size > UBI_FM_MAX_POOL_SIZE ||
 	    fm->max_wl_pool_size < 0) {
 		ubi_err("bad maximal WL pool size: %i", fm->max_wl_pool_size);
 		goto fail_bad;
 	}
 	/* read EC values from free list */
 	for (i = 0; i < be32_to_cpu(fmhdr->free_peb_count); i++) {
 		fmec = (struct ubi_fm_ec *)(fm_raw + fm_pos);
 		fm_pos += sizeof(*fmec);
 		if (fm_pos >= fm_size)
 			goto fail_bad;
 		add_aeb(ai, &ai->free, be32_to_cpu(fmec->pnum),
 			be32_to_cpu(fmec->ec), 0);
 	}
 	/* read EC values from used list */
 	for (i = 0; i < be32_to_cpu(fmhdr->used_peb_count); i++) {
 		fmec = (struct ubi_fm_ec *)(fm_raw + fm_pos);
 		fm_pos += sizeof(*fmec);
 		if (fm_pos >= fm_size)
 			goto fail_bad;
 		add_aeb(ai, &used, be32_to_cpu(fmec->pnum),
 			be32_to_cpu(fmec->ec), 0);
 	}
 	/* read EC values from scrub list */
 	for (i = 0; i < be32_to_cpu(fmhdr->scrub_peb_count); i++) {
 		fmec = (struct ubi_fm_ec *)(fm_raw + fm_pos);
 		fm_pos += sizeof(*fmec);
 		if (fm_pos >= fm_size)
 			goto fail_bad;
 		add_aeb(ai, &used, be32_to_cpu(fmec->pnum),
 			be32_to_cpu(fmec->ec), 1);
 	}
 	/* read EC values from erase list */
 	for (i = 0; i < be32_to_cpu(fmhdr->erase_peb_count); i++) {
 		fmec = (struct ubi_fm_ec *)(fm_raw + fm_pos);
 		fm_pos += sizeof(*fmec);
 		if (fm_pos >= fm_size)
 			goto fail_bad;
 		add_aeb(ai, &ai->erase, be32_to_cpu(fmec->pnum),
 			be32_to_cpu(fmec->ec), 1);
 	}
 	ai->mean_ec = div_u64(ai->ec_sum, ai->ec_count);
 	ai->bad_peb_count = be32_to_cpu(fmhdr->bad_peb_count);
 	/* Iterate over all volumes and read their EBA table */
 	for (i = 0; i < be32_to_cpu(fmhdr->vol_count); i++) {
 		fmvhdr = (struct ubi_fm_volhdr *)(fm_raw + fm_pos);
 		fm_pos += sizeof(*fmvhdr);
 		if (fm_pos >= fm_size)
 			goto fail_bad;
 		if (be32_to_cpu(fmvhdr->magic) != UBI_FM_VHDR_MAGIC) {
 			ubi_err("bad fastmap vol header magic: 0x%x, " \
 				"expected: 0x%x",
 				be32_to_cpu(fmvhdr->magic), UBI_FM_VHDR_MAGIC);
 			goto fail_bad;
 		}
 		av = add_vol(ai, be32_to_cpu(fmvhdr->vol_id),
 			     be32_to_cpu(fmvhdr->used_ebs),
 			     be32_to_cpu(fmvhdr->data_pad),
 			     fmvhdr->vol_type,
 			     be32_to_cpu(fmvhdr->last_eb_bytes));
 		if (!av)
 			goto fail_bad;
 		ai->vols_found++;
 		if (ai->highest_vol_id < be32_to_cpu(fmvhdr->vol_id))
 			ai->highest_vol_id = be32_to_cpu(fmvhdr->vol_id);
 		fm_eba = (struct ubi_fm_eba *)(fm_raw + fm_pos);
 		fm_pos += sizeof(*fm_eba);
 		fm_pos += (sizeof(__be32) * be32_to_cpu(fm_eba->reserved_pebs));
 		if (fm_pos >= fm_size)
 			goto fail_bad;
 		if (be32_to_cpu(fm_eba->magic) != UBI_FM_EBA_MAGIC) {
 			ubi_err("bad fastmap EBA header magic: 0x%x, " \
 				"expected: 0x%x",
 				be32_to_cpu(fm_eba->magic), UBI_FM_EBA_MAGIC);
 			goto fail_bad;
 		}
 		for (j = 0; j < be32_to_cpu(fm_eba->reserved_pebs); j++) {
 			int pnum = be32_to_cpu(fm_eba->pnum[j]);
 			if ((int)be32_to_cpu(fm_eba->pnum[j]) < 0)
 				continue;
 			aeb = NULL;
 			list_for_each_entry(tmp_aeb, &used, u.list) {
-				if (tmp_aeb->pnum == pnum)
+				if (tmp_aeb->pnum == pnum) {
 					aeb = tmp_aeb;
+					break;
+				}
 			}
 			/* This can happen if a PEB is already in an EBA known
 			 * by this fastmap but the PEB itself is not in the used
 			 * list.
 			 * In this case the PEB can be within the fastmap pool
 			 * or while writing the fastmap it was in the protection
 			 * queue.
 			 */
 			if (!aeb) {
 				aeb = kmem_cache_alloc(ai->aeb_slab_cache,
 						       GFP_KERNEL);
 				if (!aeb) {
 					ret = -ENOMEM;
 					goto fail;
 				}
 				aeb->lnum = j;
 				aeb->pnum = be32_to_cpu(fm_eba->pnum[j]);
 				aeb->ec = -1;
 				aeb->scrub = aeb->copy_flag = aeb->sqnum = 0;
 				list_add_tail(&aeb->u.list, &eba_orphans);
 				continue;
 			}
 			aeb->lnum = j;
 			if (av->highest_lnum <= aeb->lnum)
 				av->highest_lnum = aeb->lnum;
 			assign_aeb_to_av(ai, aeb, av);
 			dbg_bld("inserting PEB:%i (LEB %i) to vol %i",
 				aeb->pnum, aeb->lnum, av->vol_id);
 		}
 		ech = kzalloc(ubi->ec_hdr_alsize, GFP_KERNEL);
 		if (!ech) {
 			ret = -ENOMEM;
 			goto fail;
 		}
 		list_for_each_entry_safe(tmp_aeb, _tmp_aeb, &eba_orphans,
 					 u.list) {
 			int err;
 			if (ubi_io_is_bad(ubi, tmp_aeb->pnum)) {
 				ubi_err("bad PEB in fastmap EBA orphan list");
 				ret = UBI_BAD_FASTMAP;
 				kfree(ech);
 				goto fail;
 			}
 			err = ubi_io_read_ec_hdr(ubi, tmp_aeb->pnum, ech, 0);
 			if (err && err != UBI_IO_BITFLIPS) {
 				ubi_err("unable to read EC header! PEB:%i " \
 					"err:%i", tmp_aeb->pnum, err);
 				ret = err > 0 ? UBI_BAD_FASTMAP : err;
 				kfree(ech);
 				goto fail;
 			} else if (err == UBI_IO_BITFLIPS)
 				tmp_aeb->scrub = 1;
 			tmp_aeb->ec = be64_to_cpu(ech->ec);
 			assign_aeb_to_av(ai, tmp_aeb, av);
 		}
 		kfree(ech);
 	}
 	ret = scan_pool(ubi, ai, fmpl1->pebs, pool_size, &max_sqnum,
 			&eba_orphans, &free);
 	if (ret)
 		goto fail;
 	ret = scan_pool(ubi, ai, fmpl2->pebs, wl_pool_size, &max_sqnum,
 			&eba_orphans, &free);
 	if (ret)
 		goto fail;
 	if (max_sqnum > ai->max_sqnum)
 		ai->max_sqnum = max_sqnum;
 	list_for_each_entry_safe(tmp_aeb, _tmp_aeb, &free, u.list)
 		list_move_tail(&tmp_aeb->u.list, &ai->free);
 	/*
 	 * If fastmap is leaking PEBs (must not happen), raise a
 	 * fat warning and fall back to scanning mode.
 	 * We do this here because in ubi_wl_init() it's too late
 	 * and we cannot fall back to scanning.
 	 */
 	if (WARN_ON(count_fastmap_pebs(ai) != ubi->peb_count -
 		    ai->bad_peb_count - fm->used_blocks))
 		goto fail_bad;
 	return 0;
 fail_bad:
 	ret = UBI_BAD_FASTMAP;
 fail:
 	return ret;
 }
 /**
  * ubi_scan_fastmap - scan the fastmap.
  * @ubi: UBI device object
  * @ai: UBI attach info to be filled
  * @fm_anchor: The fastmap starts at this PEB
  *
  * Returns 0 on success, UBI_NO_FASTMAP if no fastmap was found,
  * UBI_BAD_FASTMAP if one was found but is not usable.
  * < 0 indicates an internal error.
  */
 int ubi_scan_fastmap(struct ubi_device *ubi, struct ubi_attach_info *ai,
 		     int fm_anchor)
 {
 	struct ubi_fm_sb *fmsb, *fmsb2;
 	struct ubi_vid_hdr *vh;
 	struct ubi_ec_hdr *ech;
 	struct ubi_fastmap_layout *fm;
 	int i, used_blocks, pnum, ret = 0;
 	size_t fm_size;
 	__be32 crc, tmp_crc;
 	unsigned long long sqnum = 0;
 	mutex_lock(&ubi->fm_mutex);
 	memset(ubi->fm_buf, 0, ubi->fm_size);
 	fmsb = kmalloc(sizeof(*fmsb), GFP_KERNEL);
 	if (!fmsb) {
 		ret = -ENOMEM;
 		goto out;
 	}
 	fm = kzalloc(sizeof(*fm), GFP_KERNEL);
 	if (!fm) {
 		ret = -ENOMEM;
 		kfree(fmsb);
 		goto out;
 	}
 	ret = ubi_io_read(ubi, fmsb, fm_anchor, ubi->leb_start, sizeof(*fmsb));
 	if (ret && ret != UBI_IO_BITFLIPS)
 		goto free_fm_sb;
 	else if (ret == UBI_IO_BITFLIPS)
 		fm->to_be_tortured[0] = 1;
 	if (be32_to_cpu(fmsb->magic) != UBI_FM_SB_MAGIC) {
 		ubi_err("bad super block magic: 0x%x, expected: 0x%x",
 			be32_to_cpu(fmsb->magic), UBI_FM_SB_MAGIC);
 		ret = UBI_BAD_FASTMAP;
 		goto free_fm_sb;
 	}
 	if (fmsb->version != UBI_FM_FMT_VERSION) {
 		ubi_err("bad fastmap version: %i, expected: %i",
 			fmsb->version, UBI_FM_FMT_VERSION);
 		ret = UBI_BAD_FASTMAP;
 		goto free_fm_sb;
 	}
 	used_blocks = be32_to_cpu(fmsb->used_blocks);
 	if (used_blocks > UBI_FM_MAX_BLOCKS || used_blocks < 1) {
 		ubi_err("number of fastmap blocks is invalid: %i", used_blocks);
 		ret = UBI_BAD_FASTMAP;
 		goto free_fm_sb;
 	}
 	fm_size = ubi->leb_size * used_blocks;
 	if (fm_size != ubi->fm_size) {
 		ubi_err("bad fastmap size: %zi, expected: %zi", fm_size,
 			ubi->fm_size);
 		ret = UBI_BAD_FASTMAP;
 		goto free_fm_sb;
 	}
 	ech = kzalloc(ubi->ec_hdr_alsize, GFP_KERNEL);
 	if (!ech) {
 		ret = -ENOMEM;
 		goto free_fm_sb;
 	}
 	vh = ubi_zalloc_vid_hdr(ubi, GFP_KERNEL);
 	if (!vh) {
 		ret = -ENOMEM;
 		goto free_hdr;
 	}
 	for (i = 0; i < used_blocks; i++) {
 		pnum = be32_to_cpu(fmsb->block_loc[i]);
 		if (ubi_io_is_bad(ubi, pnum)) {
 			ret = UBI_BAD_FASTMAP;
 			goto free_hdr;
 		}
 		ret = ubi_io_read_ec_hdr(ubi, pnum, ech, 0);
 		if (ret && ret != UBI_IO_BITFLIPS) {
 			ubi_err("unable to read fastmap block# %i EC (PEB: %i)",
 				i, pnum);
 			if (ret > 0)
 				ret = UBI_BAD_FASTMAP;
 			goto free_hdr;
 		} else if (ret == UBI_IO_BITFLIPS)
 			fm->to_be_tortured[i] = 1;
 		if (!ubi->image_seq)
 			ubi->image_seq = be32_to_cpu(ech->image_seq);
 		if (be32_to_cpu(ech->image_seq) != ubi->image_seq) {
 			ret = UBI_BAD_FASTMAP;
 			goto free_hdr;
 		}
 		ret = ubi_io_read_vid_hdr(ubi, pnum, vh, 0);
 		if (ret && ret != UBI_IO_BITFLIPS) {
 			ubi_err("unable to read fastmap block# %i (PEB: %i)",
 				i, pnum);
 			goto free_hdr;
 		}
 		if (i == 0) {
 			if (be32_to_cpu(vh->vol_id) != UBI_FM_SB_VOLUME_ID) {
 				ubi_err("bad fastmap anchor vol_id: 0x%x," \
 					" expected: 0x%x",
 					be32_to_cpu(vh->vol_id),
 					UBI_FM_SB_VOLUME_ID);
 				ret = UBI_BAD_FASTMAP;
 				goto free_hdr;
 			}
 		} else {
 			if (be32_to_cpu(vh->vol_id) != UBI_FM_DATA_VOLUME_ID) {
 				ubi_err("bad fastmap data vol_id: 0x%x," \
 					" expected: 0x%x",
 					be32_to_cpu(vh->vol_id),
 					UBI_FM_DATA_VOLUME_ID);
 				ret = UBI_BAD_FASTMAP;
 				goto free_hdr;
 			}
 		}
 		if (sqnum < be64_to_cpu(vh->sqnum))
 			sqnum = be64_to_cpu(vh->sqnum);
 		ret = ubi_io_read(ubi, ubi->fm_buf + (ubi->leb_size * i), pnum,
 				  ubi->leb_start, ubi->leb_size);
 		if (ret && ret != UBI_IO_BITFLIPS) {
 			ubi_err("unable to read fastmap block# %i (PEB: %i, " \
 				"err: %i)", i, pnum, ret);
 			goto free_hdr;
 		}
 	}
 	kfree(fmsb);
 	fmsb = NULL;
 	fmsb2 = (struct ubi_fm_sb *)(ubi->fm_buf);
 	tmp_crc = be32_to_cpu(fmsb2->data_crc);
 	fmsb2->data_crc = 0;
 	crc = crc32(UBI_CRC32_INIT, ubi->fm_buf, fm_size);
 	if (crc != tmp_crc) {
 		ubi_err("fastmap data CRC is invalid");
 		ubi_err("CRC should be: 0x%x, calc: 0x%x", tmp_crc, crc);
 		ret = UBI_BAD_FASTMAP;
 		goto free_hdr;
 	}
 	fmsb2->sqnum = sqnum;
 	fm->used_blocks = used_blocks;
 	ret = ubi_attach_fastmap(ubi, ai, fm);
 	if (ret) {
 		if (ret > 0)
 			ret = UBI_BAD_FASTMAP;
 		goto free_hdr;
 	}
 	for (i = 0; i < used_blocks; i++) {
 		struct ubi_wl_entry *e;
 		e = kmem_cache_alloc(ubi_wl_entry_slab, GFP_KERNEL);
 		if (!e) {
 			while (i--)
 				kfree(fm->e[i]);
 			ret = -ENOMEM;
 			goto free_hdr;
 		}
 		e->pnum = be32_to_cpu(fmsb2->block_loc[i]);
 		e->ec = be32_to_cpu(fmsb2->block_ec[i]);
 		fm->e[i] = e;
 	}
 	ubi->fm = fm;
 	ubi->fm_pool.max_size = ubi->fm->max_pool_size;
 	ubi->fm_wl_pool.max_size = ubi->fm->max_wl_pool_size;
 	ubi_msg("attached by fastmap");
 	ubi_msg("fastmap pool size: %d", ubi->fm_pool.max_size);
 	ubi_msg("fastmap WL pool size: %d", ubi->fm_wl_pool.max_size);
 	ubi->fm_disabled = 0;
 	ubi_free_vid_hdr(ubi, vh);
 	kfree(ech);
 out:
 	mutex_unlock(&ubi->fm_mutex);
 	if (ret == UBI_BAD_FASTMAP)
 		ubi_err("Attach by fastmap failed, doing a full scan!");
 	return ret;
 free_hdr:
 	ubi_free_vid_hdr(ubi, vh);
 	kfree(ech);
 free_fm_sb:
 	kfree(fmsb);
 	kfree(fm);
 	goto out;
 }
 /**
  * ubi_write_fastmap - writes a fastmap.
  * @ubi: UBI device object
  * @new_fm: the to be written fastmap
  *
  * Returns 0 on success, < 0 indicates an internal error.
  */
 static int ubi_write_fastmap(struct ubi_device *ubi,
 			     struct ubi_fastmap_layout *new_fm)
 {
 	size_t fm_pos = 0;
 	void *fm_raw;
 	struct ubi_fm_sb *fmsb;
 	struct ubi_fm_hdr *fmh;
 	struct ubi_fm_scan_pool *fmpl1, *fmpl2;
 	struct ubi_fm_ec *fec;
 	struct ubi_fm_volhdr *fvh;
 	struct ubi_fm_eba *feba;
 	struct rb_node *node;
 	struct ubi_wl_entry *wl_e;
 	struct ubi_volume *vol;
 	struct ubi_vid_hdr *avhdr, *dvhdr;
 	struct ubi_work *ubi_wrk;
 	int ret, i, j, free_peb_count, used_peb_count, vol_count;
 	int scrub_peb_count, erase_peb_count;
 	fm_raw = ubi->fm_buf;
 	memset(ubi->fm_buf, 0, ubi->fm_size);
 	avhdr = new_fm_vhdr(ubi, UBI_FM_SB_VOLUME_ID);
 	if (!avhdr) {
 		ret = -ENOMEM;
 		goto out;
 	}
 	dvhdr = new_fm_vhdr(ubi, UBI_FM_DATA_VOLUME_ID);
 	if (!dvhdr) {
 		ret = -ENOMEM;
 		goto out_kfree;
 	}
 	spin_lock(&ubi->volumes_lock);
 	spin_lock(&ubi->wl_lock);
 	fmsb = (struct ubi_fm_sb *)fm_raw;
 	fm_pos += sizeof(*fmsb);
 	ubi_assert(fm_pos <= ubi->fm_size);
 	fmh = (struct ubi_fm_hdr *)(fm_raw + fm_pos);
 	fm_pos += sizeof(*fmh);
 	ubi_assert(fm_pos <= ubi->fm_size);
 	fmsb->magic = cpu_to_be32(UBI_FM_SB_MAGIC);
 	fmsb->version = UBI_FM_FMT_VERSION;
 	fmsb->used_blocks = cpu_to_be32(new_fm->used_blocks);
 	/* the max sqnum will be filled in while *reading* the fastmap */
 	fmsb->sqnum = 0;
 	fmh->magic = cpu_to_be32(UBI_FM_HDR_MAGIC);
 	free_peb_count = 0;
 	used_peb_count = 0;
 	scrub_peb_count = 0;
 	erase_peb_count = 0;
 	vol_count = 0;
 	fmpl1 = (struct ubi_fm_scan_pool *)(fm_raw + fm_pos);
 	fm_pos += sizeof(*fmpl1);
 	fmpl1->magic = cpu_to_be32(UBI_FM_POOL_MAGIC);
 	fmpl1->size = cpu_to_be16(ubi->fm_pool.size);
 	fmpl1->max_size = cpu_to_be16(ubi->fm_pool.max_size);
 	for (i = 0; i < ubi->fm_pool.size; i++)
 		fmpl1->pebs[i] = cpu_to_be32(ubi->fm_pool.pebs[i]);
 	fmpl2 = (struct ubi_fm_scan_pool *)(fm_raw + fm_pos);
 	fm_pos += sizeof(*fmpl2);
 	fmpl2->magic = cpu_to_be32(UBI_FM_POOL_MAGIC);
 	fmpl2->size = cpu_to_be16(ubi->fm_wl_pool.size);
 	fmpl2->max_size = cpu_to_be16(ubi->fm_wl_pool.max_size);
 	for (i = 0; i < ubi->fm_wl_pool.size; i++)
 		fmpl2->pebs[i] = cpu_to_be32(ubi->fm_wl_pool.pebs[i]);
 	for (node = rb_first(&ubi->free); node; node = rb_next(node)) {
 		wl_e = rb_entry(node, struct ubi_wl_entry, u.rb);
 		fec = (struct ubi_fm_ec *)(fm_raw + fm_pos);
 		fec->pnum = cpu_to_be32(wl_e->pnum);
 		fec->ec = cpu_to_be32(wl_e->ec);
 		free_peb_count++;
 		fm_pos += sizeof(*fec);
 		ubi_assert(fm_pos <= ubi->fm_size);
 	}
 	fmh->free_peb_count = cpu_to_be32(free_peb_count);
 	for (node = rb_first(&ubi->used); node; node = rb_next(node)) {
 		wl_e = rb_entry(node, struct ubi_wl_entry, u.rb);
 		fec = (struct ubi_fm_ec *)(fm_raw + fm_pos);
 		fec->pnum = cpu_to_be32(wl_e->pnum);
 		fec->ec = cpu_to_be32(wl_e->ec);
 		used_peb_count++;
 		fm_pos += sizeof(*fec);
 		ubi_assert(fm_pos <= ubi->fm_size);
 	}
 	fmh->used_peb_count = cpu_to_be32(used_peb_count);
 	for (node = rb_first(&ubi->scrub); node; node = rb_next(node)) {
 		wl_e = rb_entry(node, struct ubi_wl_entry, u.rb);
 		fec = (struct ubi_fm_ec *)(fm_raw + fm_pos);
 		fec->pnum = cpu_to_be32(wl_e->pnum);
 		fec->ec = cpu_to_be32(wl_e->ec);
 		scrub_peb_count++;
 		fm_pos += sizeof(*fec);
 		ubi_assert(fm_pos <= ubi->fm_size);
 	}
 	fmh->scrub_peb_count = cpu_to_be32(scrub_peb_count);
 	list_for_each_entry(ubi_wrk, &ubi->works, list) {
 		if (ubi_is_erase_work(ubi_wrk)) {
 			wl_e = ubi_wrk->e;
 			ubi_assert(wl_e);
 			fec = (struct ubi_fm_ec *)(fm_raw + fm_pos);
 			fec->pnum = cpu_to_be32(wl_e->pnum);
 			fec->ec = cpu_to_be32(wl_e->ec);
 			erase_peb_count++;
 			fm_pos += sizeof(*fec);
 			ubi_assert(fm_pos <= ubi->fm_size);
 		}
 	}
 	fmh->erase_peb_count = cpu_to_be32(erase_peb_count);
 	for (i = 0; i < UBI_MAX_VOLUMES + UBI_INT_VOL_COUNT; i++) {
 		vol = ubi->volumes[i];
 		if (!vol)
 			continue;
 		vol_count++;
 		fvh = (struct ubi_fm_volhdr *)(fm_raw + fm_pos);
 		fm_pos += sizeof(*fvh);
 		ubi_assert(fm_pos <= ubi->fm_size);
 		fvh->magic = cpu_to_be32(UBI_FM_VHDR_MAGIC);
 		fvh->vol_id = cpu_to_be32(vol->vol_id);
 		fvh->vol_type = vol->vol_type;
 		fvh->used_ebs = cpu_to_be32(vol->used_ebs);
 		fvh->data_pad = cpu_to_be32(vol->data_pad);
 		fvh->last_eb_bytes = cpu_to_be32(vol->last_eb_bytes);
 		ubi_assert(vol->vol_type == UBI_DYNAMIC_VOLUME ||
 			vol->vol_type == UBI_STATIC_VOLUME);
 		feba = (struct ubi_fm_eba *)(fm_raw + fm_pos);
 		fm_pos += sizeof(*feba) + (sizeof(__be32) * vol->reserved_pebs);
 		ubi_assert(fm_pos <= ubi->fm_size);
 		for (j = 0; j < vol->reserved_pebs; j++)
 			feba->pnum[j] = cpu_to_be32(vol->eba_tbl[j]);
 		feba->reserved_pebs = cpu_to_be32(j);
 		feba->magic = cpu_to_be32(UBI_FM_EBA_MAGIC);
 	}
 	fmh->vol_count = cpu_to_be32(vol_count);
 	fmh->bad_peb_count = cpu_to_be32(ubi->bad_peb_count);
 	avhdr->sqnum = cpu_to_be64(ubi_next_sqnum(ubi));
 	avhdr->lnum = 0;
 	spin_unlock(&ubi->wl_lock);
 	spin_unlock(&ubi->volumes_lock);
 	dbg_bld("writing fastmap SB to PEB %i", new_fm->e[0]->pnum);
 	ret = ubi_io_write_vid_hdr(ubi, new_fm->e[0]->pnum, avhdr);
 	if (ret) {
 		ubi_err("unable to write vid_hdr to fastmap SB!");
 		goto out_kfree;
 	}
 	for (i = 0; i < new_fm->used_blocks; i++) {
 		fmsb->block_loc[i] = cpu_to_be32(new_fm->e[i]->pnum);
 		fmsb->block_ec[i] = cpu_to_be32(new_fm->e[i]->ec);
 	}
 	fmsb->data_crc = 0;
 	fmsb->data_crc = cpu_to_be32(crc32(UBI_CRC32_INIT, fm_raw,
 					   ubi->fm_size));
 	for (i = 1; i < new_fm->used_blocks; i++) {
 		dvhdr->sqnum = cpu_to_be64(ubi_next_sqnum(ubi));
 		dvhdr->lnum = cpu_to_be32(i);
 		dbg_bld("writing fastmap data to PEB %i sqnum %llu",
 			new_fm->e[i]->pnum, be64_to_cpu(dvhdr->sqnum));
 		ret = ubi_io_write_vid_hdr(ubi, new_fm->e[i]->pnum, dvhdr);
 		if (ret) {
 			ubi_err("unable to write vid_hdr to PEB %i!",
 				new_fm->e[i]->pnum);
 			goto out_kfree;
 		}
 	}
 	for (i = 0; i < new_fm->used_blocks; i++) {
 		ret = ubi_io_write(ubi, fm_raw + (i * ubi->leb_size),
 			new_fm->e[i]->pnum, ubi->leb_start, ubi->leb_size);
 		if (ret) {
 			ubi_err("unable to write fastmap to PEB %i!",
 				new_fm->e[i]->pnum);
 			goto out_kfree;
 		}
 	}
 	ubi_assert(new_fm);
 	ubi->fm = new_fm;
 	dbg_bld("fastmap written!");
 out_kfree:
 	ubi_free_vid_hdr(ubi, avhdr);
 	ubi_free_vid_hdr(ubi, dvhdr);
 out:
 	return ret;
 }
 /**
  * erase_block - Manually erase a PEB.
  * @ubi: UBI device object
  * @pnum: PEB to be erased
  *
  * Returns the new EC value on success, < 0 indicates an internal error.
  */
 static int erase_block(struct ubi_device *ubi, int pnum)
 {
 	int ret;
 	struct ubi_ec_hdr *ec_hdr;
 	long long ec;
 	ec_hdr = kzalloc(ubi->ec_hdr_alsize, GFP_KERNEL);
 	if (!ec_hdr)
 		return -ENOMEM;
 	ret = ubi_io_read_ec_hdr(ubi, pnum, ec_hdr, 0);
 	if (ret < 0)
 		goto out;
 	else if (ret && ret != UBI_IO_BITFLIPS) {
 		ret = -EINVAL;
 		goto out;
 	}
 	ret = ubi_io_sync_erase(ubi, pnum, 0);
 	if (ret < 0)
 		goto out;
 	ec = be64_to_cpu(ec_hdr->ec);
 	ec += ret;
 	if (ec > UBI_MAX_ERASECOUNTER) {
 		ret = -EINVAL;
 		goto out;
 	}
 	ec_hdr->ec = cpu_to_be64(ec);
 	ret = ubi_io_write_ec_hdr(ubi, pnum, ec_hdr);
 	if (ret < 0)
 		goto out;
 	ret = ec;
 out:
 	kfree(ec_hdr);
 	return ret;
 }
 /**
  * invalidate_fastmap - destroys a fastmap.
  * @ubi: UBI device object
  * @fm: the fastmap to be destroyed
  *
  * Returns 0 on success, < 0 indicates an internal error.
  */
 static int invalidate_fastmap(struct ubi_device *ubi,
 			      struct ubi_fastmap_layout *fm)
 {
 	int ret, i;
 	struct ubi_vid_hdr *vh;
 	ret = erase_block(ubi, fm->e[0]->pnum);
 	if (ret < 0)
 		return ret;
 	vh = new_fm_vhdr(ubi, UBI_FM_SB_VOLUME_ID);
 	if (!vh)
 		return -ENOMEM;
 	/* deleting the current fastmap SB is not enough, an old SB may exist,
 	 * so create a (corrupted) SB such that fastmap will find it and fall
 	 * back to scanning mode in any case */
 	vh->sqnum = cpu_to_be64(ubi_next_sqnum(ubi));
 	ret = ubi_io_write_vid_hdr(ubi, fm->e[0]->pnum, vh);
 	for (i = 0; i < fm->used_blocks; i++)
 		ubi_wl_put_fm_peb(ubi, fm->e[i], i, fm->to_be_tortured[i]);
 	return ret;
 }
 /**
  * ubi_update_fastmap - will be called by UBI if a volume changes or
  * a fastmap pool becomes full.
  * @ubi: UBI device object
  *
  * Returns 0 on success, < 0 indicates an internal error.
  */
 int ubi_update_fastmap(struct ubi_device *ubi)
 {
 	int ret, i;
 	struct ubi_fastmap_layout *new_fm, *old_fm;
 	struct ubi_wl_entry *tmp_e;
 	mutex_lock(&ubi->fm_mutex);
 	ubi_refill_pools(ubi);
 	if (ubi->ro_mode || ubi->fm_disabled) {
 		mutex_unlock(&ubi->fm_mutex);
 		return 0;
 	}
 	ret = ubi_ensure_anchor_pebs(ubi);
 	if (ret) {
 		mutex_unlock(&ubi->fm_mutex);
 		return ret;
 	}
 	new_fm = kzalloc(sizeof(*new_fm), GFP_KERNEL);
 	if (!new_fm) {
 		mutex_unlock(&ubi->fm_mutex);
 		return -ENOMEM;
 	}
 	new_fm->used_blocks = ubi->fm_size / ubi->leb_size;
 	for (i = 0; i < new_fm->used_blocks; i++) {
 		new_fm->e[i] = kmem_cache_alloc(ubi_wl_entry_slab, GFP_KERNEL);
 		if (!new_fm->e[i]) {
 			while (i--)
 				kfree(new_fm->e[i]);
 			kfree(new_fm);
 			mutex_unlock(&ubi->fm_mutex);
 			return -ENOMEM;
 		}
 	}
 	old_fm = ubi->fm;
 	ubi->fm = NULL;
 	if (new_fm->used_blocks > UBI_FM_MAX_BLOCKS) {
 		ubi_err("fastmap too large");
 		ret = -ENOSPC;
 		goto err;
 	}
 	for (i = 1; i < new_fm->used_blocks; i++) {
 		spin_lock(&ubi->wl_lock);
 		tmp_e = ubi_wl_get_fm_peb(ubi, 0);
 		spin_unlock(&ubi->wl_lock);
 		if (!tmp_e && !old_fm) {
 			int j;
 			ubi_err("could not get any free erase block");
 			for (j = 1; j < i; j++)
 				ubi_wl_put_fm_peb(ubi, new_fm->e[j], j, 0);
 			ret = -ENOSPC;
 			goto err;
 		} else if (!tmp_e && old_fm) {
 			ret = erase_block(ubi, old_fm->e[i]->pnum);
 			if (ret < 0) {
 				int j;
 				for (j = 1; j < i; j++)
 					ubi_wl_put_fm_peb(ubi, new_fm->e[j],
 							  j, 0);
 				ubi_err("could not erase old fastmap PEB");
 				goto err;
 			}
 			new_fm->e[i]->pnum = old_fm->e[i]->pnum;
 			new_fm->e[i]->ec = old_fm->e[i]->ec;
 		} else {
 			new_fm->e[i]->pnum = tmp_e->pnum;
 			new_fm->e[i]->ec = tmp_e->ec;
 			if (old_fm)
 				ubi_wl_put_fm_peb(ubi, old_fm->e[i], i,
 						  old_fm->to_be_tortured[i]);
 		}
 	}
 	spin_lock(&ubi->wl_lock);
 	tmp_e = ubi_wl_get_fm_peb(ubi, 1);
 	spin_unlock(&ubi->wl_lock);
 	if (old_fm) {
 		/* no fresh anchor PEB was found, reuse the old one */
 		if (!tmp_e) {
 			ret = erase_block(ubi, old_fm->e[0]->pnum);
 			if (ret < 0) {
 				int i;
 				ubi_err("could not erase old anchor PEB");
 				for (i = 1; i < new_fm->used_blocks; i++)
 					ubi_wl_put_fm_peb(ubi, new_fm->e[i],
 							  i, 0);
 				goto err;
 			}
 			new_fm->e[0]->pnum = old_fm->e[0]->pnum;
 			new_fm->e[0]->ec = ret;
 		} else {
 			/* we've got a new anchor PEB, return the old one */
 			ubi_wl_put_fm_peb(ubi, old_fm->e[0], 0,
 					  old_fm->to_be_tortured[0]);
 			new_fm->e[0]->pnum = tmp_e->pnum;
 			new_fm->e[0]->ec = tmp_e->ec;
 		}
 	} else {
 		if (!tmp_e) {
 			int i;
 			ubi_err("could not find any anchor PEB");
 			for (i = 1; i < new_fm->used_blocks; i++)
 				ubi_wl_put_fm_peb(ubi, new_fm->e[i], i, 0);
 			ret = -ENOSPC;
 			goto err;
 		}
 		new_fm->e[0]->pnum = tmp_e->pnum;
 		new_fm->e[0]->ec = tmp_e->ec;
 	}
 	down_write(&ubi->work_sem);
 	down_write(&ubi->fm_sem);
 	ret = ubi_write_fastmap(ubi, new_fm);
 	up_write(&ubi->fm_sem);
 	up_write(&ubi->work_sem);
 	if (ret)
 		goto err;
 out_unlock:
 	mutex_unlock(&ubi->fm_mutex);
 	kfree(old_fm);
 	return ret;
 err:
 	kfree(new_fm);
 	ubi_warn("Unable to write new fastmap, err=%i", ret);
 	ret = 0;
 	if (old_fm) {
 		ret = invalidate_fastmap(ubi, old_fm);
 		if (ret < 0)
 			ubi_err("Unable to invalidiate current fastmap!");
 		else if (ret)
 			ret = 0;
 	}
 	goto out_unlock;
 }

include/uapi/mtd/ubi-user.h

Diff comments View file @ 4517547

 /*
  * Copyright © International Business Machines Corp., 2006
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
  * the GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  *
  * Author: Artem Bityutskiy (Битюцкий Артём)
  */
 #ifndef __UBI_USER_H__
 #define __UBI_USER_H__
 #include <linux/types.h>
 /*
  * UBI device creation (the same as MTD device attachment)
  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  *
  * MTD devices may be attached using %UBI_IOCATT ioctl command of the UBI
  * control device. The caller has to properly fill and pass
  * &struct ubi_attach_req object - UBI will attach the MTD device specified in
  * the request and return the newly created UBI device number as the ioctl
  * return value.
  *
  * UBI device deletion (the same as MTD device detachment)
  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  *
  * An UBI device maybe deleted with %UBI_IOCDET ioctl command of the UBI
  * control device.
  *
  * UBI volume creation
  * ~~~~~~~~~~~~~~~~~~~
  *
  * UBI volumes are created via the %UBI_IOCMKVOL ioctl command of UBI character
  * device. A &struct ubi_mkvol_req object has to be properly filled and a
  * pointer to it has to be passed to the ioctl.
  *
  * UBI volume deletion
  * ~~~~~~~~~~~~~~~~~~~
  *
  * To delete a volume, the %UBI_IOCRMVOL ioctl command of the UBI character
  * device should be used. A pointer to the 32-bit volume ID hast to be passed
  * to the ioctl.
  *
  * UBI volume re-size
  * ~~~~~~~~~~~~~~~~~~
  *
  * To re-size a volume, the %UBI_IOCRSVOL ioctl command of the UBI character
  * device should be used. A &struct ubi_rsvol_req object has to be properly
  * filled and a pointer to it has to be passed to the ioctl.
  *
  * UBI volumes re-name
  * ~~~~~~~~~~~~~~~~~~~
  *
  * To re-name several volumes atomically at one go, the %UBI_IOCRNVOL command
  * of the UBI character device should be used. A &struct ubi_rnvol_req object
  * has to be properly filled and a pointer to it has to be passed to the ioctl.
  *
  * UBI volume update
  * ~~~~~~~~~~~~~~~~~
  *
  * Volume update should be done via the %UBI_IOCVOLUP ioctl command of the
  * corresponding UBI volume character device. A pointer to a 64-bit update
  * size should be passed to the ioctl. After this, UBI expects user to write
  * this number of bytes to the volume character device. The update is finished
  * when the claimed number of bytes is passed. So, the volume update sequence
  * is something like:
  *
  * fd = open("/dev/my_volume");
  * ioctl(fd, UBI_IOCVOLUP, &image_size);
  * write(fd, buf, image_size);
  * close(fd);
  *
  * Logical eraseblock erase
  * ~~~~~~~~~~~~~~~~~~~~~~~~
  *
  * To erase a logical eraseblock, the %UBI_IOCEBER ioctl command of the
  * corresponding UBI volume character device should be used. This command
  * unmaps the requested logical eraseblock, makes sure the corresponding
  * physical eraseblock is successfully erased, and returns.
  *
  * Atomic logical eraseblock change
  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  *
  * Atomic logical eraseblock change operation is called using the %UBI_IOCEBCH
  * ioctl command of the corresponding UBI volume character device. A pointer to
  * a &struct ubi_leb_change_req object has to be passed to the ioctl. Then the
  * user is expected to write the requested amount of bytes (similarly to what
  * should be done in case of the "volume update" ioctl).
  *
  * Logical eraseblock map
  * ~~~~~~~~~~~~~~~~~~~~~
  *
  * To map a logical eraseblock to a physical eraseblock, the %UBI_IOCEBMAP
  * ioctl command should be used. A pointer to a &struct ubi_map_req object is
  * expected to be passed. The ioctl maps the requested logical eraseblock to
  * a physical eraseblock and returns.  Only non-mapped logical eraseblocks can
  * be mapped. If the logical eraseblock specified in the request is already
  * mapped to a physical eraseblock, the ioctl fails and returns error.
  *
  * Logical eraseblock unmap
  * ~~~~~~~~~~~~~~~~~~~~~~~~
  *
  * To unmap a logical eraseblock to a physical eraseblock, the %UBI_IOCEBUNMAP
  * ioctl command should be used. The ioctl unmaps the logical eraseblocks,
  * schedules corresponding physical eraseblock for erasure, and returns. Unlike
  * the "LEB erase" command, it does not wait for the physical eraseblock being
  * erased. Note, the side effect of this is that if an unclean reboot happens
  * after the unmap ioctl returns, you may find the LEB mapped again to the same
  * physical eraseblock after the UBI is run again.
  *
  * Check if logical eraseblock is mapped
  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  *
  * To check if a logical eraseblock is mapped to a physical eraseblock, the
  * %UBI_IOCEBISMAP ioctl command should be used. It returns %0 if the LEB is
  * not mapped, and %1 if it is mapped.
  *
  * Set an UBI volume property
  * ~~~~~~~~~~~~~~~~~~~~~~~~~
  *
  * To set an UBI volume property the %UBI_IOCSETPROP ioctl command should be
  * used. A pointer to a &struct ubi_set_vol_prop_req object is expected to be
  * passed. The object describes which property should be set, and to which value
  * it should be set.
  */
 /*
  * When a new UBI volume or UBI device is created, users may either specify the
  * volume/device number they want to create or to let UBI automatically assign
  * the number using these constants.
  */
 #define UBI_VOL_NUM_AUTO (-1)
 #define UBI_DEV_NUM_AUTO (-1)
 /* Maximum volume name length */
 #define UBI_MAX_VOLUME_NAME 127
 /* ioctl commands of UBI character devices */
 #define UBI_IOC_MAGIC 'o'
 /* Create an UBI volume */
 #define UBI_IOCMKVOL _IOW(UBI_IOC_MAGIC, 0, struct ubi_mkvol_req)
 /* Remove an UBI volume */
 #define UBI_IOCRMVOL _IOW(UBI_IOC_MAGIC, 1, __s32)
 /* Re-size an UBI volume */
 #define UBI_IOCRSVOL _IOW(UBI_IOC_MAGIC, 2, struct ubi_rsvol_req)
 /* Re-name volumes */
 #define UBI_IOCRNVOL _IOW(UBI_IOC_MAGIC, 3, struct ubi_rnvol_req)
 /* ioctl commands of the UBI control character device */
 #define UBI_CTRL_IOC_MAGIC 'o'
 /* Attach an MTD device */
 #define UBI_IOCATT _IOW(UBI_CTRL_IOC_MAGIC, 64, struct ubi_attach_req)
 /* Detach an MTD device */
 #define UBI_IOCDET _IOW(UBI_CTRL_IOC_MAGIC, 65, __s32)
 /* ioctl commands of UBI volume character devices */
 #define UBI_VOL_IOC_MAGIC 'O'
-/* Start UBI volume update */
+/* Start UBI volume update
+ * Note: This actually takes a pointer (__s64*), but we can't change
+ *       that without breaking the ABI on 32bit systems
+ */
 #define UBI_IOCVOLUP _IOW(UBI_VOL_IOC_MAGIC, 0, __s64)
 /* LEB erasure command, used for debugging, disabled by default */
 #define UBI_IOCEBER _IOW(UBI_VOL_IOC_MAGIC, 1, __s32)
 /* Atomic LEB change command */
 #define UBI_IOCEBCH _IOW(UBI_VOL_IOC_MAGIC, 2, __s32)
 /* Map LEB command */
 #define UBI_IOCEBMAP _IOW(UBI_VOL_IOC_MAGIC, 3, struct ubi_map_req)
 /* Unmap LEB command */
 #define UBI_IOCEBUNMAP _IOW(UBI_VOL_IOC_MAGIC, 4, __s32)
 /* Check if LEB is mapped command */
 #define UBI_IOCEBISMAP _IOR(UBI_VOL_IOC_MAGIC, 5, __s32)
 /* Set an UBI volume property */
 #define UBI_IOCSETVOLPROP _IOW(UBI_VOL_IOC_MAGIC, 6, \
 			       struct ubi_set_vol_prop_req)
 /* Maximum MTD device name length supported by UBI */
 #define MAX_UBI_MTD_NAME_LEN 127
 /* Maximum amount of UBI volumes that can be re-named at one go */
 #define UBI_MAX_RNVOL 32
 /*
  * UBI volume type constants.
  *
  * @UBI_DYNAMIC_VOLUME: dynamic volume
  * @UBI_STATIC_VOLUME:  static volume
  */
 enum {
 	UBI_DYNAMIC_VOLUME = 3,
 	UBI_STATIC_VOLUME  = 4,
 };
 /*
  * UBI set volume property ioctl constants.
  *
  * @UBI_VOL_PROP_DIRECT_WRITE: allow (any non-zero value) or disallow (value 0)
  *                             user to directly write and erase individual
  *                             eraseblocks on dynamic volumes
  */
 enum {
 	UBI_VOL_PROP_DIRECT_WRITE = 1,
 };
 /**
  * struct ubi_attach_req - attach MTD device request.
  * @ubi_num: UBI device number to create
  * @mtd_num: MTD device number to attach
  * @vid_hdr_offset: VID header offset (use defaults if %0)
  * @max_beb_per1024: maximum expected number of bad PEB per 1024 PEBs
  * @padding: reserved for future, not used, has to be zeroed
  *
  * This data structure is used to specify MTD device UBI has to attach and the
  * parameters it has to use. The number which should be assigned to the new UBI
  * device is passed in @ubi_num. UBI may automatically assign the number if
  * @UBI_DEV_NUM_AUTO is passed. In this case, the device number is returned in
  * @ubi_num.
  *
  * Most applications should pass %0 in @vid_hdr_offset to make UBI use default
  * offset of the VID header within physical eraseblocks. The default offset is
  * the next min. I/O unit after the EC header. For example, it will be offset
  * 512 in case of a 512 bytes page NAND flash with no sub-page support. Or
  * it will be 512 in case of a 2KiB page NAND flash with 4 512-byte sub-pages.
  *
  * But in rare cases, if this optimizes things, the VID header may be placed to
  * a different offset. For example, the boot-loader might do things faster if
  * the VID header sits at the end of the first 2KiB NAND page with 4 sub-pages.
  * As the boot-loader would not normally need to read EC headers (unless it
  * needs UBI in RW mode), it might be faster to calculate ECC. This is weird
  * example, but it real-life example. So, in this example, @vid_hdr_offer would
  * be 2KiB-64 bytes = 1984. Note, that this position is not even 512-bytes
  * aligned, which is OK, as UBI is clever enough to realize this is 4th
  * sub-page of the first page and add needed padding.
  *
  * The @max_beb_per1024 is the maximum amount of bad PEBs UBI expects on the
  * UBI device per 1024 eraseblocks.  This value is often given in an other form
  * in the NAND datasheet (min NVB i.e. minimal number of valid blocks). The
  * maximum expected bad eraseblocks per 1024 is then:
  *    1024 * (1 - MinNVB / MaxNVB)
  * Which gives 20 for most NAND devices.  This limit is used in order to derive
  * amount of eraseblock UBI reserves for handling new bad blocks. If the device
  * has more bad eraseblocks than this limit, UBI does not reserve any physical
  * eraseblocks for new bad eraseblocks, but attempts to use available
  * eraseblocks (if any). The accepted range is 0-768. If 0 is given, the
  * default kernel value of %CONFIG_MTD_UBI_BEB_LIMIT will be used.
  */
 struct ubi_attach_req {
 	__s32 ubi_num;
 	__s32 mtd_num;
 	__s32 vid_hdr_offset;
 	__s16 max_beb_per1024;
 	__s8 padding[10];
 };
 /**
  * struct ubi_mkvol_req - volume description data structure used in
  *                        volume creation requests.
  * @vol_id: volume number
  * @alignment: volume alignment
  * @bytes: volume size in bytes
  * @vol_type: volume type (%UBI_DYNAMIC_VOLUME or %UBI_STATIC_VOLUME)
  * @padding1: reserved for future, not used, has to be zeroed
  * @name_len: volume name length
  * @padding2: reserved for future, not used, has to be zeroed
  * @name: volume name
  *
  * This structure is used by user-space programs when creating new volumes. The
  * @used_bytes field is only necessary when creating static volumes.
  *
  * The @alignment field specifies the required alignment of the volume logical
  * eraseblock. This means, that the size of logical eraseblocks will be aligned
  * to this number, i.e.,
  *	(UBI device logical eraseblock size) mod (@alignment) = 0.
  *
  * To put it differently, the logical eraseblock of this volume may be slightly
  * shortened in order to make it properly aligned. The alignment has to be
  * multiple of the flash minimal input/output unit, or %1 to utilize the entire
  * available space of logical eraseblocks.
  *
  * The @alignment field may be useful, for example, when one wants to maintain
  * a block device on top of an UBI volume. In this case, it is desirable to fit
  * an integer number of blocks in logical eraseblocks of this UBI volume. With
  * alignment it is possible to update this volume using plane UBI volume image
  * BLOBs, without caring about how to properly align them.
  */
 struct ubi_mkvol_req {
 	__s32 vol_id;
 	__s32 alignment;
 	__s64 bytes;
 	__s8 vol_type;
 	__s8 padding1;
 	__s16 name_len;
 	__s8 padding2[4];
 	char name[UBI_MAX_VOLUME_NAME + 1];
 } __packed;
 /**
  * struct ubi_rsvol_req - a data structure used in volume re-size requests.
  * @vol_id: ID of the volume to re-size
  * @bytes: new size of the volume in bytes
  *
  * Re-sizing is possible for both dynamic and static volumes. But while dynamic
  * volumes may be re-sized arbitrarily, static volumes cannot be made to be
  * smaller than the number of bytes they bear. To arbitrarily shrink a static
  * volume, it must be wiped out first (by means of volume update operation with
  * zero number of bytes).
  */
 struct ubi_rsvol_req {
 	__s64 bytes;
 	__s32 vol_id;
 } __packed;
 /**
  * struct ubi_rnvol_req - volumes re-name request.
  * @count: count of volumes to re-name
  * @padding1:  reserved for future, not used, has to be zeroed
  * @vol_id: ID of the volume to re-name
  * @name_len: name length
  * @padding2:  reserved for future, not used, has to be zeroed
  * @name: new volume name
  *
  * UBI allows to re-name up to %32 volumes at one go. The count of volumes to
  * re-name is specified in the @count field. The ID of the volumes to re-name
  * and the new names are specified in the @vol_id and @name fields.
  *
  * The UBI volume re-name operation is atomic, which means that should power cut
  * happen, the volumes will have either old name or new name. So the possible
  * use-cases of this command is atomic upgrade. Indeed, to upgrade, say, volumes
  * A and B one may create temporary volumes %A1 and %B1 with the new contents,
  * then atomically re-name A1->A and B1->B, in which case old %A and %B will
  * be removed.
  *
  * If it is not desirable to remove old A and B, the re-name request has to
  * contain 4 entries: A1->A, A->A1, B1->B, B->B1, in which case old A1 and B1
  * become A and B, and old A and B will become A1 and B1.
  *
  * It is also OK to request: A1->A, A1->X, B1->B, B->Y, in which case old A1
  * and B1 become A and B, and old A and B become X and Y.
  *
  * In other words, in case of re-naming into an existing volume name, the
  * existing volume is removed, unless it is re-named as well at the same
  * re-name request.
  */
 struct ubi_rnvol_req {
 	__s32 count;
 	__s8 padding1[12];
 	struct {
 		__s32 vol_id;
 		__s16 name_len;
 		__s8  padding2[2];
 		char    name[UBI_MAX_VOLUME_NAME + 1];
 	} ents[UBI_MAX_RNVOL];
 } __packed;
 /**
  * struct ubi_leb_change_req - a data structure used in atomic LEB change
  *                             requests.
  * @lnum: logical eraseblock number to change
  * @bytes: how many bytes will be written to the logical eraseblock
  * @dtype: pass "3" for better compatibility with old kernels
  * @padding: reserved for future, not used, has to be zeroed
  *
  * The @dtype field used to inform UBI about what kind of data will be written
  * to the LEB: long term (value 1), short term (value 2), unknown (value 3).
  * UBI tried to pick a PEB with lower erase counter for short term data and a
  * PEB with higher erase counter for long term data. But this was not really
  * used because users usually do not know this and could easily mislead UBI. We
  * removed this feature in May 2012. UBI currently just ignores the @dtype
  * field. But for better compatibility with older kernels it is recommended to
  * set @dtype to 3 (unknown).
  */
 struct ubi_leb_change_req {
 	__s32 lnum;
 	__s32 bytes;
 	__s8  dtype; /* obsolete, do not use! */
 	__s8  padding[7];
 } __packed;
 /**
  * struct ubi_map_req - a data structure used in map LEB requests.
  * @dtype: pass "3" for better compatibility with old kernels
  * @lnum: logical eraseblock number to unmap
  * @padding: reserved for future, not used, has to be zeroed
  */
 struct ubi_map_req {
 	__s32 lnum;
 	__s8  dtype; /* obsolete, do not use! */
 	__s8  padding[3];
 } __packed;
 /**
  * struct ubi_set_vol_prop_req - a data structure used to set an UBI volume
  *                               property.
  * @property: property to set (%UBI_VOL_PROP_DIRECT_WRITE)
  * @padding: reserved for future, not used, has to be zeroed
  * @value: value to set
  */
 struct ubi_set_vol_prop_req {
 	__u8  property;
 	__u8  padding[7];
 	__u64 value;
 }  __packed;
 #endif /* __UBI_USER_H__ */