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

Commit fbd0107f4d33be01c9fb2c630036bd66b7e3d4dc

Authored by Artem Bityutskiy 2012-05-17 21:12:26 +0800

Exists in smarc-l5.0.0_1.0.0-ga and in 5 other branches

UBI: amend comments after all the renamings

This patch amends commentaries in scan.[ch] to match the new logic. Reminder -
we did the restructuring to prepare the code for adding the fastmap. This patch
also renames a couple of functions - it was too difficult to separate out that
change and I decided that it is not too bad to have it in the same patch with
commentaries changes.

Signed-off-by: Artem Bityutskiy <artem.bityutskiy@linux.intel.com>

Showing 6 changed files with 73 additions and 81 deletions Inline Diff

drivers/mtd/ubi/build.c
drivers/mtd/ubi/io.c
drivers/mtd/ubi/scan.c
drivers/mtd/ubi/scan.h
drivers/mtd/ubi/ubi-media.h
drivers/mtd/ubi/vtbl.c

drivers/mtd/ubi/build.c

Diff comments View file @ fbd0107

 /*
  * 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".
- *
- * At the moment we only attach UBI devices by scanning, which will become a
- * bottleneck when flashes reach certain large size. Then one may improve UBI
- * and add other methods, although it does not seem to be easy to do.
  */
 #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/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
 #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
  */
 struct mtd_dev_param {
 	char name[MTD_PARAM_LEN_MAX];
 	int vid_hdr_offs;
 };
 /* 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];
 /* 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);
 	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);
 }
 /**
  * free_internal_volumes - free internal volumes.
  * @ubi: UBI device description object
  */
 static void 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]);
 	}
 }
 /**
  * attach_by_scanning - attach an MTD device using scanning method.
  * @ubi: UBI device descriptor
  *
  * This function returns zero in case of success and a negative error code in
  * case of failure.
  *
  * Note, currently this is the only method to attach UBI devices. Hopefully in
  * the future we'll have more scalable attaching methods and avoid full media
  * scanning. But even in this case scanning will be needed as a fall-back
  * attaching method if there are some on-flash table corruptions.
  */
 static int attach_by_scanning(struct ubi_device *ubi)
 {
 	int err;
 	struct ubi_attach_info *ai;
 	ai = ubi_scan(ubi);
 	if (IS_ERR(ai))
 		return PTR_ERR(ai);
 	ubi->bad_peb_count = ai->bad_peb_count;
 	ubi->good_peb_count = ubi->peb_count - ubi->bad_peb_count;
 	ubi->corr_peb_count = ai->corr_peb_count;
 	ubi->max_ec = ai->max_ec;
 	ubi->mean_ec = ai->mean_ec;
 	ubi_msg("max. sequence number:       %llu", ai->max_sqnum);
 	err = ubi_read_volume_table(ubi, ai);
 	if (err)
 		goto out_ai;
 	err = ubi_wl_init_scan(ubi, ai);
 	if (err)
 		goto out_vtbl;
 	err = ubi_eba_init_scan(ubi, ai);
 	if (err)
 		goto out_wl;
 	ubi_destroy_ai(ai);
 	return 0;
 out_wl:
 	ubi_wl_close(ubi);
 out_vtbl:
 	free_internal_volumes(ubi);
 	vfree(ubi->vtbl);
 out_ai:
 	ubi_destroy_ai(ai);
 	return err;
 }
 /**
  * io_init - initialize I/O sub-system for a given UBI device.
  * @ubi: UBI device description object
  *
  * 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)
 {
 	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;
 	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_msg("min_io_size      %d", ubi->min_io_size);
 	dbg_msg("max_write_size   %d", ubi->max_write_size);
 	dbg_msg("hdrs_min_io_size %d", ubi->hdrs_min_io_size);
 	dbg_msg("ec_hdr_alsize    %d", ubi->ec_hdr_alsize);
 	dbg_msg("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_msg("vid_hdr_offset   %d", ubi->vid_hdr_offset);
 	dbg_msg("vid_hdr_aloffset %d", ubi->vid_hdr_aloffset);
 	dbg_msg("vid_hdr_shift    %d", ubi->vid_hdr_shift);
 	dbg_msg("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_msg("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;
 	}
 	ubi_msg("physical eraseblock size:   %d bytes (%d KiB)",
 		ubi->peb_size, ubi->peb_size >> 10);
 	ubi_msg("logical eraseblock size:    %d bytes", ubi->leb_size);
 	ubi_msg("smallest flash I/O unit:    %d", ubi->min_io_size);
 	if (ubi->hdrs_min_io_size != ubi->min_io_size)
 		ubi_msg("sub-page size:              %d",
 			ubi->hdrs_min_io_size);
 	ubi_msg("VID header offset:          %d (aligned %d)",
 		ubi->vid_hdr_offset, ubi->vid_hdr_aloffset);
 	ubi_msg("data offset:                %d", ubi->leb_start);
 	/*
-	 * Note, ideally, we have to initialize ubi->bad_peb_count here. But
+	 * 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 skip ubi->bad_peb_count
+	 * each physical eraseblock. So, we leave @ubi->bad_peb_count
-	 * uninitialized and initialize it after scanning.
+	 * 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
+ * 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;
 	/*
 	 * 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.
 		 */
 		memcpy(&vtbl_rec, &ubi->vtbl[vol_id],
 		       sizeof(struct ubi_vtbl_record));
 		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
  *
  * 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)
 {
 	struct ubi_device *ubi;
 	int i, err, ref = 0;
 	/*
 	 * 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;
 	mutex_init(&ubi->buf_mutex);
 	mutex_init(&ubi->ckvol_mutex);
 	mutex_init(&ubi->device_mutex);
 	spin_lock_init(&ubi->volumes_lock);
 	ubi_msg("attaching mtd%d to ubi%d", mtd->index, ubi_num);
 	dbg_msg("sizeof(struct ubi_ainf_peb) %zu", sizeof(struct ubi_ainf_peb));
 	dbg_msg("sizeof(struct ubi_wl_entry) %zu", sizeof(struct ubi_wl_entry));
 	err = io_init(ubi);
 	if (err)
 		goto out_free;
 	err = -ENOMEM;
 	ubi->peb_buf = vmalloc(ubi->peb_size);
 	if (!ubi->peb_buf)
 		goto out_free;
 	err = ubi_debugging_init_dev(ubi);
 	if (err)
 		goto out_free;
 	err = attach_by_scanning(ubi);
 	if (err) {
 		ubi_err("failed to attach by scanning, error %d", err);
 		goto out_debugging;
 	}
 	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, 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 to ubi%d", mtd->index, ubi_num);
 	ubi_msg("MTD device name:            \"%s\"", mtd->name);
 	ubi_msg("MTD device size:            %llu MiB", ubi->flash_size >> 20);
 	ubi_msg("number of good PEBs:        %d", ubi->good_peb_count);
 	ubi_msg("number of bad PEBs:         %d", ubi->bad_peb_count);
 	ubi_msg("number of corrupted PEBs:   %d", ubi->corr_peb_count);
 	ubi_msg("max. allowed volumes:       %d", ubi->vtbl_slots);
 	ubi_msg("wear-leveling threshold:    %d", CONFIG_MTD_UBI_WL_THRESHOLD);
 	ubi_msg("number of internal volumes: %d", UBI_INT_VOL_COUNT);
 	ubi_msg("number of user volumes:     %d",
 		ubi->vol_count - UBI_INT_VOL_COUNT);
 	ubi_msg("available PEBs:             %d", ubi->avail_pebs);
 	ubi_msg("total number of reserved PEBs: %d", ubi->rsvd_pebs);
 	ubi_msg("number of PEBs reserved for bad PEB handling: %d",
 		ubi->beb_rsvd_pebs);
 	ubi_msg("max/mean erase counter: %d/%d", ubi->max_ec, ubi->mean_ec);
 	ubi_msg("image sequence number:  %d", ubi->image_seq);
 	/*
 	 * 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);
 	free_internal_volumes(ubi);
 	vfree(ubi->vtbl);
 out_debugging:
 	ubi_debugging_exit_dev(ubi);
 out_free:
 	vfree(ubi->peb_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);
 	dbg_msg("detaching mtd%d from ubi%d", ubi->mtd->index, ubi_num);
 	/*
 	 * 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);
 	free_internal_volumes(ubi);
 	vfree(ubi->vtbl);
 	put_mtd_device(ubi->mtd);
 	ubi_debugging_exit_dev(ubi);
 	vfree(ubi->peb_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;
 		}
 		mutex_lock(&ubi_devices_mutex);
 		err = ubi_attach_mtd_dev(mtd, UBI_DEV_NUM_AUTO,
 					 p->vid_hdr_offs);
 		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);
 	return err;
 }
 module_init(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) {
 		printk(KERN_ERR "UBI error: 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:
 		printk(KERN_ERR "UBI error: 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[2] = {NULL, NULL};
 	if (!val)
 		return -EINVAL;
 	if (mtd_devs == UBI_MAX_DEVICES) {
 		printk(KERN_ERR "UBI error: 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) {
 		printk(KERN_ERR "UBI error: parameter \"%s\" is too long, "
 		       "max. is %d\n", val, MTD_PARAM_LEN_MAX);
 		return -EINVAL;
 	}
 	if (len == 0) {
 		printk(KERN_WARNING "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 < 2; i++)
 		tokens[i] = strsep(&pbuf, ",");
 	if (pbuf) {
 		printk(KERN_ERR "UBI error: too many arguments at \"%s\"\n",
 		       val);
 		return -EINVAL;
 	}
 	p = &mtd_dev_param[mtd_devs];
 	strcpy(&p->name[0], tokens[0]);
 	if (tokens[1])
 		p->vid_hdr_offs = bytes_str_to_int(tokens[1]);
 	if (p->vid_hdr_offs < 0)
 		return p->vid_hdr_offs;
 	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>].\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.\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.");
 MODULE_VERSION(__stringify(UBI_VERSION));
 MODULE_DESCRIPTION("UBI - Unsorted Block Images");
 MODULE_AUTHOR("Artem Bityutskiy");
 MODULE_LICENSE("GPL");

drivers/mtd/ubi/io.c

Diff comments View file @ fbd0107

 /*
  * Copyright (c) International Business Machines Corp., 2006
  * Copyright (c) Nokia Corporation, 2006, 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 (Битюцкий Артём)
  */
 /*
  * UBI input/output sub-system.
  *
  * This sub-system provides a uniform way to work with all kinds of the
  * underlying MTD devices. It also implements handy functions for reading and
  * writing UBI headers.
  *
  * We are trying to have a paranoid mindset and not to trust to what we read
  * from the flash media in order to be more secure and robust. So this
  * sub-system validates every single header it reads from the flash media.
  *
  * Some words about how the eraseblock headers are stored.
  *
  * The erase counter header is always stored at offset zero. By default, the
  * VID header is stored after the EC header at the closest aligned offset
  * (i.e. aligned to the minimum I/O unit size). Data starts next to the VID
  * header at the closest aligned offset. But this default layout may be
  * changed. For example, for different reasons (e.g., optimization) UBI may be
  * asked to put the VID header at further offset, and even at an unaligned
  * offset. Of course, if the offset of the VID header is unaligned, UBI adds
  * proper padding in front of it. Data offset may also be changed but it has to
  * be aligned.
  *
  * About minimal I/O units. In general, UBI assumes flash device model where
  * there is only one minimal I/O unit size. E.g., in case of NOR flash it is 1,
  * in case of NAND flash it is a NAND page, etc. This is reported by MTD in the
  * @ubi->mtd->writesize field. But as an exception, UBI admits of using another
  * (smaller) minimal I/O unit size for EC and VID headers to make it possible
  * to do different optimizations.
  *
  * This is extremely useful in case of NAND flashes which admit of several
  * write operations to one NAND page. In this case UBI can fit EC and VID
  * headers at one NAND page. Thus, UBI may use "sub-page" size as the minimal
  * I/O unit for the headers (the @ubi->hdrs_min_io_size field). But it still
  * reports NAND page size (@ubi->min_io_size) as a minimal I/O unit for the UBI
  * users.
  *
  * Example: some Samsung NANDs with 2KiB pages allow 4x 512-byte writes, so
  * although the minimal I/O unit is 2K, UBI uses 512 bytes for EC and VID
  * headers.
  *
  * Q: why not just to treat sub-page as a minimal I/O unit of this flash
  * device, e.g., make @ubi->min_io_size = 512 in the example above?
  *
  * A: because when writing a sub-page, MTD still writes a full 2K page but the
  * bytes which are not relevant to the sub-page are 0xFF. So, basically,
  * writing 4x512 sub-pages is 4 times slower than writing one 2KiB NAND page.
  * Thus, we prefer to use sub-pages only for EC and VID headers.
  *
  * As it was noted above, the VID header may start at a non-aligned offset.
  * For example, in case of a 2KiB page NAND flash with a 512 bytes sub-page,
  * the VID header may reside at offset 1984 which is the last 64 bytes of the
  * last sub-page (EC header is always at offset zero). This causes some
  * difficulties when reading and writing VID headers.
  *
  * Suppose we have a 64-byte buffer and we read a VID header at it. We change
  * the data and want to write this VID header out. As we can only write in
  * 512-byte chunks, we have to allocate one more buffer and copy our VID header
  * to offset 448 of this buffer.
  *
  * The I/O sub-system does the following trick in order to avoid this extra
  * copy. It always allocates a @ubi->vid_hdr_alsize bytes buffer for the VID
  * header and returns a pointer to offset @ubi->vid_hdr_shift of this buffer.
  * When the VID header is being written out, it shifts the VID header pointer
  * back and writes the whole sub-page.
  */
 #include <linux/crc32.h>
 #include <linux/err.h>
 #include <linux/slab.h>
 #include "ubi.h"
 static int self_check_not_bad(const struct ubi_device *ubi, int pnum);
 static int self_check_peb_ec_hdr(const struct ubi_device *ubi, int pnum);
 static int self_check_ec_hdr(const struct ubi_device *ubi, int pnum,
 			     const struct ubi_ec_hdr *ec_hdr);
 static int self_check_peb_vid_hdr(const struct ubi_device *ubi, int pnum);
 static int self_check_vid_hdr(const struct ubi_device *ubi, int pnum,
 			      const struct ubi_vid_hdr *vid_hdr);
 static int self_check_write(struct ubi_device *ubi, const void *buf, int pnum,
 			    int offset, int len);
 /**
  * ubi_io_read - read data from a physical eraseblock.
  * @ubi: UBI device description object
  * @buf: buffer where to store the read data
  * @pnum: physical eraseblock number to read from
  * @offset: offset within the physical eraseblock from where to read
  * @len: how many bytes to read
  *
  * This function reads data from offset @offset of physical eraseblock @pnum
  * and stores the read data in the @buf buffer. The following return codes are
  * possible:
  *
  * o %0 if all the requested data were successfully read;
  * o %UBI_IO_BITFLIPS if all the requested data were successfully read, but
  *   correctable bit-flips were detected; this is harmless but may indicate
  *   that this eraseblock may become bad soon (but do not have to);
  * o %-EBADMSG if the MTD subsystem reported about data integrity problems, for
  *   example it can be an ECC error in case of NAND; this most probably means
  *   that the data is corrupted;
  * o %-EIO if some I/O error occurred;
  * o other negative error codes in case of other errors.
  */
 int ubi_io_read(const struct ubi_device *ubi, void *buf, int pnum, int offset,
 		int len)
 {
 	int err, retries = 0;
 	size_t read;
 	loff_t addr;
 	dbg_io("read %d bytes from PEB %d:%d", len, pnum, offset);
 	ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
 	ubi_assert(offset >= 0 && offset + len <= ubi->peb_size);
 	ubi_assert(len > 0);
 	err = self_check_not_bad(ubi, pnum);
 	if (err)
 		return err;
 	/*
 	 * Deliberately corrupt the buffer to improve robustness. Indeed, if we
 	 * do not do this, the following may happen:
 	 * 1. The buffer contains data from previous operation, e.g., read from
 	 *    another PEB previously. The data looks like expected, e.g., if we
 	 *    just do not read anything and return - the caller would not
 	 *    notice this. E.g., if we are reading a VID header, the buffer may
 	 *    contain a valid VID header from another PEB.
 	 * 2. The driver is buggy and returns us success or -EBADMSG or
 	 *    -EUCLEAN, but it does not actually put any data to the buffer.
 	 *
 	 * This may confuse UBI or upper layers - they may think the buffer
 	 * contains valid data while in fact it is just old data. This is
 	 * especially possible because UBI (and UBIFS) relies on CRC, and
 	 * treats data as correct even in case of ECC errors if the CRC is
 	 * correct.
 	 *
 	 * Try to prevent this situation by changing the first byte of the
 	 * buffer.
 	 */
 	*((uint8_t *)buf) ^= 0xFF;
 	addr = (loff_t)pnum * ubi->peb_size + offset;
 retry:
 	err = mtd_read(ubi->mtd, addr, len, &read, buf);
 	if (err) {
 		const char *errstr = mtd_is_eccerr(err) ? " (ECC error)" : "";
 		if (mtd_is_bitflip(err)) {
 			/*
 			 * -EUCLEAN is reported if there was a bit-flip which
 			 * was corrected, so this is harmless.
 			 *
 			 * We do not report about it here unless debugging is
 			 * enabled. A corresponding message will be printed
 			 * later, when it is has been scrubbed.
 			 */
 			dbg_msg("fixable bit-flip detected at PEB %d", pnum);
 			ubi_assert(len == read);
 			return UBI_IO_BITFLIPS;
 		}
 		if (retries++ < UBI_IO_RETRIES) {
 			ubi_warn("error %d%s while reading %d bytes from PEB "
 				 "%d:%d, read only %zd bytes, retry",
 				 err, errstr, len, pnum, offset, read);
 			yield();
 			goto retry;
 		}
 		ubi_err("error %d%s while reading %d bytes from PEB %d:%d, "
 			"read %zd bytes", err, errstr, len, pnum, offset, read);
 		dump_stack();
 		/*
 		 * The driver should never return -EBADMSG if it failed to read
 		 * all the requested data. But some buggy drivers might do
 		 * this, so we change it to -EIO.
 		 */
 		if (read != len && mtd_is_eccerr(err)) {
 			ubi_assert(0);
 			err = -EIO;
 		}
 	} else {
 		ubi_assert(len == read);
 		if (ubi_dbg_is_bitflip(ubi)) {
 			dbg_gen("bit-flip (emulated)");
 			err = UBI_IO_BITFLIPS;
 		}
 	}
 	return err;
 }
 /**
  * ubi_io_write - write data to a physical eraseblock.
  * @ubi: UBI device description object
  * @buf: buffer with the data to write
  * @pnum: physical eraseblock number to write to
  * @offset: offset within the physical eraseblock where to write
  * @len: how many bytes to write
  *
  * This function writes @len bytes of data from buffer @buf to offset @offset
  * of physical eraseblock @pnum. If all the data were successfully written,
  * zero is returned. If an error occurred, this function returns a negative
  * error code. If %-EIO is returned, the physical eraseblock most probably went
  * bad.
  *
  * Note, in case of an error, it is possible that something was still written
  * to the flash media, but may be some garbage.
  */
 int ubi_io_write(struct ubi_device *ubi, const void *buf, int pnum, int offset,
 		 int len)
 {
 	int err;
 	size_t written;
 	loff_t addr;
 	dbg_io("write %d bytes to PEB %d:%d", len, pnum, offset);
 	ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
 	ubi_assert(offset >= 0 && offset + len <= ubi->peb_size);
 	ubi_assert(offset % ubi->hdrs_min_io_size == 0);
 	ubi_assert(len > 0 && len % ubi->hdrs_min_io_size == 0);
 	if (ubi->ro_mode) {
 		ubi_err("read-only mode");
 		return -EROFS;
 	}
 	err = self_check_not_bad(ubi, pnum);
 	if (err)
 		return err;
 	/* The area we are writing to has to contain all 0xFF bytes */
 	err = ubi_self_check_all_ff(ubi, pnum, offset, len);
 	if (err)
 		return err;
 	if (offset >= ubi->leb_start) {
 		/*
 		 * We write to the data area of the physical eraseblock. Make
 		 * sure it has valid EC and VID headers.
 		 */
 		err = self_check_peb_ec_hdr(ubi, pnum);
 		if (err)
 			return err;
 		err = self_check_peb_vid_hdr(ubi, pnum);
 		if (err)
 			return err;
 	}
 	if (ubi_dbg_is_write_failure(ubi)) {
 		ubi_err("cannot write %d bytes to PEB %d:%d "
 			"(emulated)", len, pnum, offset);
 		dump_stack();
 		return -EIO;
 	}
 	addr = (loff_t)pnum * ubi->peb_size + offset;
 	err = mtd_write(ubi->mtd, addr, len, &written, buf);
 	if (err) {
 		ubi_err("error %d while writing %d bytes to PEB %d:%d, written "
 			"%zd bytes", err, len, pnum, offset, written);
 		dump_stack();
 		ubi_dump_flash(ubi, pnum, offset, len);
 	} else
 		ubi_assert(written == len);
 	if (!err) {
 		err = self_check_write(ubi, buf, pnum, offset, len);
 		if (err)
 			return err;
 		/*
 		 * Since we always write sequentially, the rest of the PEB has
 		 * to contain only 0xFF bytes.
 		 */
 		offset += len;
 		len = ubi->peb_size - offset;
 		if (len)
 			err = ubi_self_check_all_ff(ubi, pnum, offset, len);
 	}
 	return err;
 }
 /**
  * erase_callback - MTD erasure call-back.
  * @ei: MTD erase information object.
  *
  * Note, even though MTD erase interface is asynchronous, all the current
  * implementations are synchronous anyway.
  */
 static void erase_callback(struct erase_info *ei)
 {
 	wake_up_interruptible((wait_queue_head_t *)ei->priv);
 }
 /**
  * do_sync_erase - synchronously erase a physical eraseblock.
  * @ubi: UBI device description object
  * @pnum: the physical eraseblock number to erase
  *
  * This function synchronously erases physical eraseblock @pnum and returns
  * zero in case of success and a negative error code in case of failure. If
  * %-EIO is returned, the physical eraseblock most probably went bad.
  */
 static int do_sync_erase(struct ubi_device *ubi, int pnum)
 {
 	int err, retries = 0;
 	struct erase_info ei;
 	wait_queue_head_t wq;
 	dbg_io("erase PEB %d", pnum);
 	ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
 	if (ubi->ro_mode) {
 		ubi_err("read-only mode");
 		return -EROFS;
 	}
 retry:
 	init_waitqueue_head(&wq);
 	memset(&ei, 0, sizeof(struct erase_info));
 	ei.mtd      = ubi->mtd;
 	ei.addr     = (loff_t)pnum * ubi->peb_size;
 	ei.len      = ubi->peb_size;
 	ei.callback = erase_callback;
 	ei.priv     = (unsigned long)&wq;
 	err = mtd_erase(ubi->mtd, &ei);
 	if (err) {
 		if (retries++ < UBI_IO_RETRIES) {
 			ubi_warn("error %d while erasing PEB %d, retry",
 				 err, pnum);
 			yield();
 			goto retry;
 		}
 		ubi_err("cannot erase PEB %d, error %d", pnum, err);
 		dump_stack();
 		return err;
 	}
 	err = wait_event_interruptible(wq, ei.state == MTD_ERASE_DONE ||
 					   ei.state == MTD_ERASE_FAILED);
 	if (err) {
 		ubi_err("interrupted PEB %d erasure", pnum);
 		return -EINTR;
 	}
 	if (ei.state == MTD_ERASE_FAILED) {
 		if (retries++ < UBI_IO_RETRIES) {
 			ubi_warn("error while erasing PEB %d, retry", pnum);
 			yield();
 			goto retry;
 		}
 		ubi_err("cannot erase PEB %d", pnum);
 		dump_stack();
 		return -EIO;
 	}
 	err = ubi_self_check_all_ff(ubi, pnum, 0, ubi->peb_size);
 	if (err)
 		return err;
 	if (ubi_dbg_is_erase_failure(ubi)) {
 		ubi_err("cannot erase PEB %d (emulated)", pnum);
 		return -EIO;
 	}
 	return 0;
 }
 /* Patterns to write to a physical eraseblock when torturing it */
 static uint8_t patterns[] = {0xa5, 0x5a, 0x0};
 /**
  * torture_peb - test a supposedly bad physical eraseblock.
  * @ubi: UBI device description object
  * @pnum: the physical eraseblock number to test
  *
  * This function returns %-EIO if the physical eraseblock did not pass the
  * test, a positive number of erase operations done if the test was
  * successfully passed, and other negative error codes in case of other errors.
  */
 static int torture_peb(struct ubi_device *ubi, int pnum)
 {
 	int err, i, patt_count;
 	ubi_msg("run torture test for PEB %d", pnum);
 	patt_count = ARRAY_SIZE(patterns);
 	ubi_assert(patt_count > 0);
 	mutex_lock(&ubi->buf_mutex);
 	for (i = 0; i < patt_count; i++) {
 		err = do_sync_erase(ubi, pnum);
 		if (err)
 			goto out;
 		/* Make sure the PEB contains only 0xFF bytes */
 		err = ubi_io_read(ubi, ubi->peb_buf, pnum, 0, ubi->peb_size);
 		if (err)
 			goto out;
 		err = ubi_check_pattern(ubi->peb_buf, 0xFF, ubi->peb_size);
 		if (err == 0) {
 			ubi_err("erased PEB %d, but a non-0xFF byte found",
 				pnum);
 			err = -EIO;
 			goto out;
 		}
 		/* Write a pattern and check it */
 		memset(ubi->peb_buf, patterns[i], ubi->peb_size);
 		err = ubi_io_write(ubi, ubi->peb_buf, pnum, 0, ubi->peb_size);
 		if (err)
 			goto out;
 		memset(ubi->peb_buf, ~patterns[i], ubi->peb_size);
 		err = ubi_io_read(ubi, ubi->peb_buf, pnum, 0, ubi->peb_size);
 		if (err)
 			goto out;
 		err = ubi_check_pattern(ubi->peb_buf, patterns[i],
 					ubi->peb_size);
 		if (err == 0) {
 			ubi_err("pattern %x checking failed for PEB %d",
 				patterns[i], pnum);
 			err = -EIO;
 			goto out;
 		}
 	}
 	err = patt_count;
 	ubi_msg("PEB %d passed torture test, do not mark it as bad", pnum);
 out:
 	mutex_unlock(&ubi->buf_mutex);
 	if (err == UBI_IO_BITFLIPS || mtd_is_eccerr(err)) {
 		/*
 		 * If a bit-flip or data integrity error was detected, the test
 		 * has not passed because it happened on a freshly erased
 		 * physical eraseblock which means something is wrong with it.
 		 */
 		ubi_err("read problems on freshly erased PEB %d, must be bad",
 			pnum);
 		err = -EIO;
 	}
 	return err;
 }
 /**
  * nor_erase_prepare - prepare a NOR flash PEB for erasure.
  * @ubi: UBI device description object
  * @pnum: physical eraseblock number to prepare
  *
  * NOR flash, or at least some of them, have peculiar embedded PEB erasure
  * algorithm: the PEB is first filled with zeroes, then it is erased. And
  * filling with zeroes starts from the end of the PEB. This was observed with
  * Spansion S29GL512N NOR flash.
  *
  * This means that in case of a power cut we may end up with intact data at the
  * beginning of the PEB, and all zeroes at the end of PEB. In other words, the
  * EC and VID headers are OK, but a large chunk of data at the end of PEB is
  * zeroed. This makes UBI mistakenly treat this PEB as used and associate it
  * with an LEB, which leads to subsequent failures (e.g., UBIFS fails).
  *
  * This function is called before erasing NOR PEBs and it zeroes out EC and VID
  * magic numbers in order to invalidate them and prevent the failures. Returns
  * zero in case of success and a negative error code in case of failure.
  */
 static int nor_erase_prepare(struct ubi_device *ubi, int pnum)
 {
 	int err, err1;
 	size_t written;
 	loff_t addr;
 	uint32_t data = 0;
 	/*
 	 * Note, we cannot generally define VID header buffers on stack,
 	 * because of the way we deal with these buffers (see the header
 	 * comment in this file). But we know this is a NOR-specific piece of
 	 * code, so we can do this. But yes, this is error-prone and we should
 	 * (pre-)allocate VID header buffer instead.
 	 */
 	struct ubi_vid_hdr vid_hdr;
 	/*
 	 * It is important to first invalidate the EC header, and then the VID
 	 * header. Otherwise a power cut may lead to valid EC header and
 	 * invalid VID header, in which case UBI will treat this PEB as
-	 * corrupted and will try to preserve it, and print scary warnings (see
+	 * corrupted and will try to preserve it, and print scary warnings.
-	 * the header comment in scan.c for more information).
 	 */
 	addr = (loff_t)pnum * ubi->peb_size;
 	err = mtd_write(ubi->mtd, addr, 4, &written, (void *)&data);
 	if (!err) {
 		addr += ubi->vid_hdr_aloffset;
 		err = mtd_write(ubi->mtd, addr, 4, &written, (void *)&data);
 		if (!err)
 			return 0;
 	}
 	/*
 	 * We failed to write to the media. This was observed with Spansion
 	 * S29GL512N NOR flash. Most probably the previously eraseblock erasure
 	 * was interrupted at a very inappropriate moment, so it became
 	 * unwritable. In this case we probably anyway have garbage in this
 	 * PEB.
 	 */
 	err1 = ubi_io_read_vid_hdr(ubi, pnum, &vid_hdr, 0);
 	if (err1 == UBI_IO_BAD_HDR_EBADMSG || err1 == UBI_IO_BAD_HDR ||
 	    err1 == UBI_IO_FF) {
 		struct ubi_ec_hdr ec_hdr;
 		err1 = ubi_io_read_ec_hdr(ubi, pnum, &ec_hdr, 0);
 		if (err1 == UBI_IO_BAD_HDR_EBADMSG || err1 == UBI_IO_BAD_HDR ||
 		    err1 == UBI_IO_FF)
 			/*
 			 * Both VID and EC headers are corrupted, so we can
 			 * safely erase this PEB and not afraid that it will be
 			 * treated as a valid PEB in case of an unclean reboot.
 			 */
 			return 0;
 	}
 	/*
 	 * The PEB contains a valid VID header, but we cannot invalidate it.
 	 * Supposedly the flash media or the driver is screwed up, so return an
 	 * error.
 	 */
 	ubi_err("cannot invalidate PEB %d, write returned %d read returned %d",
 		pnum, err, err1);
 	ubi_dump_flash(ubi, pnum, 0, ubi->peb_size);
 	return -EIO;
 }
 /**
  * ubi_io_sync_erase - synchronously erase a physical eraseblock.
  * @ubi: UBI device description object
  * @pnum: physical eraseblock number to erase
  * @torture: if this physical eraseblock has to be tortured
  *
  * This function synchronously erases physical eraseblock @pnum. If @torture
  * flag is not zero, the physical eraseblock is checked by means of writing
  * different patterns to it and reading them back. If the torturing is enabled,
  * the physical eraseblock is erased more than once.
  *
  * This function returns the number of erasures made in case of success, %-EIO
  * if the erasure failed or the torturing test failed, and other negative error
  * codes in case of other errors. Note, %-EIO means that the physical
  * eraseblock is bad.
  */
 int ubi_io_sync_erase(struct ubi_device *ubi, int pnum, int torture)
 {
 	int err, ret = 0;
 	ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
 	err = self_check_not_bad(ubi, pnum);
 	if (err != 0)
 		return err;
 	if (ubi->ro_mode) {
 		ubi_err("read-only mode");
 		return -EROFS;
 	}
 	if (ubi->nor_flash) {
 		err = nor_erase_prepare(ubi, pnum);
 		if (err)
 			return err;
 	}
 	if (torture) {
 		ret = torture_peb(ubi, pnum);
 		if (ret < 0)
 			return ret;
 	}
 	err = do_sync_erase(ubi, pnum);
 	if (err)
 		return err;
 	return ret + 1;
 }
 /**
  * ubi_io_is_bad - check if a physical eraseblock is bad.
  * @ubi: UBI device description object
  * @pnum: the physical eraseblock number to check
  *
  * This function returns a positive number if the physical eraseblock is bad,
  * zero if not, and a negative error code if an error occurred.
  */
 int ubi_io_is_bad(const struct ubi_device *ubi, int pnum)
 {
 	struct mtd_info *mtd = ubi->mtd;
 	ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
 	if (ubi->bad_allowed) {
 		int ret;
 		ret = mtd_block_isbad(mtd, (loff_t)pnum * ubi->peb_size);
 		if (ret < 0)
 			ubi_err("error %d while checking if PEB %d is bad",
 				ret, pnum);
 		else if (ret)
 			dbg_io("PEB %d is bad", pnum);
 		return ret;
 	}
 	return 0;
 }
 /**
  * ubi_io_mark_bad - mark a physical eraseblock as bad.
  * @ubi: UBI device description object
  * @pnum: the physical eraseblock number to mark
  *
  * This function returns zero in case of success and a negative error code in
  * case of failure.
  */
 int ubi_io_mark_bad(const struct ubi_device *ubi, int pnum)
 {
 	int err;
 	struct mtd_info *mtd = ubi->mtd;
 	ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
 	if (ubi->ro_mode) {
 		ubi_err("read-only mode");
 		return -EROFS;
 	}
 	if (!ubi->bad_allowed)
 		return 0;
 	err = mtd_block_markbad(mtd, (loff_t)pnum * ubi->peb_size);
 	if (err)
 		ubi_err("cannot mark PEB %d bad, error %d", pnum, err);
 	return err;
 }
 /**
  * validate_ec_hdr - validate an erase counter header.
  * @ubi: UBI device description object
  * @ec_hdr: the erase counter header to check
  *
  * This function returns zero if the erase counter header is OK, and %1 if
  * not.
  */
 static int validate_ec_hdr(const struct ubi_device *ubi,
 			   const struct ubi_ec_hdr *ec_hdr)
 {
 	long long ec;
 	int vid_hdr_offset, leb_start;
 	ec = be64_to_cpu(ec_hdr->ec);
 	vid_hdr_offset = be32_to_cpu(ec_hdr->vid_hdr_offset);
 	leb_start = be32_to_cpu(ec_hdr->data_offset);
 	if (ec_hdr->version != UBI_VERSION) {
 		ubi_err("node with incompatible UBI version found: "
 			"this UBI version is %d, image version is %d",
 			UBI_VERSION, (int)ec_hdr->version);
 		goto bad;
 	}
 	if (vid_hdr_offset != ubi->vid_hdr_offset) {
 		ubi_err("bad VID header offset %d, expected %d",
 			vid_hdr_offset, ubi->vid_hdr_offset);
 		goto bad;
 	}
 	if (leb_start != ubi->leb_start) {
 		ubi_err("bad data offset %d, expected %d",
 			leb_start, ubi->leb_start);
 		goto bad;
 	}
 	if (ec < 0 || ec > UBI_MAX_ERASECOUNTER) {
 		ubi_err("bad erase counter %lld", ec);
 		goto bad;
 	}
 	return 0;
 bad:
 	ubi_err("bad EC header");
 	ubi_dump_ec_hdr(ec_hdr);
 	dump_stack();
 	return 1;
 }
 /**
  * ubi_io_read_ec_hdr - read and check an erase counter header.
  * @ubi: UBI device description object
  * @pnum: physical eraseblock to read from
  * @ec_hdr: a &struct ubi_ec_hdr object where to store the read erase counter
  * header
  * @verbose: be verbose if the header is corrupted or was not found
  *
  * This function reads erase counter header from physical eraseblock @pnum and
  * stores it in @ec_hdr. This function also checks CRC checksum of the read
  * erase counter header. The following codes may be returned:
  *
  * o %0 if the CRC checksum is correct and the header was successfully read;
  * o %UBI_IO_BITFLIPS if the CRC is correct, but bit-flips were detected
  *   and corrected by the flash driver; this is harmless but may indicate that
  *   this eraseblock may become bad soon (but may be not);
  * o %UBI_IO_BAD_HDR if the erase counter header is corrupted (a CRC error);
  * o %UBI_IO_BAD_HDR_EBADMSG is the same as %UBI_IO_BAD_HDR, but there also was
  *   a data integrity error (uncorrectable ECC error in case of NAND);
  * o %UBI_IO_FF if only 0xFF bytes were read (the PEB is supposedly empty)
  * o a negative error code in case of failure.
  */
 int ubi_io_read_ec_hdr(struct ubi_device *ubi, int pnum,
 		       struct ubi_ec_hdr *ec_hdr, int verbose)
 {
 	int err, read_err;
 	uint32_t crc, magic, hdr_crc;
 	dbg_io("read EC header from PEB %d", pnum);
 	ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
 	read_err = ubi_io_read(ubi, ec_hdr, pnum, 0, UBI_EC_HDR_SIZE);
 	if (read_err) {
 		if (read_err != UBI_IO_BITFLIPS && !mtd_is_eccerr(read_err))
 			return read_err;
 		/*
 		 * We read all the data, but either a correctable bit-flip
 		 * occurred, or MTD reported a data integrity error
 		 * (uncorrectable ECC error in case of NAND). The former is
 		 * harmless, the later may mean that the read data is
 		 * corrupted. But we have a CRC check-sum and we will detect
 		 * this. If the EC header is still OK, we just report this as
 		 * there was a bit-flip, to force scrubbing.
 		 */
 	}
 	magic = be32_to_cpu(ec_hdr->magic);
 	if (magic != UBI_EC_HDR_MAGIC) {
 		if (mtd_is_eccerr(read_err))
 			return UBI_IO_BAD_HDR_EBADMSG;
 		/*
 		 * The magic field is wrong. Let's check if we have read all
 		 * 0xFF. If yes, this physical eraseblock is assumed to be
 		 * empty.
 		 */
 		if (ubi_check_pattern(ec_hdr, 0xFF, UBI_EC_HDR_SIZE)) {
 			/* The physical eraseblock is supposedly empty */
 			if (verbose)
 				ubi_warn("no EC header found at PEB %d, "
 					 "only 0xFF bytes", pnum);
 			dbg_bld("no EC header found at PEB %d, "
 				"only 0xFF bytes", pnum);
 			if (!read_err)
 				return UBI_IO_FF;
 			else
 				return UBI_IO_FF_BITFLIPS;
 		}
 		/*
 		 * This is not a valid erase counter header, and these are not
 		 * 0xFF bytes. Report that the header is corrupted.
 		 */
 		if (verbose) {
 			ubi_warn("bad magic number at PEB %d: %08x instead of "
 				 "%08x", pnum, magic, UBI_EC_HDR_MAGIC);
 			ubi_dump_ec_hdr(ec_hdr);
 		}
 		dbg_bld("bad magic number at PEB %d: %08x instead of "
 			"%08x", pnum, magic, UBI_EC_HDR_MAGIC);
 		return UBI_IO_BAD_HDR;
 	}
 	crc = crc32(UBI_CRC32_INIT, ec_hdr, UBI_EC_HDR_SIZE_CRC);
 	hdr_crc = be32_to_cpu(ec_hdr->hdr_crc);
 	if (hdr_crc != crc) {
 		if (verbose) {
 			ubi_warn("bad EC header CRC at PEB %d, calculated "
 				 "%#08x, read %#08x", pnum, crc, hdr_crc);
 			ubi_dump_ec_hdr(ec_hdr);
 		}
 		dbg_bld("bad EC header CRC at PEB %d, calculated "
 			"%#08x, read %#08x", pnum, crc, hdr_crc);
 		if (!read_err)
 			return UBI_IO_BAD_HDR;
 		else
 			return UBI_IO_BAD_HDR_EBADMSG;
 	}
 	/* And of course validate what has just been read from the media */
 	err = validate_ec_hdr(ubi, ec_hdr);
 	if (err) {
 		ubi_err("validation failed for PEB %d", pnum);
 		return -EINVAL;
 	}
 	/*
 	 * If there was %-EBADMSG, but the header CRC is still OK, report about
 	 * a bit-flip to force scrubbing on this PEB.
 	 */
 	return read_err ? UBI_IO_BITFLIPS : 0;
 }
 /**
  * ubi_io_write_ec_hdr - write an erase counter header.
  * @ubi: UBI device description object
  * @pnum: physical eraseblock to write to
  * @ec_hdr: the erase counter header to write
  *
  * This function writes erase counter header described by @ec_hdr to physical
  * eraseblock @pnum. It also fills most fields of @ec_hdr before writing, so
  * the caller do not have to fill them. Callers must only fill the @ec_hdr->ec
  * field.
  *
  * This function returns zero in case of success and a negative error code in
  * case of failure. If %-EIO is returned, the physical eraseblock most probably
  * went bad.
  */
 int ubi_io_write_ec_hdr(struct ubi_device *ubi, int pnum,
 			struct ubi_ec_hdr *ec_hdr)
 {
 	int err;
 	uint32_t crc;
 	dbg_io("write EC header to PEB %d", pnum);
 	ubi_assert(pnum >= 0 &&  pnum < ubi->peb_count);
 	ec_hdr->magic = cpu_to_be32(UBI_EC_HDR_MAGIC);
 	ec_hdr->version = UBI_VERSION;
 	ec_hdr->vid_hdr_offset = cpu_to_be32(ubi->vid_hdr_offset);
 	ec_hdr->data_offset = cpu_to_be32(ubi->leb_start);
 	ec_hdr->image_seq = cpu_to_be32(ubi->image_seq);
 	crc = crc32(UBI_CRC32_INIT, ec_hdr, UBI_EC_HDR_SIZE_CRC);
 	ec_hdr->hdr_crc = cpu_to_be32(crc);
 	err = self_check_ec_hdr(ubi, pnum, ec_hdr);
 	if (err)
 		return err;
 	err = ubi_io_write(ubi, ec_hdr, pnum, 0, ubi->ec_hdr_alsize);
 	return err;
 }
 /**
  * validate_vid_hdr - validate a volume identifier header.
  * @ubi: UBI device description object
  * @vid_hdr: the volume identifier header to check
  *
  * This function checks that data stored in the volume identifier header
  * @vid_hdr. Returns zero if the VID header is OK and %1 if not.
  */
 static int validate_vid_hdr(const struct ubi_device *ubi,
 			    const struct ubi_vid_hdr *vid_hdr)
 {
 	int vol_type = vid_hdr->vol_type;
 	int copy_flag = vid_hdr->copy_flag;
 	int vol_id = be32_to_cpu(vid_hdr->vol_id);
 	int lnum = be32_to_cpu(vid_hdr->lnum);
 	int compat = vid_hdr->compat;
 	int data_size = be32_to_cpu(vid_hdr->data_size);
 	int used_ebs = be32_to_cpu(vid_hdr->used_ebs);
 	int data_pad = be32_to_cpu(vid_hdr->data_pad);
 	int data_crc = be32_to_cpu(vid_hdr->data_crc);
 	int usable_leb_size = ubi->leb_size - data_pad;
 	if (copy_flag != 0 && copy_flag != 1) {
 		ubi_err("bad copy_flag");
 		goto bad;
 	}
 	if (vol_id < 0 || lnum < 0 || data_size < 0 || used_ebs < 0 ||
 	    data_pad < 0) {
 		ubi_err("negative values");
 		goto bad;
 	}
 	if (vol_id >= UBI_MAX_VOLUMES && vol_id < UBI_INTERNAL_VOL_START) {
 		ubi_err("bad vol_id");
 		goto bad;
 	}
 	if (vol_id < UBI_INTERNAL_VOL_START && compat != 0) {
 		ubi_err("bad compat");
 		goto bad;
 	}
 	if (vol_id >= UBI_INTERNAL_VOL_START && compat != UBI_COMPAT_DELETE &&
 	    compat != UBI_COMPAT_RO && compat != UBI_COMPAT_PRESERVE &&
 	    compat != UBI_COMPAT_REJECT) {
 		ubi_err("bad compat");
 		goto bad;
 	}
 	if (vol_type != UBI_VID_DYNAMIC && vol_type != UBI_VID_STATIC) {
 		ubi_err("bad vol_type");
 		goto bad;
 	}
 	if (data_pad >= ubi->leb_size / 2) {
 		ubi_err("bad data_pad");
 		goto bad;
 	}
 	if (vol_type == UBI_VID_STATIC) {
 		/*
 		 * Although from high-level point of view static volumes may
 		 * contain zero bytes of data, but no VID headers can contain
 		 * zero at these fields, because they empty volumes do not have
 		 * mapped logical eraseblocks.
 		 */
 		if (used_ebs == 0) {
 			ubi_err("zero used_ebs");
 			goto bad;
 		}
 		if (data_size == 0) {
 			ubi_err("zero data_size");
 			goto bad;
 		}
 		if (lnum < used_ebs - 1) {
 			if (data_size != usable_leb_size) {
 				ubi_err("bad data_size");
 				goto bad;
 			}
 		} else if (lnum == used_ebs - 1) {
 			if (data_size == 0) {
 				ubi_err("bad data_size at last LEB");
 				goto bad;
 			}
 		} else {
 			ubi_err("too high lnum");
 			goto bad;
 		}
 	} else {
 		if (copy_flag == 0) {
 			if (data_crc != 0) {
 				ubi_err("non-zero data CRC");
 				goto bad;
 			}
 			if (data_size != 0) {
 				ubi_err("non-zero data_size");
 				goto bad;
 			}
 		} else {
 			if (data_size == 0) {
 				ubi_err("zero data_size of copy");
 				goto bad;
 			}
 		}
 		if (used_ebs != 0) {
 			ubi_err("bad used_ebs");
 			goto bad;
 		}
 	}
 	return 0;
 bad:
 	ubi_err("bad VID header");
 	ubi_dump_vid_hdr(vid_hdr);
 	dump_stack();
 	return 1;
 }
 /**
  * ubi_io_read_vid_hdr - read and check a volume identifier header.
  * @ubi: UBI device description object
  * @pnum: physical eraseblock number to read from
  * @vid_hdr: &struct ubi_vid_hdr object where to store the read volume
  * identifier header
  * @verbose: be verbose if the header is corrupted or wasn't found
  *
  * This function reads the volume identifier header from physical eraseblock
  * @pnum and stores it in @vid_hdr. It also checks CRC checksum of the read
  * volume identifier header. The error codes are the same as in
  * 'ubi_io_read_ec_hdr()'.
  *
  * Note, the implementation of this function is also very similar to
  * 'ubi_io_read_ec_hdr()', so refer commentaries in 'ubi_io_read_ec_hdr()'.
  */
 int ubi_io_read_vid_hdr(struct ubi_device *ubi, int pnum,
 			struct ubi_vid_hdr *vid_hdr, int verbose)
 {
 	int err, read_err;
 	uint32_t crc, magic, hdr_crc;
 	void *p;
 	dbg_io("read VID header from PEB %d", pnum);
 	ubi_assert(pnum >= 0 &&  pnum < ubi->peb_count);
 	p = (char *)vid_hdr - ubi->vid_hdr_shift;
 	read_err = ubi_io_read(ubi, p, pnum, ubi->vid_hdr_aloffset,
 			  ubi->vid_hdr_alsize);
 	if (read_err && read_err != UBI_IO_BITFLIPS && !mtd_is_eccerr(read_err))
 		return read_err;
 	magic = be32_to_cpu(vid_hdr->magic);
 	if (magic != UBI_VID_HDR_MAGIC) {
 		if (mtd_is_eccerr(read_err))
 			return UBI_IO_BAD_HDR_EBADMSG;
 		if (ubi_check_pattern(vid_hdr, 0xFF, UBI_VID_HDR_SIZE)) {
 			if (verbose)
 				ubi_warn("no VID header found at PEB %d, "
 					 "only 0xFF bytes", pnum);
 			dbg_bld("no VID header found at PEB %d, "
 				"only 0xFF bytes", pnum);
 			if (!read_err)
 				return UBI_IO_FF;
 			else
 				return UBI_IO_FF_BITFLIPS;
 		}
 		if (verbose) {
 			ubi_warn("bad magic number at PEB %d: %08x instead of "
 				 "%08x", pnum, magic, UBI_VID_HDR_MAGIC);
 			ubi_dump_vid_hdr(vid_hdr);
 		}
 		dbg_bld("bad magic number at PEB %d: %08x instead of "
 			"%08x", pnum, magic, UBI_VID_HDR_MAGIC);
 		return UBI_IO_BAD_HDR;
 	}
 	crc = crc32(UBI_CRC32_INIT, vid_hdr, UBI_VID_HDR_SIZE_CRC);
 	hdr_crc = be32_to_cpu(vid_hdr->hdr_crc);
 	if (hdr_crc != crc) {
 		if (verbose) {
 			ubi_warn("bad CRC at PEB %d, calculated %#08x, "
 				 "read %#08x", pnum, crc, hdr_crc);
 			ubi_dump_vid_hdr(vid_hdr);
 		}
 		dbg_bld("bad CRC at PEB %d, calculated %#08x, "
 			"read %#08x", pnum, crc, hdr_crc);
 		if (!read_err)
 			return UBI_IO_BAD_HDR;
 		else
 			return UBI_IO_BAD_HDR_EBADMSG;
 	}
 	err = validate_vid_hdr(ubi, vid_hdr);
 	if (err) {
 		ubi_err("validation failed for PEB %d", pnum);
 		return -EINVAL;
 	}
 	return read_err ? UBI_IO_BITFLIPS : 0;
 }
 /**
  * ubi_io_write_vid_hdr - write a volume identifier header.
  * @ubi: UBI device description object
  * @pnum: the physical eraseblock number to write to
  * @vid_hdr: the volume identifier header to write
  *
  * This function writes the volume identifier header described by @vid_hdr to
  * physical eraseblock @pnum. This function automatically fills the
  * @vid_hdr->magic and the @vid_hdr->version fields, as well as calculates
  * header CRC checksum and stores it at vid_hdr->hdr_crc.
  *
  * This function returns zero in case of success and a negative error code in
  * case of failure. If %-EIO is returned, the physical eraseblock probably went
  * bad.
  */
 int ubi_io_write_vid_hdr(struct ubi_device *ubi, int pnum,
 			 struct ubi_vid_hdr *vid_hdr)
 {
 	int err;
 	uint32_t crc;
 	void *p;
 	dbg_io("write VID header to PEB %d", pnum);
 	ubi_assert(pnum >= 0 &&  pnum < ubi->peb_count);
 	err = self_check_peb_ec_hdr(ubi, pnum);
 	if (err)
 		return err;
 	vid_hdr->magic = cpu_to_be32(UBI_VID_HDR_MAGIC);
 	vid_hdr->version = UBI_VERSION;
 	crc = crc32(UBI_CRC32_INIT, vid_hdr, UBI_VID_HDR_SIZE_CRC);
 	vid_hdr->hdr_crc = cpu_to_be32(crc);
 	err = self_check_vid_hdr(ubi, pnum, vid_hdr);
 	if (err)
 		return err;
 	p = (char *)vid_hdr - ubi->vid_hdr_shift;
 	err = ubi_io_write(ubi, p, pnum, ubi->vid_hdr_aloffset,
 			   ubi->vid_hdr_alsize);
 	return err;
 }
 /**
  * self_check_not_bad - ensure that a physical eraseblock is not bad.
  * @ubi: UBI device description object
  * @pnum: physical eraseblock number to check
  *
  * This function returns zero if the physical eraseblock is good, %-EINVAL if
  * it is bad and a negative error code if an error occurred.
  */
 static int self_check_not_bad(const struct ubi_device *ubi, int pnum)
 {
 	int err;
 	if (!ubi->dbg->chk_io)
 		return 0;
 	err = ubi_io_is_bad(ubi, pnum);
 	if (!err)
 		return err;
 	ubi_err("self-check failed for PEB %d", pnum);
 	dump_stack();
 	return err > 0 ? -EINVAL : err;
 }
 /**
  * self_check_ec_hdr - check if an erase counter header is all right.
  * @ubi: UBI device description object
  * @pnum: physical eraseblock number the erase counter header belongs to
  * @ec_hdr: the erase counter header to check
  *
  * This function returns zero if the erase counter header contains valid
  * values, and %-EINVAL if not.
  */
 static int self_check_ec_hdr(const struct ubi_device *ubi, int pnum,
 			     const struct ubi_ec_hdr *ec_hdr)
 {
 	int err;
 	uint32_t magic;
 	if (!ubi->dbg->chk_io)
 		return 0;
 	magic = be32_to_cpu(ec_hdr->magic);
 	if (magic != UBI_EC_HDR_MAGIC) {
 		ubi_err("bad magic %#08x, must be %#08x",
 			magic, UBI_EC_HDR_MAGIC);
 		goto fail;
 	}
 	err = validate_ec_hdr(ubi, ec_hdr);
 	if (err) {
 		ubi_err("self-check failed for PEB %d", pnum);
 		goto fail;
 	}
 	return 0;
 fail:
 	ubi_dump_ec_hdr(ec_hdr);
 	dump_stack();
 	return -EINVAL;
 }
 /**
  * self_check_peb_ec_hdr - check erase counter header.
  * @ubi: UBI device description object
  * @pnum: the physical eraseblock number to check
  *
  * This function returns zero if the erase counter header is all right and and
  * a negative error code if not or if an error occurred.
  */
 static int self_check_peb_ec_hdr(const struct ubi_device *ubi, int pnum)
 {
 	int err;
 	uint32_t crc, hdr_crc;
 	struct ubi_ec_hdr *ec_hdr;
 	if (!ubi->dbg->chk_io)
 		return 0;
 	ec_hdr = kzalloc(ubi->ec_hdr_alsize, GFP_NOFS);
 	if (!ec_hdr)
 		return -ENOMEM;
 	err = ubi_io_read(ubi, ec_hdr, pnum, 0, UBI_EC_HDR_SIZE);
 	if (err && err != UBI_IO_BITFLIPS && !mtd_is_eccerr(err))
 		goto exit;
 	crc = crc32(UBI_CRC32_INIT, ec_hdr, UBI_EC_HDR_SIZE_CRC);
 	hdr_crc = be32_to_cpu(ec_hdr->hdr_crc);
 	if (hdr_crc != crc) {
 		ubi_err("bad CRC, calculated %#08x, read %#08x", crc, hdr_crc);
 		ubi_err("self-check failed for PEB %d", pnum);
 		ubi_dump_ec_hdr(ec_hdr);
 		dump_stack();
 		err = -EINVAL;
 		goto exit;
 	}
 	err = self_check_ec_hdr(ubi, pnum, ec_hdr);
 exit:
 	kfree(ec_hdr);
 	return err;
 }
 /**
  * self_check_vid_hdr - check that a volume identifier header is all right.
  * @ubi: UBI device description object
  * @pnum: physical eraseblock number the volume identifier header belongs to
  * @vid_hdr: the volume identifier header to check
  *
  * This function returns zero if the volume identifier header is all right, and
  * %-EINVAL if not.
  */
 static int self_check_vid_hdr(const struct ubi_device *ubi, int pnum,
 			      const struct ubi_vid_hdr *vid_hdr)
 {
 	int err;
 	uint32_t magic;
 	if (!ubi->dbg->chk_io)
 		return 0;
 	magic = be32_to_cpu(vid_hdr->magic);
 	if (magic != UBI_VID_HDR_MAGIC) {
 		ubi_err("bad VID header magic %#08x at PEB %d, must be %#08x",
 			magic, pnum, UBI_VID_HDR_MAGIC);
 		goto fail;
 	}
 	err = validate_vid_hdr(ubi, vid_hdr);
 	if (err) {
 		ubi_err("self-check failed for PEB %d", pnum);
 		goto fail;
 	}
 	return err;
 fail:
 	ubi_err("self-check failed for PEB %d", pnum);
 	ubi_dump_vid_hdr(vid_hdr);
 	dump_stack();
 	return -EINVAL;
 }
 /**
  * self_check_peb_vid_hdr - check volume identifier header.
  * @ubi: UBI device description object
  * @pnum: the physical eraseblock number to check
  *
  * This function returns zero if the volume identifier header is all right,
  * and a negative error code if not or if an error occurred.
  */
 static int self_check_peb_vid_hdr(const struct ubi_device *ubi, int pnum)
 {
 	int err;
 	uint32_t crc, hdr_crc;
 	struct ubi_vid_hdr *vid_hdr;
 	void *p;
 	if (!ubi->dbg->chk_io)
 		return 0;
 	vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS);
 	if (!vid_hdr)
 		return -ENOMEM;
 	p = (char *)vid_hdr - ubi->vid_hdr_shift;
 	err = ubi_io_read(ubi, p, pnum, ubi->vid_hdr_aloffset,
 			  ubi->vid_hdr_alsize);
 	if (err && err != UBI_IO_BITFLIPS && !mtd_is_eccerr(err))
 		goto exit;
 	crc = crc32(UBI_CRC32_INIT, vid_hdr, UBI_EC_HDR_SIZE_CRC);
 	hdr_crc = be32_to_cpu(vid_hdr->hdr_crc);
 	if (hdr_crc != crc) {
 		ubi_err("bad VID header CRC at PEB %d, calculated %#08x, "
 			"read %#08x", pnum, crc, hdr_crc);
 		ubi_err("self-check failed for PEB %d", pnum);
 		ubi_dump_vid_hdr(vid_hdr);
 		dump_stack();
 		err = -EINVAL;
 		goto exit;
 	}
 	err = self_check_vid_hdr(ubi, pnum, vid_hdr);
 exit:
 	ubi_free_vid_hdr(ubi, vid_hdr);
 	return err;
 }
 /**
  * self_check_write - make sure write succeeded.
  * @ubi: UBI device description object
  * @buf: buffer with data which were written
  * @pnum: physical eraseblock number the data were written to
  * @offset: offset within the physical eraseblock the data were written to
  * @len: how many bytes were written
  *
  * This functions reads data which were recently written and compares it with
  * the original data buffer - the data have to match. Returns zero if the data
  * match and a negative error code if not or in case of failure.
  */
 static int self_check_write(struct ubi_device *ubi, const void *buf, int pnum,
 			    int offset, int len)
 {
 	int err, i;
 	size_t read;
 	void *buf1;
 	loff_t addr = (loff_t)pnum * ubi->peb_size + offset;
 	if (!ubi->dbg->chk_io)
 		return 0;
 	buf1 = __vmalloc(len, GFP_NOFS, PAGE_KERNEL);
 	if (!buf1) {
 		ubi_err("cannot allocate memory to check writes");
 		return 0;
 	}
 	err = mtd_read(ubi->mtd, addr, len, &read, buf1);
 	if (err && !mtd_is_bitflip(err))
 		goto out_free;
 	for (i = 0; i < len; i++) {
 		uint8_t c = ((uint8_t *)buf)[i];
 		uint8_t c1 = ((uint8_t *)buf1)[i];
 		int dump_len;
 		if (c == c1)
 			continue;
 		ubi_err("self-check failed for PEB %d:%d, len %d",
 			pnum, offset, len);
 		ubi_msg("data differ at position %d", i);
 		dump_len = max_t(int, 128, len - i);
 		ubi_msg("hex dump of the original buffer from %d to %d",
 			i, i + dump_len);
 		print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1,
 			       buf + i, dump_len, 1);
 		ubi_msg("hex dump of the read buffer from %d to %d",
 			i, i + dump_len);
 		print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1,
 			       buf1 + i, dump_len, 1);
 		dump_stack();
 		err = -EINVAL;
 		goto out_free;
 	}
 	vfree(buf1);
 	return 0;
 out_free:
 	vfree(buf1);
 	return err;
 }
 /**
  * ubi_self_check_all_ff - check that a region of flash is empty.
  * @ubi: UBI device description object
  * @pnum: the physical eraseblock number to check
  * @offset: the starting offset within the physical eraseblock to check
  * @len: the length of the region to check
  *
  * This function returns zero if only 0xFF bytes are present at offset
  * @offset of the physical eraseblock @pnum, and a negative error code if not
  * or if an error occurred.
  */
 int ubi_self_check_all_ff(struct ubi_device *ubi, int pnum, int offset, int len)
 {
 	size_t read;
 	int err;
 	void *buf;
 	loff_t addr = (loff_t)pnum * ubi->peb_size + offset;
 	if (!ubi->dbg->chk_io)
 		return 0;
 	buf = __vmalloc(len, GFP_NOFS, PAGE_KERNEL);
 	if (!buf) {
 		ubi_err("cannot allocate memory to check for 0xFFs");
 		return 0;
 	}
 	err = mtd_read(ubi->mtd, addr, len, &read, buf);
 	if (err && !mtd_is_bitflip(err)) {
 		ubi_err("error %d while reading %d bytes from PEB %d:%d, "
 			"read %zd bytes", err, len, pnum, offset, read);
 		goto error;
 	}
 	err = ubi_check_pattern(buf, 0xFF, len);
 	if (err == 0) {
 		ubi_err("flash region at PEB %d:%d, length %d does not "
 			"contain all 0xFF bytes", pnum, offset, len);
 		goto fail;
 	}
 	vfree(buf);
 	return 0;
 fail:
 	ubi_err("self-check failed for PEB %d", pnum);
 	ubi_msg("hex dump of the %d-%d region", offset, offset + len);
 	print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1, buf, len, 1);
 	err = -EINVAL;
 error:
 	dump_stack();
 	vfree(buf);
 	return err;
 }

drivers/mtd/ubi/scan.c

Diff comments View file @ fbd0107

 /*
  * Copyright (c) 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 (Битюцкий Артём)
  */
 /*
- * UBI scanning sub-system.
+ * UBI attaching sub-system.
  *
- * This sub-system is responsible for scanning the flash media, checking UBI
+ * This sub-system is responsible for attaching MTD devices and it also
- * headers and providing complete information about the UBI flash image.
+ * implements flash media scanning.
  *
  * The attaching information is represented by a &struct ubi_attach_info'
- * object. Information about found volumes is represented by
+ * object. Information about volumes is represented by &struct ubi_ainf_volume
- * &struct ubi_ainf_volume objects which are kept in volume RB-tree with root
+ * objects which are kept in volume RB-tree with root at the @volumes field.
- * at the @volumes field. The RB-tree is indexed by the volume ID.
+ * The RB-tree is indexed by the volume ID.
  *
- * Scanned logical eraseblocks are represented by &struct ubi_ainf_peb objects.
+ * Logical eraseblocks are represented by &struct ubi_ainf_peb objects. These
- * These objects are kept in per-volume RB-trees with the root at the
+ * objects are kept in per-volume RB-trees with the root at the corresponding
- * corresponding &struct ubi_ainf_volume object. To put it differently, we keep
+ * &struct ubi_ainf_volume object. To put it differently, we keep an RB-tree of
- * an RB-tree of per-volume objects and each of these objects is the root of
+ * per-volume objects and each of these objects is the root of RB-tree of
- * RB-tree of per-eraseblock objects.
+ * per-LEB objects.
  *
  * Corrupted physical eraseblocks are put to the @corr list, free physical
  * eraseblocks are put to the @free list and the physical eraseblock to be
  * erased are put to the @erase list.
  *
  * About corruptions
  * ~~~~~~~~~~~~~~~~~
  *
  * UBI protects EC and VID headers with CRC-32 checksums, so it can detect
  * whether the headers are corrupted or not. Sometimes UBI also protects the
  * data with CRC-32, e.g., when it executes the atomic LEB change operation, or
  * when it moves the contents of a PEB for wear-leveling purposes.
  *
  * UBI tries to distinguish between 2 types of corruptions.
  *
  * 1. Corruptions caused by power cuts. These are expected corruptions and UBI
  * tries to handle them gracefully, without printing too many warnings and
- * error messages. The idea is that we do not lose important data in these case
+ * error messages. The idea is that we do not lose important data in these
- * - we may lose only the data which was being written to the media just before
+ * cases - we may lose only the data which were being written to the media just
- * the power cut happened, and the upper layers (e.g., UBIFS) are supposed to
+ * before the power cut happened, and the upper layers (e.g., UBIFS) are
- * handle such data losses (e.g., by using the FS journal).
+ * supposed to handle such data losses (e.g., by using the FS journal).
  *
  * When UBI detects a corruption (CRC-32 mismatch) in a PEB, and it looks like
  * the reason is a power cut, UBI puts this PEB to the @erase list, and all
  * PEBs in the @erase list are scheduled for erasure later.
  *
  * 2. Unexpected corruptions which are not caused by power cuts. During
- * scanning, such PEBs are put to the @corr list and UBI preserves them.
+ * attaching, such PEBs are put to the @corr list and UBI preserves them.
  * Obviously, this lessens the amount of available PEBs, and if at some  point
  * UBI runs out of free PEBs, it switches to R/O mode. UBI also loudly informs
  * about such PEBs every time the MTD device is attached.
  *
  * However, it is difficult to reliably distinguish between these types of
- * corruptions and UBI's strategy is as follows. UBI assumes corruption type 2
+ * corruptions and UBI's strategy is as follows (in case of attaching by
- * if the VID header is corrupted and the data area does not contain all 0xFFs,
+ * scanning). UBI assumes corruption type 2 if the VID header is corrupted and
- * and there were no bit-flips or integrity errors while reading the data area.
+ * the data area does not contain all 0xFFs, and there were no bit-flips or
- * Otherwise UBI assumes corruption type 1. So the decision criteria are as
+ * integrity errors (e.g., ECC errors in case of NAND) while reading the data
- * follows.
+ * area.  Otherwise UBI assumes corruption type 1. So the decision criteria
- *   o If the data area contains only 0xFFs, there is no data, and it is safe
+ * are as follows.
+ *   o If the data area contains only 0xFFs, there are no data, and it is safe
  *     to just erase this PEB - this is corruption type 1.
  *   o If the data area has bit-flips or data integrity errors (ECC errors on
  *     NAND), it is probably a PEB which was being erased when power cut
  *     happened, so this is corruption type 1. However, this is just a guess,
  *     which might be wrong.
  *   o Otherwise this it corruption type 2.
  */
 #include <linux/err.h>
 #include <linux/slab.h>
 #include <linux/crc32.h>
 #include <linux/math64.h>
 #include <linux/random.h>
 #include "ubi.h"
 static int self_check_ai(struct ubi_device *ubi, struct ubi_attach_info *ai);
 /* Temporary variables used during scanning */
 static struct ubi_ec_hdr *ech;
 static struct ubi_vid_hdr *vidh;
 /**
  * add_to_list - add physical eraseblock to a list.
  * @ai: attaching information
  * @pnum: physical eraseblock number to add
  * @ec: erase counter of the physical eraseblock
  * @to_head: if not zero, add to the head of the list
  * @list: the list to add to
  *
- * This function adds physical eraseblock @pnum to free, erase, or alien lists.
+ * This function allocates a 'struct ubi_ainf_peb' object for physical
+ * eraseblock @pnum and adds it to the "free", "erase", or "alien" lists.
  * If @to_head is not zero, PEB will be added to the head of the list, which
  * basically means it will be processed first later. E.g., we add corrupted
  * PEBs (corrupted due to power cuts) to the head of the erase list to make
  * sure we erase them first and get rid of corruptions ASAP. This function
  * returns zero in case of success and a negative error code in case of
  * failure.
  */
 static int add_to_list(struct ubi_attach_info *ai, int pnum, int ec,
 		       int to_head, struct list_head *list)
 {
 	struct ubi_ainf_peb *aeb;
 	if (list == &ai->free) {
 		dbg_bld("add to free: PEB %d, EC %d", pnum, ec);
 	} else if (list == &ai->erase) {
 		dbg_bld("add to erase: PEB %d, EC %d", pnum, ec);
 	} else if (list == &ai->alien) {
 		dbg_bld("add to alien: PEB %d, EC %d", pnum, ec);
 		ai->alien_peb_count += 1;
 	} else
 		BUG();
 	aeb = kmem_cache_alloc(ai->aeb_slab_cache, GFP_KERNEL);
 	if (!aeb)
 		return -ENOMEM;
 	aeb->pnum = pnum;
 	aeb->ec = ec;
 	if (to_head)
 		list_add(&aeb->u.list, list);
 	else
 		list_add_tail(&aeb->u.list, list);
 	return 0;
 }
 /**
  * add_corrupted - add a corrupted physical eraseblock.
  * @ai: attaching information
  * @pnum: physical eraseblock number to add
  * @ec: erase counter of the physical eraseblock
  *
- * This function adds corrupted physical eraseblock @pnum to the 'corr' list.
+ * This function allocates a 'struct ubi_ainf_peb' object for a corrupted
- * The corruption was presumably not caused by a power cut. Returns zero in
+ * physical eraseblock @pnum and adds it to the 'corr' list.  The corruption
- * case of success and a negative error code in case of failure.
+ * was presumably not caused by a power cut. Returns zero in case of success
+ * and a negative error code in case of failure.
  */
 static int add_corrupted(struct ubi_attach_info *ai, int pnum, int ec)
 {
 	struct ubi_ainf_peb *aeb;
 	dbg_bld("add to corrupted: PEB %d, EC %d", pnum, ec);
 	aeb = kmem_cache_alloc(ai->aeb_slab_cache, GFP_KERNEL);
 	if (!aeb)
 		return -ENOMEM;
 	ai->corr_peb_count += 1;
 	aeb->pnum = pnum;
 	aeb->ec = ec;
 	list_add(&aeb->u.list, &ai->corr);
 	return 0;
 }
 /**
  * validate_vid_hdr - check volume identifier header.
  * @vid_hdr: the volume identifier header to check
  * @av: information about the volume this logical eraseblock belongs to
  * @pnum: physical eraseblock number the VID header came from
  *
  * This function checks that data stored in @vid_hdr is consistent. Returns
  * non-zero if an inconsistency was found and zero if not.
  *
  * Note, UBI does sanity check of everything it reads from the flash media.
  * Most of the checks are done in the I/O sub-system. Here we check that the
  * information in the VID header is consistent to the information in other VID
  * headers of the same volume.
  */
 static int validate_vid_hdr(const struct ubi_vid_hdr *vid_hdr,
 			    const struct ubi_ainf_volume *av, int pnum)
 {
 	int vol_type = vid_hdr->vol_type;
 	int vol_id = be32_to_cpu(vid_hdr->vol_id);
 	int used_ebs = be32_to_cpu(vid_hdr->used_ebs);
 	int data_pad = be32_to_cpu(vid_hdr->data_pad);
 	if (av->leb_count != 0) {
 		int av_vol_type;
 		/*
 		 * This is not the first logical eraseblock belonging to this
 		 * volume. Ensure that the data in its VID header is consistent
 		 * to the data in previous logical eraseblock headers.
 		 */
 		if (vol_id != av->vol_id) {
 			ubi_err("inconsistent vol_id");
 			goto bad;
 		}
 		if (av->vol_type == UBI_STATIC_VOLUME)
 			av_vol_type = UBI_VID_STATIC;
 		else
 			av_vol_type = UBI_VID_DYNAMIC;
 		if (vol_type != av_vol_type) {
 			ubi_err("inconsistent vol_type");
 			goto bad;
 		}
 		if (used_ebs != av->used_ebs) {
 			ubi_err("inconsistent used_ebs");
 			goto bad;
 		}
 		if (data_pad != av->data_pad) {
 			ubi_err("inconsistent data_pad");
 			goto bad;
 		}
 	}
 	return 0;
 bad:
 	ubi_err("inconsistent VID header at PEB %d", pnum);
 	ubi_dump_vid_hdr(vid_hdr);
 	ubi_dump_av(av);
 	return -EINVAL;
 }
 /**
  * add_volume - add volume to the attaching information.
  * @ai: attaching information
  * @vol_id: ID of the volume to add
  * @pnum: physical eraseblock number
  * @vid_hdr: volume identifier header
  *
  * If the volume corresponding to the @vid_hdr logical eraseblock is already
  * present in the attaching information, this function does nothing. Otherwise
  * it adds corresponding volume to the attaching information. Returns a pointer
- * to the scanning volume object in case of success and a negative error code
+ * to the allocated "av" object in case of success and a negative error code in
- * in case of failure.
+ * case of failure.
  */
 static struct ubi_ainf_volume *add_volume(struct ubi_attach_info *ai,
 					  int vol_id, int pnum,
 					  const struct ubi_vid_hdr *vid_hdr)
 {
 	struct ubi_ainf_volume *av;
 	struct rb_node **p = &ai->volumes.rb_node, *parent = NULL;
 	ubi_assert(vol_id == be32_to_cpu(vid_hdr->vol_id));
 	/* Walk the volume RB-tree to look if this volume is already present */
 	while (*p) {
 		parent = *p;
 		av = rb_entry(parent, struct ubi_ainf_volume, rb);
 		if (vol_id == av->vol_id)
 			return av;
 		if (vol_id > av->vol_id)
 			p = &(*p)->rb_left;
 		else
 			p = &(*p)->rb_right;
 	}
 	/* The volume is absent - add it */
 	av = kmalloc(sizeof(struct ubi_ainf_volume), GFP_KERNEL);
 	if (!av)
 		return ERR_PTR(-ENOMEM);
 	av->highest_lnum = av->leb_count = 0;
 	av->vol_id = vol_id;
 	av->root = RB_ROOT;
 	av->used_ebs = be32_to_cpu(vid_hdr->used_ebs);
 	av->data_pad = be32_to_cpu(vid_hdr->data_pad);
 	av->compat = vid_hdr->compat;
 	av->vol_type = vid_hdr->vol_type == UBI_VID_DYNAMIC ? UBI_DYNAMIC_VOLUME
 							    : UBI_STATIC_VOLUME;
 	if (vol_id > ai->highest_vol_id)
 		ai->highest_vol_id = vol_id;
 	rb_link_node(&av->rb, parent, p);
 	rb_insert_color(&av->rb, &ai->volumes);
 	ai->vols_found += 1;
 	dbg_bld("added volume %d", vol_id);
 	return av;
 }
 /**
  * compare_lebs - find out which logical eraseblock is newer.
  * @ubi: UBI device description object
  * @aeb: first logical eraseblock to compare
  * @pnum: physical eraseblock number of the second logical eraseblock to
  * compare
  * @vid_hdr: volume identifier header of the second logical eraseblock
  *
  * This function compares 2 copies of a LEB and informs which one is newer. In
  * case of success this function returns a positive value, in case of failure, a
  * negative error code is returned. The success return codes use the following
  * bits:
  *     o bit 0 is cleared: the first PEB (described by @aeb) is newer than the
  *       second PEB (described by @pnum and @vid_hdr);
  *     o bit 0 is set: the second PEB is newer;
  *     o bit 1 is cleared: no bit-flips were detected in the newer LEB;
  *     o bit 1 is set: bit-flips were detected in the newer LEB;
  *     o bit 2 is cleared: the older LEB is not corrupted;
  *     o bit 2 is set: the older LEB is corrupted.
  */
 static int compare_lebs(struct ubi_device *ubi, const struct ubi_ainf_peb *aeb,
 			int pnum, const struct ubi_vid_hdr *vid_hdr)
 {
 	void *buf;
 	int len, err, second_is_newer, bitflips = 0, corrupted = 0;
 	uint32_t data_crc, crc;
 	struct ubi_vid_hdr *vh = NULL;
 	unsigned long long sqnum2 = be64_to_cpu(vid_hdr->sqnum);
 	if (sqnum2 == aeb->sqnum) {
 		/*
 		 * This must be a really ancient UBI image which has been
 		 * created before sequence numbers support has been added. At
 		 * that times we used 32-bit LEB versions stored in logical
 		 * eraseblocks. That was before UBI got into mainline. We do not
 		 * support these images anymore. Well, those images still work,
 		 * but only if no unclean reboots happened.
 		 */
 		ubi_err("unsupported on-flash UBI format\n");
 		return -EINVAL;
 	}
 	/* Obviously the LEB with lower sequence counter is older */
 	second_is_newer = (sqnum2 > aeb->sqnum);
 	/*
 	 * Now we know which copy is newer. If the copy flag of the PEB with
 	 * newer version is not set, then we just return, otherwise we have to
 	 * check data CRC. For the second PEB we already have the VID header,
 	 * for the first one - we'll need to re-read it from flash.
 	 *
 	 * Note: this may be optimized so that we wouldn't read twice.
 	 */
 	if (second_is_newer) {
 		if (!vid_hdr->copy_flag) {
 			/* It is not a copy, so it is newer */
 			dbg_bld("second PEB %d is newer, copy_flag is unset",
 				pnum);
 			return 1;
 		}
 	} else {
 		if (!aeb->copy_flag) {
 			/* It is not a copy, so it is newer */
 			dbg_bld("first PEB %d is newer, copy_flag is unset",
 				pnum);
 			return bitflips << 1;
 		}
 		vh = ubi_zalloc_vid_hdr(ubi, GFP_KERNEL);
 		if (!vh)
 			return -ENOMEM;
 		pnum = aeb->pnum;
 		err = ubi_io_read_vid_hdr(ubi, pnum, vh, 0);
 		if (err) {
 			if (err == UBI_IO_BITFLIPS)
 				bitflips = 1;
 			else {
 				ubi_err("VID of PEB %d header is bad, but it "
 					"was OK earlier, err %d", pnum, err);
 				if (err > 0)
 					err = -EIO;
 				goto out_free_vidh;
 			}
 		}
 		vid_hdr = vh;
 	}
 	/* Read the data of the copy and check the CRC */
 	len = be32_to_cpu(vid_hdr->data_size);
 	buf = vmalloc(len);
 	if (!buf) {
 		err = -ENOMEM;
 		goto out_free_vidh;
 	}
 	err = ubi_io_read_data(ubi, buf, pnum, 0, len);
 	if (err && err != UBI_IO_BITFLIPS && !mtd_is_eccerr(err))
 		goto out_free_buf;
 	data_crc = be32_to_cpu(vid_hdr->data_crc);
 	crc = crc32(UBI_CRC32_INIT, buf, len);
 	if (crc != data_crc) {
 		dbg_bld("PEB %d CRC error: calculated %#08x, must be %#08x",
 			pnum, crc, data_crc);
 		corrupted = 1;
 		bitflips = 0;
 		second_is_newer = !second_is_newer;
 	} else {
 		dbg_bld("PEB %d CRC is OK", pnum);
 		bitflips = !!err;
 	}
 	vfree(buf);
 	ubi_free_vid_hdr(ubi, vh);
 	if (second_is_newer)
 		dbg_bld("second PEB %d is newer, copy_flag is set", pnum);
 	else
 		dbg_bld("first PEB %d is newer, copy_flag is set", pnum);
 	return second_is_newer | (bitflips << 1) | (corrupted << 2);
 out_free_buf:
 	vfree(buf);
 out_free_vidh:
 	ubi_free_vid_hdr(ubi, vh);
 	return err;
 }
 /**
- * ubi_add_to_av - add physical eraseblock to the attaching information.
+ * ubi_add_to_av - add used physical eraseblock to the attaching information.
  * @ubi: UBI device description object
  * @ai: attaching information
  * @pnum: the physical eraseblock number
  * @ec: erase counter
  * @vid_hdr: the volume identifier header
  * @bitflips: if bit-flips were detected when this physical eraseblock was read
  *
  * This function adds information about a used physical eraseblock to the
  * 'used' tree of the corresponding volume. The function is rather complex
  * because it has to handle cases when this is not the first physical
  * eraseblock belonging to the same logical eraseblock, and the newer one has
  * to be picked, while the older one has to be dropped. This function returns
  * zero in case of success and a negative error code in case of failure.
  */
 int ubi_add_to_av(struct ubi_device *ubi, struct ubi_attach_info *ai, int pnum,
 		  int ec, const struct ubi_vid_hdr *vid_hdr, int bitflips)
 {
 	int err, vol_id, lnum;
 	unsigned long long sqnum;
 	struct ubi_ainf_volume *av;
 	struct ubi_ainf_peb *aeb;
 	struct rb_node **p, *parent = NULL;
 	vol_id = be32_to_cpu(vid_hdr->vol_id);
 	lnum = be32_to_cpu(vid_hdr->lnum);
 	sqnum = be64_to_cpu(vid_hdr->sqnum);
 	dbg_bld("PEB %d, LEB %d:%d, EC %d, sqnum %llu, bitflips %d",
 		pnum, vol_id, lnum, ec, sqnum, bitflips);
 	av = add_volume(ai, vol_id, pnum, vid_hdr);
 	if (IS_ERR(av))
 		return PTR_ERR(av);
 	if (ai->max_sqnum < sqnum)
 		ai->max_sqnum = sqnum;
 	/*
 	 * Walk the RB-tree of logical eraseblocks of volume @vol_id to look
 	 * if this is the first instance of this logical eraseblock or not.
 	 */
 	p = &av->root.rb_node;
 	while (*p) {
 		int cmp_res;
 		parent = *p;
 		aeb = rb_entry(parent, struct ubi_ainf_peb, u.rb);
 		if (lnum != aeb->lnum) {
 			if (lnum < aeb->lnum)
 				p = &(*p)->rb_left;
 			else
 				p = &(*p)->rb_right;
 			continue;
 		}
 		/*
 		 * There is already a physical eraseblock describing the same
 		 * logical eraseblock present.
 		 */
 		dbg_bld("this LEB already exists: PEB %d, sqnum %llu, EC %d",
 			aeb->pnum, aeb->sqnum, aeb->ec);
 		/*
 		 * Make sure that the logical eraseblocks have different
 		 * sequence numbers. Otherwise the image is bad.
 		 *
 		 * However, if the sequence number is zero, we assume it must
 		 * be an ancient UBI image from the era when UBI did not have
 		 * sequence numbers. We still can attach these images, unless
 		 * there is a need to distinguish between old and new
 		 * eraseblocks, in which case we'll refuse the image in
 		 * 'compare_lebs()'. In other words, we attach old clean
 		 * images, but refuse attaching old images with duplicated
 		 * logical eraseblocks because there was an unclean reboot.
 		 */
 		if (aeb->sqnum == sqnum && sqnum != 0) {
 			ubi_err("two LEBs with same sequence number %llu",
 				sqnum);
 			ubi_dump_aeb(aeb, 0);
 			ubi_dump_vid_hdr(vid_hdr);
 			return -EINVAL;
 		}
 		/*
 		 * Now we have to drop the older one and preserve the newer
 		 * one.
 		 */
 		cmp_res = compare_lebs(ubi, aeb, pnum, vid_hdr);
 		if (cmp_res < 0)
 			return cmp_res;
 		if (cmp_res & 1) {
 			/*
 			 * This logical eraseblock is newer than the one
 			 * found earlier.
 			 */
 			err = validate_vid_hdr(vid_hdr, av, pnum);
 			if (err)
 				return err;
 			err = add_to_list(ai, aeb->pnum, aeb->ec, cmp_res & 4,
 					  &ai->erase);
 			if (err)
 				return err;
 			aeb->ec = ec;
 			aeb->pnum = pnum;
 			aeb->scrub = ((cmp_res & 2) || bitflips);
 			aeb->copy_flag = vid_hdr->copy_flag;
 			aeb->sqnum = sqnum;
 			if (av->highest_lnum == lnum)
 				av->last_data_size =
 					be32_to_cpu(vid_hdr->data_size);
 			return 0;
 		} else {
 			/*
 			 * This logical eraseblock is older than the one found
 			 * previously.
 			 */
 			return add_to_list(ai, pnum, ec, cmp_res & 4,
 					   &ai->erase);
 		}
 	}
 	/*
 	 * We've met this logical eraseblock for the first time, add it to the
 	 * attaching information.
 	 */
 	err = validate_vid_hdr(vid_hdr, av, pnum);
 	if (err)
 		return err;
 	aeb = kmem_cache_alloc(ai->aeb_slab_cache, GFP_KERNEL);
 	if (!aeb)
 		return -ENOMEM;
 	aeb->ec = ec;
 	aeb->pnum = pnum;
 	aeb->lnum = lnum;
 	aeb->scrub = bitflips;
 	aeb->copy_flag = vid_hdr->copy_flag;
 	aeb->sqnum = sqnum;
 	if (av->highest_lnum <= lnum) {
 		av->highest_lnum = lnum;
 		av->last_data_size = be32_to_cpu(vid_hdr->data_size);
 	}
 	av->leb_count += 1;
 	rb_link_node(&aeb->u.rb, parent, p);
 	rb_insert_color(&aeb->u.rb, &av->root);
 	return 0;
 }
 /**
  * ubi_find_av - find volume in the attaching information.
  * @ai: attaching information
  * @vol_id: the requested volume ID
  *
  * This function returns a pointer to the volume description or %NULL if there
  * are no data about this volume in the attaching information.
  */
 struct ubi_ainf_volume *ubi_find_av(const struct ubi_attach_info *ai,
 				    int vol_id)
 {
 	struct ubi_ainf_volume *av;
 	struct rb_node *p = ai->volumes.rb_node;
 	while (p) {
 		av = rb_entry(p, struct ubi_ainf_volume, rb);
 		if (vol_id == av->vol_id)
 			return av;
 		if (vol_id > av->vol_id)
 			p = p->rb_left;
 		else
 			p = p->rb_right;
 	}
 	return NULL;
 }
 /**
  * ubi_remove_av - delete attaching information about a volume.
  * @ai: attaching information
  * @av: the volume attaching information to delete
  */
 void ubi_remove_av(struct ubi_attach_info *ai, struct ubi_ainf_volume *av)
 {
 	struct rb_node *rb;
 	struct ubi_ainf_peb *aeb;
 	dbg_bld("remove attaching information about volume %d", av->vol_id);
 	while ((rb = rb_first(&av->root))) {
 		aeb = rb_entry(rb, struct ubi_ainf_peb, u.rb);
 		rb_erase(&aeb->u.rb, &av->root);
 		list_add_tail(&aeb->u.list, &ai->erase);
 	}
 	rb_erase(&av->rb, &ai->volumes);
 	kfree(av);
 	ai->vols_found -= 1;
 }
 /**
  * early_erase_peb - erase a physical eraseblock.
  * @ubi: UBI device description object
  * @ai: attaching information
  * @pnum: physical eraseblock number to erase;
  * @ec: erase counter value to write (%UBI_SCAN_UNKNOWN_EC if it is unknown)
  *
  * This function erases physical eraseblock 'pnum', and writes the erase
  * counter header to it. This function should only be used on UBI device
  * initialization stages, when the EBA sub-system had not been yet initialized.
  * This function returns zero in case of success and a negative error code in
  * case of failure.
  */
 static int early_erase_peb(struct ubi_device *ubi,
 			   const struct ubi_attach_info *ai, int pnum, int ec)
 {
 	int err;
 	struct ubi_ec_hdr *ec_hdr;
 	if ((long long)ec >= UBI_MAX_ERASECOUNTER) {
 		/*
 		 * Erase counter overflow. Upgrade UBI and use 64-bit
 		 * erase counters internally.
 		 */
 		ubi_err("erase counter overflow at PEB %d, EC %d", pnum, ec);
 		return -EINVAL;
 	}
 	ec_hdr = kzalloc(ubi->ec_hdr_alsize, GFP_KERNEL);
 	if (!ec_hdr)
 		return -ENOMEM;
 	ec_hdr->ec = cpu_to_be64(ec);
 	err = ubi_io_sync_erase(ubi, pnum, 0);
 	if (err < 0)
 		goto out_free;
 	err = ubi_io_write_ec_hdr(ubi, pnum, ec_hdr);
 out_free:
 	kfree(ec_hdr);
 	return err;
 }
 /**
  * ubi_early_get_peb - get a free physical eraseblock.
  * @ubi: UBI device description object
  * @ai: attaching information
  *
  * This function returns a free physical eraseblock. It is supposed to be
  * called on the UBI initialization stages when the wear-leveling sub-system is
  * not initialized yet. This function picks a physical eraseblocks from one of
  * the lists, writes the EC header if it is needed, and removes it from the
  * list.
  *
- * This function returns scanning physical eraseblock information in case of
+ * This function returns a pointer to the "aeb" of the found free PEB in case
- * success and an error code in case of failure.
+ * of success and an error code in case of failure.
  */
 struct ubi_ainf_peb *ubi_early_get_peb(struct ubi_device *ubi,
 				       struct ubi_attach_info *ai)
 {
 	int err = 0;
 	struct ubi_ainf_peb *aeb, *tmp_aeb;
 	if (!list_empty(&ai->free)) {
 		aeb = list_entry(ai->free.next, struct ubi_ainf_peb, u.list);
 		list_del(&aeb->u.list);
 		dbg_bld("return free PEB %d, EC %d", aeb->pnum, aeb->ec);
 		return aeb;
 	}
 	/*
 	 * We try to erase the first physical eraseblock from the erase list
 	 * and pick it if we succeed, or try to erase the next one if not. And
 	 * so forth. We don't want to take care about bad eraseblocks here -
 	 * they'll be handled later.
 	 */
 	list_for_each_entry_safe(aeb, tmp_aeb, &ai->erase, u.list) {
 		if (aeb->ec == UBI_SCAN_UNKNOWN_EC)
 			aeb->ec = ai->mean_ec;
 		err = early_erase_peb(ubi, ai, aeb->pnum, aeb->ec+1);
 		if (err)
 			continue;
 		aeb->ec += 1;
 		list_del(&aeb->u.list);
 		dbg_bld("return PEB %d, EC %d", aeb->pnum, aeb->ec);
 		return aeb;
 	}
 	ubi_err("no free eraseblocks");
 	return ERR_PTR(-ENOSPC);
 }
 /**
  * check_corruption - check the data area of PEB.
  * @ubi: UBI device description object
  * @vid_hrd: the (corrupted) VID header of this PEB
  * @pnum: the physical eraseblock number to check
  *
  * This is a helper function which is used to distinguish between VID header
  * corruptions caused by power cuts and other reasons. If the PEB contains only
  * 0xFF bytes in the data area, the VID header is most probably corrupted
  * because of a power cut (%0 is returned in this case). Otherwise, it was
  * probably corrupted for some other reasons (%1 is returned in this case). A
  * negative error code is returned if a read error occurred.
  *
  * If the corruption reason was a power cut, UBI can safely erase this PEB.
  * Otherwise, it should preserve it to avoid possibly destroying important
  * information.
  */
 static int check_corruption(struct ubi_device *ubi, struct ubi_vid_hdr *vid_hdr,
 			    int pnum)
 {
 	int err;
 	mutex_lock(&ubi->buf_mutex);
 	memset(ubi->peb_buf, 0x00, ubi->leb_size);
 	err = ubi_io_read(ubi, ubi->peb_buf, pnum, ubi->leb_start,
 			  ubi->leb_size);
 	if (err == UBI_IO_BITFLIPS || mtd_is_eccerr(err)) {
 		/*
 		 * Bit-flips or integrity errors while reading the data area.
 		 * It is difficult to say for sure what type of corruption is
 		 * this, but presumably a power cut happened while this PEB was
 		 * erased, so it became unstable and corrupted, and should be
 		 * erased.
 		 */
 		err = 0;
 		goto out_unlock;
 	}
 	if (err)
 		goto out_unlock;
 	if (ubi_check_pattern(ubi->peb_buf, 0xFF, ubi->leb_size))
 		goto out_unlock;
 	ubi_err("PEB %d contains corrupted VID header, and the data does not "
 		"contain all 0xFF, this may be a non-UBI PEB or a severe VID "
 		"header corruption which requires manual inspection", pnum);
 	ubi_dump_vid_hdr(vid_hdr);
 	dbg_msg("hexdump of PEB %d offset %d, length %d",
 		pnum, ubi->leb_start, ubi->leb_size);
 	ubi_dbg_print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1,
 			       ubi->peb_buf, ubi->leb_size, 1);
 	err = 1;
 out_unlock:
 	mutex_unlock(&ubi->buf_mutex);
 	return err;
 }
 /**
- * process_eb - read, check UBI headers, and add them to attaching information.
+ * scan_peb - scan and process UBI headers of a PEB.
  * @ubi: UBI device description object
  * @ai: attaching information
  * @pnum: the physical eraseblock number
  *
- * This function returns a zero if the physical eraseblock was successfully
+ * This function reads UBI headers of PEB @pnum, checks them, and adds
- * handled and a negative error code in case of failure.
+ * information about this PEB to the corresponding list or RB-tree in the
+ * "attaching info" structure. Returns zero if the physical eraseblock was
+ * successfully handled and a negative error code in case of failure.
  */
-static int process_eb(struct ubi_device *ubi, struct ubi_attach_info *ai,
+static int scan_peb(struct ubi_device *ubi, struct ubi_attach_info *ai,
-		      int pnum)
+		    int pnum)
 {
 	long long uninitialized_var(ec);
 	int err, bitflips = 0, vol_id, ec_err = 0;
 	dbg_bld("scan PEB %d", pnum);
 	/* Skip bad physical eraseblocks */
 	err = ubi_io_is_bad(ubi, pnum);
 	if (err < 0)
 		return err;
 	else if (err) {
-		/*
-		 * FIXME: this is actually duty of the I/O sub-system to
-		 * initialize this, but MTD does not provide enough
-		 * information.
-		 */
 		ai->bad_peb_count += 1;
 		return 0;
 	}
 	err = ubi_io_read_ec_hdr(ubi, pnum, ech, 0);
 	if (err < 0)
 		return err;
 	switch (err) {
 	case 0:
 		break;
 	case UBI_IO_BITFLIPS:
 		bitflips = 1;
 		break;
 	case UBI_IO_FF:
 		ai->empty_peb_count += 1;
 		return add_to_list(ai, pnum, UBI_SCAN_UNKNOWN_EC, 0,
 				   &ai->erase);
 	case UBI_IO_FF_BITFLIPS:
 		ai->empty_peb_count += 1;
 		return add_to_list(ai, pnum, UBI_SCAN_UNKNOWN_EC, 1,
 				   &ai->erase);
 	case UBI_IO_BAD_HDR_EBADMSG:
 	case UBI_IO_BAD_HDR:
 		/*
 		 * We have to also look at the VID header, possibly it is not
 		 * corrupted. Set %bitflips flag in order to make this PEB be
 		 * moved and EC be re-created.
 		 */
 		ec_err = err;
 		ec = UBI_SCAN_UNKNOWN_EC;
 		bitflips = 1;
 		break;
 	default:
 		ubi_err("'ubi_io_read_ec_hdr()' returned unknown code %d", err);
 		return -EINVAL;
 	}
 	if (!ec_err) {
 		int image_seq;
 		/* Make sure UBI version is OK */
 		if (ech->version != UBI_VERSION) {
 			ubi_err("this UBI version is %d, image version is %d",
 				UBI_VERSION, (int)ech->version);
 			return -EINVAL;
 		}
 		ec = be64_to_cpu(ech->ec);
 		if (ec > UBI_MAX_ERASECOUNTER) {
 			/*
 			 * Erase counter overflow. The EC headers have 64 bits
 			 * reserved, but we anyway make use of only 31 bit
 			 * values, as this seems to be enough for any existing
 			 * flash. Upgrade UBI and use 64-bit erase counters
 			 * internally.
 			 */
 			ubi_err("erase counter overflow, max is %d",
 				UBI_MAX_ERASECOUNTER);
 			ubi_dump_ec_hdr(ech);
 			return -EINVAL;
 		}
 		/*
 		 * Make sure that all PEBs have the same image sequence number.
 		 * This allows us to detect situations when users flash UBI
 		 * images incorrectly, so that the flash has the new UBI image
 		 * and leftovers from the old one. This feature was added
 		 * relatively recently, and the sequence number was always
 		 * zero, because old UBI implementations always set it to zero.
 		 * For this reasons, we do not panic if some PEBs have zero
 		 * sequence number, while other PEBs have non-zero sequence
 		 * number.
 		 */
 		image_seq = be32_to_cpu(ech->image_seq);
 		if (!ubi->image_seq && image_seq)
 			ubi->image_seq = image_seq;
 		if (ubi->image_seq && image_seq &&
 		    ubi->image_seq != image_seq) {
 			ubi_err("bad image sequence number %d in PEB %d, "
 				"expected %d", image_seq, pnum, ubi->image_seq);
 			ubi_dump_ec_hdr(ech);
 			return -EINVAL;
 		}
 	}
 	/* OK, we've done with the EC header, let's look at the VID header */
 	err = ubi_io_read_vid_hdr(ubi, pnum, vidh, 0);
 	if (err < 0)
 		return err;
 	switch (err) {
 	case 0:
 		break;
 	case UBI_IO_BITFLIPS:
 		bitflips = 1;
 		break;
 	case UBI_IO_BAD_HDR_EBADMSG:
 		if (ec_err == UBI_IO_BAD_HDR_EBADMSG)
 			/*
 			 * Both EC and VID headers are corrupted and were read
 			 * with data integrity error, probably this is a bad
 			 * PEB, bit it is not marked as bad yet. This may also
 			 * be a result of power cut during erasure.
 			 */
 			ai->maybe_bad_peb_count += 1;
 	case UBI_IO_BAD_HDR:
 		if (ec_err)
 			/*
 			 * Both headers are corrupted. There is a possibility
 			 * that this a valid UBI PEB which has corresponding
 			 * LEB, but the headers are corrupted. However, it is
 			 * impossible to distinguish it from a PEB which just
 			 * contains garbage because of a power cut during erase
 			 * operation. So we just schedule this PEB for erasure.
 			 *
 			 * Besides, in case of NOR flash, we deliberately
 			 * corrupt both headers because NOR flash erasure is
 			 * slow and can start from the end.
 			 */
 			err = 0;
 		else
 			/*
 			 * The EC was OK, but the VID header is corrupted. We
 			 * have to check what is in the data area.
 			 */
 			err = check_corruption(ubi, vidh, pnum);
 		if (err < 0)
 			return err;
 		else if (!err)
 			/* This corruption is caused by a power cut */
 			err = add_to_list(ai, pnum, ec, 1, &ai->erase);
 		else
 			/* This is an unexpected corruption */
 			err = add_corrupted(ai, pnum, ec);
 		if (err)
 			return err;
 		goto adjust_mean_ec;
 	case UBI_IO_FF_BITFLIPS:
 		err = add_to_list(ai, pnum, ec, 1, &ai->erase);
 		if (err)
 			return err;
 		goto adjust_mean_ec;
 	case UBI_IO_FF:
 		if (ec_err)
 			err = add_to_list(ai, pnum, ec, 1, &ai->erase);
 		else
 			err = add_to_list(ai, pnum, ec, 0, &ai->free);
 		if (err)
 			return err;
 		goto adjust_mean_ec;
 	default:
 		ubi_err("'ubi_io_read_vid_hdr()' returned unknown code %d",
 			err);
 		return -EINVAL;
 	}
 	vol_id = be32_to_cpu(vidh->vol_id);
 	if (vol_id > UBI_MAX_VOLUMES && vol_id != UBI_LAYOUT_VOLUME_ID) {
 		int lnum = be32_to_cpu(vidh->lnum);
 		/* Unsupported internal volume */
 		switch (vidh->compat) {
 		case UBI_COMPAT_DELETE:
 			ubi_msg("\"delete\" compatible internal volume %d:%d"
 				" found, will remove it", vol_id, lnum);
 			err = add_to_list(ai, pnum, ec, 1, &ai->erase);
 			if (err)
 				return err;
 			return 0;
 		case UBI_COMPAT_RO:
 			ubi_msg("read-only compatible internal volume %d:%d"
 				" found, switch to read-only mode",
 				vol_id, lnum);
 			ubi->ro_mode = 1;
 			break;
 		case UBI_COMPAT_PRESERVE:
 			ubi_msg("\"preserve\" compatible internal volume %d:%d"
 				" found", vol_id, lnum);
 			err = add_to_list(ai, pnum, ec, 0, &ai->alien);
 			if (err)
 				return err;
 			return 0;
 		case UBI_COMPAT_REJECT:
 			ubi_err("incompatible internal volume %d:%d found",
 				vol_id, lnum);
 			return -EINVAL;
 		}
 	}
 	if (ec_err)
 		ubi_warn("valid VID header but corrupted EC header at PEB %d",
 			 pnum);
 	err = ubi_add_to_av(ubi, ai, pnum, ec, vidh, bitflips);
 	if (err)
 		return err;
 adjust_mean_ec:
 	if (!ec_err) {
 		ai->ec_sum += ec;
 		ai->ec_count += 1;
 		if (ec > ai->max_ec)
 			ai->max_ec = ec;
 		if (ec < ai->min_ec)
 			ai->min_ec = ec;
 	}
 	return 0;
 }
 /**
- * check_what_we_have - check what PEB were found by scanning.
+ * late_analysis - analyze the overall situation with PEB.
  * @ubi: UBI device description object
  * @ai: attaching information
  *
- * This is a helper function which takes a look what PEBs were found by
+ * This is a helper function which takes a look what PEBs we have after we
- * scanning, and decides whether the flash is empty and should be formatted and
+ * gather information about all of them ("ai" is compete). It decides whether
- * whether there are too many corrupted PEBs and we should not attach this
+ * the flash is empty and should be formatted of whether there are too many
- * MTD device. Returns zero if we should proceed with attaching the MTD device,
+ * corrupted PEBs and we should not attach this MTD device. Returns zero if we
- * and %-EINVAL if we should not.
+ * should proceed with attaching the MTD device, and %-EINVAL if we should not.
  */
-static int check_what_we_have(struct ubi_device *ubi,
+static int late_analysis(struct ubi_device *ubi, struct ubi_attach_info *ai)
-			      struct ubi_attach_info *ai)
 {
 	struct ubi_ainf_peb *aeb;
 	int max_corr, peb_count;
 	peb_count = ubi->peb_count - ai->bad_peb_count - ai->alien_peb_count;
 	max_corr = peb_count / 20 ?: 8;
 	/*
 	 * Few corrupted PEBs is not a problem and may be just a result of
 	 * unclean reboots. However, many of them may indicate some problems
 	 * with the flash HW or driver.
 	 */
 	if (ai->corr_peb_count) {
 		ubi_err("%d PEBs are corrupted and preserved",
 			ai->corr_peb_count);
 		printk(KERN_ERR "Corrupted PEBs are:");
 		list_for_each_entry(aeb, &ai->corr, u.list)
 			printk(KERN_CONT " %d", aeb->pnum);
 		printk(KERN_CONT "\n");
 		/*
 		 * If too many PEBs are corrupted, we refuse attaching,
 		 * otherwise, only print a warning.
 		 */
 		if (ai->corr_peb_count >= max_corr) {
 			ubi_err("too many corrupted PEBs, refusing");
 			return -EINVAL;
 		}
 	}
 	if (ai->empty_peb_count + ai->maybe_bad_peb_count == peb_count) {
 		/*
 		 * All PEBs are empty, or almost all - a couple PEBs look like
 		 * they may be bad PEBs which were not marked as bad yet.
 		 *
 		 * This piece of code basically tries to distinguish between
 		 * the following situations:
 		 *
 		 * 1. Flash is empty, but there are few bad PEBs, which are not
 		 *    marked as bad so far, and which were read with error. We
 		 *    want to go ahead and format this flash. While formatting,
 		 *    the faulty PEBs will probably be marked as bad.
 		 *
 		 * 2. Flash contains non-UBI data and we do not want to format
 		 *    it and destroy possibly important information.
 		 */
 		if (ai->maybe_bad_peb_count <= 2) {
 			ai->is_empty = 1;
 			ubi_msg("empty MTD device detected");
 			get_random_bytes(&ubi->image_seq,
 					 sizeof(ubi->image_seq));
 		} else {
 			ubi_err("MTD device is not UBI-formatted and possibly "
 				"contains non-UBI data - refusing it");
 			return -EINVAL;
 		}
 	}
 	return 0;
 }
 /**
  * ubi_scan - scan an MTD device.
  * @ubi: UBI device description object
  *
  * This function does full scanning of an MTD device and returns complete
- * information about it. In case of failure, an error code is returned.
+ * information about it in form of a "struct ubi_attach_info" object. In case
+ * of failure, an error code is returned.
  */
 struct ubi_attach_info *ubi_scan(struct ubi_device *ubi)
 {
 	int err, pnum;
 	struct rb_node *rb1, *rb2;
 	struct ubi_ainf_volume *av;
 	struct ubi_ainf_peb *aeb;
 	struct ubi_attach_info *ai;
 	ai = kzalloc(sizeof(struct ubi_attach_info), GFP_KERNEL);
 	if (!ai)
 		return ERR_PTR(-ENOMEM);
 	INIT_LIST_HEAD(&ai->corr);
 	INIT_LIST_HEAD(&ai->free);
 	INIT_LIST_HEAD(&ai->erase);
 	INIT_LIST_HEAD(&ai->alien);
 	ai->volumes = RB_ROOT;
 	err = -ENOMEM;
 	ai->aeb_slab_cache = kmem_cache_create("ubi_aeb_slab_cache",
 					       sizeof(struct ubi_ainf_peb),
 					       0, 0, NULL);
 	if (!ai->aeb_slab_cache)
 		goto out_ai;
 	ech = kzalloc(ubi->ec_hdr_alsize, GFP_KERNEL);
 	if (!ech)
 		goto out_ai;
 	vidh = ubi_zalloc_vid_hdr(ubi, GFP_KERNEL);
 	if (!vidh)
 		goto out_ech;
 	for (pnum = 0; pnum < ubi->peb_count; pnum++) {
 		cond_resched();
 		dbg_gen("process PEB %d", pnum);
-		err = process_eb(ubi, ai, pnum);
+		err = scan_peb(ubi, ai, pnum);
 		if (err < 0)
 			goto out_vidh;
 	}
 	dbg_msg("scanning is finished");
 	/* Calculate mean erase counter */
 	if (ai->ec_count)
 		ai->mean_ec = div_u64(ai->ec_sum, ai->ec_count);
-	err = check_what_we_have(ubi, ai);
+	err = late_analysis(ubi, ai);
 	if (err)
 		goto out_vidh;
 	/*
 	 * In case of unknown erase counter we use the mean erase counter
 	 * value.
 	 */
 	ubi_rb_for_each_entry(rb1, av, &ai->volumes, rb) {
 		ubi_rb_for_each_entry(rb2, aeb, &av->root, u.rb)
 			if (aeb->ec == UBI_SCAN_UNKNOWN_EC)
 				aeb->ec = ai->mean_ec;
 	}
 	list_for_each_entry(aeb, &ai->free, u.list) {
 		if (aeb->ec == UBI_SCAN_UNKNOWN_EC)
 			aeb->ec = ai->mean_ec;
 	}
 	list_for_each_entry(aeb, &ai->corr, u.list)
 		if (aeb->ec == UBI_SCAN_UNKNOWN_EC)
 			aeb->ec = ai->mean_ec;
 	list_for_each_entry(aeb, &ai->erase, u.list)
 		if (aeb->ec == UBI_SCAN_UNKNOWN_EC)
 			aeb->ec = ai->mean_ec;
 	err = self_check_ai(ubi, ai);
 	if (err)
 		goto out_vidh;
 	ubi_free_vid_hdr(ubi, vidh);
 	kfree(ech);
 	return ai;
 out_vidh:
 	ubi_free_vid_hdr(ubi, vidh);
 out_ech:
 	kfree(ech);
 out_ai:
 	ubi_destroy_ai(ai);
 	return ERR_PTR(err);
 }
 /**
- * destroy_av - free the scanning volume information
+ * destroy_av - free volume attaching information.
- * @av: scanning volume information
+ * @av: volume attaching information
  * @ai: attaching information
  *
- * This function destroys the volume RB-tree (@av->root) and the scanning
+ * This function destroys the volume attaching information.
- * volume information.
  */
 static void destroy_av(struct ubi_attach_info *ai, struct ubi_ainf_volume *av)
 {
 	struct ubi_ainf_peb *aeb;
 	struct rb_node *this = av->root.rb_node;
 	while (this) {
 		if (this->rb_left)
 			this = this->rb_left;
 		else if (this->rb_right)
 			this = this->rb_right;
 		else {
 			aeb = rb_entry(this, struct ubi_ainf_peb, u.rb);
 			this = rb_parent(this);
 			if (this) {
 				if (this->rb_left == &aeb->u.rb)
 					this->rb_left = NULL;
 				else
 					this->rb_right = NULL;
 			}
 			kmem_cache_free(ai->aeb_slab_cache, aeb);
 		}
 	}
 	kfree(av);
 }
 /**
  * ubi_destroy_ai - destroy attaching information.
  * @ai: attaching information
  */
 void ubi_destroy_ai(struct ubi_attach_info *ai)
 {
 	struct ubi_ainf_peb *aeb, *aeb_tmp;
 	struct ubi_ainf_volume *av;
 	struct rb_node *rb;
 	list_for_each_entry_safe(aeb, aeb_tmp, &ai->alien, u.list) {
 		list_del(&aeb->u.list);
 		kmem_cache_free(ai->aeb_slab_cache, aeb);
 	}
 	list_for_each_entry_safe(aeb, aeb_tmp, &ai->erase, u.list) {
 		list_del(&aeb->u.list);
 		kmem_cache_free(ai->aeb_slab_cache, aeb);
 	}
 	list_for_each_entry_safe(aeb, aeb_tmp, &ai->corr, u.list) {
 		list_del(&aeb->u.list);
 		kmem_cache_free(ai->aeb_slab_cache, aeb);
 	}
 	list_for_each_entry_safe(aeb, aeb_tmp, &ai->free, u.list) {
 		list_del(&aeb->u.list);
 		kmem_cache_free(ai->aeb_slab_cache, aeb);
 	}
 	/* Destroy the volume RB-tree */
 	rb = ai->volumes.rb_node;
 	while (rb) {
 		if (rb->rb_left)
 			rb = rb->rb_left;
 		else if (rb->rb_right)
 			rb = rb->rb_right;
 		else {
 			av = rb_entry(rb, struct ubi_ainf_volume, rb);
 			rb = rb_parent(rb);
 			if (rb) {
 				if (rb->rb_left == &av->rb)
 					rb->rb_left = NULL;
 				else
 					rb->rb_right = NULL;
 			}
 			destroy_av(ai, av);
 		}
 	}
 	if (ai->aeb_slab_cache)
 		kmem_cache_destroy(ai->aeb_slab_cache);
 	kfree(ai);
 }
 /**
  * self_check_ai - check the attaching information.
  * @ubi: UBI device description object
  * @ai: attaching information
  *
  * This function returns zero if the attaching information is all right, and a
  * negative error code if not or if an error occurred.
  */
 static int self_check_ai(struct ubi_device *ubi, struct ubi_attach_info *ai)
 {
 	int pnum, err, vols_found = 0;
 	struct rb_node *rb1, *rb2;
 	struct ubi_ainf_volume *av;
 	struct ubi_ainf_peb *aeb, *last_aeb;
 	uint8_t *buf;
 	if (!ubi->dbg->chk_gen)
 		return 0;
 	/*
 	 * At first, check that attaching information is OK.
 	 */
 	ubi_rb_for_each_entry(rb1, av, &ai->volumes, rb) {
 		int leb_count = 0;
 		cond_resched();
 		vols_found += 1;
 		if (ai->is_empty) {
 			ubi_err("bad is_empty flag");
 			goto bad_av;
 		}
 		if (av->vol_id < 0 || av->highest_lnum < 0 ||
 		    av->leb_count < 0 || av->vol_type < 0 || av->used_ebs < 0 ||
 		    av->data_pad < 0 || av->last_data_size < 0) {
 			ubi_err("negative values");
 			goto bad_av;
 		}
 		if (av->vol_id >= UBI_MAX_VOLUMES &&
 		    av->vol_id < UBI_INTERNAL_VOL_START) {
 			ubi_err("bad vol_id");
 			goto bad_av;
 		}
 		if (av->vol_id > ai->highest_vol_id) {
 			ubi_err("highest_vol_id is %d, but vol_id %d is there",
 				ai->highest_vol_id, av->vol_id);
 			goto out;
 		}
 		if (av->vol_type != UBI_DYNAMIC_VOLUME &&
 		    av->vol_type != UBI_STATIC_VOLUME) {
 			ubi_err("bad vol_type");
 			goto bad_av;
 		}
 		if (av->data_pad > ubi->leb_size / 2) {
 			ubi_err("bad data_pad");
 			goto bad_av;
 		}
 		last_aeb = NULL;
 		ubi_rb_for_each_entry(rb2, aeb, &av->root, u.rb) {
 			cond_resched();
 			last_aeb = aeb;
 			leb_count += 1;
 			if (aeb->pnum < 0 || aeb->ec < 0) {
 				ubi_err("negative values");
 				goto bad_aeb;
 			}
 			if (aeb->ec < ai->min_ec) {
 				ubi_err("bad ai->min_ec (%d), %d found",
 					ai->min_ec, aeb->ec);
 				goto bad_aeb;
 			}
 			if (aeb->ec > ai->max_ec) {
 				ubi_err("bad ai->max_ec (%d), %d found",
 					ai->max_ec, aeb->ec);
 				goto bad_aeb;
 			}
 			if (aeb->pnum >= ubi->peb_count) {
 				ubi_err("too high PEB number %d, total PEBs %d",
 					aeb->pnum, ubi->peb_count);
 				goto bad_aeb;
 			}
 			if (av->vol_type == UBI_STATIC_VOLUME) {
 				if (aeb->lnum >= av->used_ebs) {
 					ubi_err("bad lnum or used_ebs");
 					goto bad_aeb;
 				}
 			} else {
 				if (av->used_ebs != 0) {
 					ubi_err("non-zero used_ebs");
 					goto bad_aeb;
 				}
 			}
 			if (aeb->lnum > av->highest_lnum) {
 				ubi_err("incorrect highest_lnum or lnum");
 				goto bad_aeb;
 			}
 		}
 		if (av->leb_count != leb_count) {
 			ubi_err("bad leb_count, %d objects in the tree",
 				leb_count);
 			goto bad_av;
 		}
 		if (!last_aeb)
 			continue;
 		aeb = last_aeb;
 		if (aeb->lnum != av->highest_lnum) {
 			ubi_err("bad highest_lnum");
 			goto bad_aeb;
 		}
 	}
 	if (vols_found != ai->vols_found) {
 		ubi_err("bad ai->vols_found %d, should be %d",
 			ai->vols_found, vols_found);
 		goto out;
 	}
 	/* Check that attaching information is correct */
 	ubi_rb_for_each_entry(rb1, av, &ai->volumes, rb) {
 		last_aeb = NULL;
 		ubi_rb_for_each_entry(rb2, aeb, &av->root, u.rb) {
 			int vol_type;
 			cond_resched();
 			last_aeb = aeb;
 			err = ubi_io_read_vid_hdr(ubi, aeb->pnum, vidh, 1);
 			if (err && err != UBI_IO_BITFLIPS) {
 				ubi_err("VID header is not OK (%d)", err);
 				if (err > 0)
 					err = -EIO;
 				return err;
 			}
 			vol_type = vidh->vol_type == UBI_VID_DYNAMIC ?
 				   UBI_DYNAMIC_VOLUME : UBI_STATIC_VOLUME;
 			if (av->vol_type != vol_type) {
 				ubi_err("bad vol_type");
 				goto bad_vid_hdr;
 			}
 			if (aeb->sqnum != be64_to_cpu(vidh->sqnum)) {
 				ubi_err("bad sqnum %llu", aeb->sqnum);
 				goto bad_vid_hdr;
 			}
 			if (av->vol_id != be32_to_cpu(vidh->vol_id)) {
 				ubi_err("bad vol_id %d", av->vol_id);
 				goto bad_vid_hdr;
 			}
 			if (av->compat != vidh->compat) {
 				ubi_err("bad compat %d", vidh->compat);
 				goto bad_vid_hdr;
 			}
 			if (aeb->lnum != be32_to_cpu(vidh->lnum)) {
 				ubi_err("bad lnum %d", aeb->lnum);
 				goto bad_vid_hdr;
 			}
 			if (av->used_ebs != be32_to_cpu(vidh->used_ebs)) {
 				ubi_err("bad used_ebs %d", av->used_ebs);
 				goto bad_vid_hdr;
 			}
 			if (av->data_pad != be32_to_cpu(vidh->data_pad)) {
 				ubi_err("bad data_pad %d", av->data_pad);
 				goto bad_vid_hdr;
 			}
 		}
 		if (!last_aeb)
 			continue;
 		if (av->highest_lnum != be32_to_cpu(vidh->lnum)) {
 			ubi_err("bad highest_lnum %d", av->highest_lnum);
 			goto bad_vid_hdr;
 		}
 		if (av->last_data_size != be32_to_cpu(vidh->data_size)) {
 			ubi_err("bad last_data_size %d", av->last_data_size);
 			goto bad_vid_hdr;
 		}
 	}
 	/*
 	 * Make sure that all the physical eraseblocks are in one of the lists
 	 * or trees.
 	 */
 	buf = kzalloc(ubi->peb_count, GFP_KERNEL);
 	if (!buf)
 		return -ENOMEM;
 	for (pnum = 0; pnum < ubi->peb_count; pnum++) {
 		err = ubi_io_is_bad(ubi, pnum);
 		if (err < 0) {
 			kfree(buf);
 			return err;
 		} else if (err)
 			buf[pnum] = 1;
 	}
 	ubi_rb_for_each_entry(rb1, av, &ai->volumes, rb)
 		ubi_rb_for_each_entry(rb2, aeb, &av->root, u.rb)
 			buf[aeb->pnum] = 1;
 	list_for_each_entry(aeb, &ai->free, u.list)
 		buf[aeb->pnum] = 1;
 	list_for_each_entry(aeb, &ai->corr, u.list)
 		buf[aeb->pnum] = 1;
 	list_for_each_entry(aeb, &ai->erase, u.list)
 		buf[aeb->pnum] = 1;
 	list_for_each_entry(aeb, &ai->alien, u.list)
 		buf[aeb->pnum] = 1;
 	err = 0;
 	for (pnum = 0; pnum < ubi->peb_count; pnum++)
 		if (!buf[pnum]) {
 			ubi_err("PEB %d is not referred", pnum);
 			err = 1;
 		}
 	kfree(buf);
 	if (err)
 		goto out;
 	return 0;
 bad_aeb:
 	ubi_err("bad attaching information about LEB %d", aeb->lnum);
 	ubi_dump_aeb(aeb, 0);
 	ubi_dump_av(av);
 	goto out;
 bad_av:
 	ubi_err("bad attaching information about volume %d", av->vol_id);
 	ubi_dump_av(av);
 	goto out;
 bad_vid_hdr:
 	ubi_err("bad attaching information about volume %d", av->vol_id);
 	ubi_dump_av(av);
 	ubi_dump_vid_hdr(vidh);

drivers/mtd/ubi/scan.h

Diff comments View file @ fbd0107

1	/*	1	/*
2	* Copyright (c) International Business Machines Corp., 2006	2	* Copyright (c) International Business Machines Corp., 2006
3	*	3	*
4	* This program is free software; you can redistribute it and/or modify	4	* This program is free software; you can redistribute it and/or modify
5	* it under the terms of the GNU General Public License as published by	5	* it under the terms of the GNU General Public License as published by
6	* the Free Software Foundation; either version 2 of the License, or	6	* the Free Software Foundation; either version 2 of the License, or
7	* (at your option) any later version.	7	* (at your option) any later version.
8	*	8	*
9	* This program is distributed in the hope that it will be useful,	9	* This program is distributed in the hope that it will be useful,
10	* but WITHOUT ANY WARRANTY; without even the implied warranty of	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
12	* the GNU General Public License for more details.	12	* the GNU General Public License for more details.
13	*	13	*
14	* You should have received a copy of the GNU General Public License	14	* You should have received a copy of the GNU General Public License
15	* along with this program; if not, write to the Free Software	15	* along with this program; if not, write to the Free Software
16	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA	16	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17	*	17	*
18	* Author: Artem Bityutskiy (Битюцкий Артём)	18	* Author: Artem Bityutskiy (Битюцкий Артём)
19	*/	19	*/
20		20
21	#ifndef __UBI_SCAN_H__	21	#ifndef __UBI_SCAN_H__
22	#define __UBI_SCAN_H__	22	#define __UBI_SCAN_H__
23		23
24	/* The erase counter value for this physical eraseblock is unknown */	24	/* The erase counter value for this physical eraseblock is unknown */
25	#define UBI_SCAN_UNKNOWN_EC (-1)	25	#define UBI_SCAN_UNKNOWN_EC (-1)
26		26
27	/**	27	/**
28	* struct ubi_ainf_peb - attach information about a physical eraseblock.	28	* struct ubi_ainf_peb - attach information about a physical eraseblock.
29	* @ec: erase counter (%UBI_SCAN_UNKNOWN_EC if it is unknown)	29	* @ec: erase counter (%UBI_SCAN_UNKNOWN_EC if it is unknown)
30	* @pnum: physical eraseblock number	30	* @pnum: physical eraseblock number
31	* @lnum: logical eraseblock number	31	* @lnum: logical eraseblock number
32	* @scrub: if this physical eraseblock needs scrubbing	32	* @scrub: if this physical eraseblock needs scrubbing
33	* @copy_flag: this LEB is a copy (@copy_flag is set in VID header of this LEB)	33	* @copy_flag: this LEB is a copy (@copy_flag is set in VID header of this LEB)
34	* @sqnum: sequence number	34	* @sqnum: sequence number
35	* @u: unions RB-tree or @list links	35	* @u: unions RB-tree or @list links
36	* @u.rb: link in the per-volume RB-tree of &struct ubi_ainf_peb objects	36	* @u.rb: link in the per-volume RB-tree of &struct ubi_ainf_peb objects
37	* @u.list: link in one of the eraseblock lists	37	* @u.list: link in one of the eraseblock lists
38	*	38	*
39	* One object of this type is allocated for each physical eraseblock when	39	* One object of this type is allocated for each physical eraseblock when
40	* attaching an MTD device.	40	* attaching an MTD device.
41	*/	41	*/
42	struct ubi_ainf_peb {	42	struct ubi_ainf_peb {
43	int ec;	43	int ec;
44	int pnum;	44	int pnum;
45	int lnum;	45	int lnum;
46	unsigned int scrub:1;	46	unsigned int scrub:1;
47	unsigned int copy_flag:1;	47	unsigned int copy_flag:1;
48	unsigned long long sqnum;	48	unsigned long long sqnum;
49	union {	49	union {
50	struct rb_node rb;	50	struct rb_node rb;
51	struct list_head list;	51	struct list_head list;
52	} u;	52	} u;
53	};	53	};
54		54
55	/**	55	/**
56	* struct ubi_ainf_volume - attaching information about a volume.	56	* struct ubi_ainf_volume - attaching information about a volume.
57	* @vol_id: volume ID	57	* @vol_id: volume ID
58	* @highest_lnum: highest logical eraseblock number in this volume	58	* @highest_lnum: highest logical eraseblock number in this volume
59	* @leb_count: number of logical eraseblocks in this volume	59	* @leb_count: number of logical eraseblocks in this volume
60	* @vol_type: volume type	60	* @vol_type: volume type
61	* @used_ebs: number of used logical eraseblocks in this volume (only for	61	* @used_ebs: number of used logical eraseblocks in this volume (only for
62	* static volumes)	62	* static volumes)
63	* @last_data_size: amount of data in the last logical eraseblock of this	63	* @last_data_size: amount of data in the last logical eraseblock of this
64	* volume (always equivalent to the usable logical eraseblock	64	* volume (always equivalent to the usable logical eraseblock
65	* size in case of dynamic volumes)	65	* size in case of dynamic volumes)
66	* @data_pad: how many bytes at the end of logical eraseblocks of this volume	66	* @data_pad: how many bytes at the end of logical eraseblocks of this volume
67	* are not used (due to volume alignment)	67	* are not used (due to volume alignment)
68	* @compat: compatibility flags of this volume	68	* @compat: compatibility flags of this volume
69	* @rb: link in the volume RB-tree	69	* @rb: link in the volume RB-tree
70	* @root: root of the RB-tree containing all the eraseblock belonging to this	70	* @root: root of the RB-tree containing all the eraseblock belonging to this
71	* volume (&struct ubi_ainf_peb objects)	71	* volume (&struct ubi_ainf_peb objects)
72	*	72	*
73	* One object of this type is allocated for each volume when attaching an MTD	73	* One object of this type is allocated for each volume when attaching an MTD
74	* device.	74	* device.
75	*/	75	*/
76	struct ubi_ainf_volume {	76	struct ubi_ainf_volume {
77	int vol_id;	77	int vol_id;
78	int highest_lnum;	78	int highest_lnum;
79	int leb_count;	79	int leb_count;
80	int vol_type;	80	int vol_type;
81	int used_ebs;	81	int used_ebs;
82	int last_data_size;	82	int last_data_size;
83	int data_pad;	83	int data_pad;
84	int compat;	84	int compat;
85	struct rb_node rb;	85	struct rb_node rb;
86	struct rb_root root;	86	struct rb_root root;
87	};	87	};
88		88
89	/**	89	/**
90	* struct ubi_attach_info - MTD device attaching information.	90	* struct ubi_attach_info - MTD device attaching information.
91	* @volumes: root of the volume RB-tree	91	* @volumes: root of the volume RB-tree
92	* @corr: list of corrupted physical eraseblocks	92	* @corr: list of corrupted physical eraseblocks
93	* @free: list of free physical eraseblocks	93	* @free: list of free physical eraseblocks
94	* @erase: list of physical eraseblocks which have to be erased	94	* @erase: list of physical eraseblocks which have to be erased
95	* @alien: list of physical eraseblocks which should not be used by UBI (e.g.,	95	* @alien: list of physical eraseblocks which should not be used by UBI (e.g.,
96	* those belonging to "preserve"-compatible internal volumes)	96	* those belonging to "preserve"-compatible internal volumes)
97	* @corr_peb_count: count of PEBs in the @corr list	97	* @corr_peb_count: count of PEBs in the @corr list
98	* @empty_peb_count: count of PEBs which are presumably empty (contain only	98	* @empty_peb_count: count of PEBs which are presumably empty (contain only
99	* 0xFF bytes)	99	* 0xFF bytes)
100	* @alien_peb_count: count of PEBs in the @alien list	100	* @alien_peb_count: count of PEBs in the @alien list
101	* @bad_peb_count: count of bad physical eraseblocks	101	* @bad_peb_count: count of bad physical eraseblocks
102	* @maybe_bad_peb_count: count of bad physical eraseblocks which are not marked	102	* @maybe_bad_peb_count: count of bad physical eraseblocks which are not marked
103	* as bad yet, but which look like bad	103	* as bad yet, but which look like bad
104	* @vols_found: number of volumes found	104	* @vols_found: number of volumes found
105	* @highest_vol_id: highest volume ID	105	* @highest_vol_id: highest volume ID
106	* @is_empty: flag indicating whether the MTD device is empty or not	106	* @is_empty: flag indicating whether the MTD device is empty or not
107	* @min_ec: lowest erase counter value	107	* @min_ec: lowest erase counter value
108	* @max_ec: highest erase counter value	108	* @max_ec: highest erase counter value
109	* @max_sqnum: highest sequence number value	109	* @max_sqnum: highest sequence number value
110	* @mean_ec: mean erase counter value	110	* @mean_ec: mean erase counter value
111	* @ec_sum: a temporary variable used when calculating @mean_ec	111	* @ec_sum: a temporary variable used when calculating @mean_ec
112	* @ec_count: a temporary variable used when calculating @mean_ec	112	* @ec_count: a temporary variable used when calculating @mean_ec
113	* @aeb_slab_cache: slab cache for &struct ubi_ainf_peb objects	113	* @aeb_slab_cache: slab cache for &struct ubi_ainf_peb objects
114	*	114	*
115	* This data structure contains the result of attaching an MTD device and may	115	* This data structure contains the result of attaching an MTD device and may
116	* be used by other UBI sub-systems to build final UBI data structures, further	116	* be used by other UBI sub-systems to build final UBI data structures, further
117	* error-recovery and so on.	117	* error-recovery and so on.
118	*/	118	*/
119	struct ubi_attach_info {	119	struct ubi_attach_info {
120	struct rb_root volumes;	120	struct rb_root volumes;
121	struct list_head corr;	121	struct list_head corr;
122	struct list_head free;	122	struct list_head free;
123	struct list_head erase;	123	struct list_head erase;
124	struct list_head alien;	124	struct list_head alien;
125	int corr_peb_count;	125	int corr_peb_count;
126	int empty_peb_count;	126	int empty_peb_count;
127	int alien_peb_count;	127	int alien_peb_count;
128	int bad_peb_count;	128	int bad_peb_count;
129	int maybe_bad_peb_count;	129	int maybe_bad_peb_count;
130	int vols_found;	130	int vols_found;
131	int highest_vol_id;	131	int highest_vol_id;
132	int is_empty;	132	int is_empty;
133	int min_ec;	133	int min_ec;
134	int max_ec;	134	int max_ec;
135	unsigned long long max_sqnum;	135	unsigned long long max_sqnum;
136	int mean_ec;	136	int mean_ec;
137	uint64_t ec_sum;	137	uint64_t ec_sum;
138	int ec_count;	138	int ec_count;
139	struct kmem_cache *aeb_slab_cache;	139	struct kmem_cache *aeb_slab_cache;
140	};	140	};
141		141
142	struct ubi_device;	142	struct ubi_device;
143	struct ubi_vid_hdr;	143	struct ubi_vid_hdr;
144		144
145	/*	145	/*
146	* ubi_move_aeb_to_list - move a PEB from the volume tree to a list.	146	* ubi_move_aeb_to_list - move a PEB from the volume tree to a list.
147	*	147	*
148	* @av: volume attaching information	148	* @av: volume attaching information
149	* @aeb: scanning eraseblock information	149	* @aeb: attaching eraseblock information
150	* @list: the list to move to	150	* @list: the list to move to
151	*/	151	*/
152	static inline void ubi_move_aeb_to_list(struct ubi_ainf_volume *av,	152	static inline void ubi_move_aeb_to_list(struct ubi_ainf_volume *av,
153	struct ubi_ainf_peb *aeb,	153	struct ubi_ainf_peb *aeb,
154	struct list_head *list)	154	struct list_head *list)
155	{	155	{
156	rb_erase(&aeb->u.rb, &av->root);	156	rb_erase(&aeb->u.rb, &av->root);
157	list_add_tail(&aeb->u.list, list);	157	list_add_tail(&aeb->u.list, list);
158	}	158	}
159		159
160	int ubi_add_to_av(struct ubi_device ubi, struct ubi_attach_info ai, int pnum,	160	int ubi_add_to_av(struct ubi_device ubi, struct ubi_attach_info ai, int pnum,
161	int ec, const struct ubi_vid_hdr *vid_hdr, int bitflips);	161	int ec, const struct ubi_vid_hdr *vid_hdr, int bitflips);
162	struct ubi_ainf_volume ubi_find_av(const struct ubi_attach_info ai,	162	struct ubi_ainf_volume ubi_find_av(const struct ubi_attach_info ai,
163	int vol_id);	163	int vol_id);
164	void ubi_remove_av(struct ubi_attach_info ai, struct ubi_ainf_volume av);	164	void ubi_remove_av(struct ubi_attach_info ai, struct ubi_ainf_volume av);
165	struct ubi_ainf_peb ubi_early_get_peb(struct ubi_device ubi,	165	struct ubi_ainf_peb ubi_early_get_peb(struct ubi_device ubi,
166	struct ubi_attach_info *ai);	166	struct ubi_attach_info *ai);
167	struct ubi_attach_info ubi_scan(struct ubi_device ubi);	167	struct ubi_attach_info ubi_scan(struct ubi_device ubi);
168	void ubi_destroy_ai(struct ubi_attach_info *ai);	168	void ubi_destroy_ai(struct ubi_attach_info *ai);
169		169
170	#endif /* !__UBI_SCAN_H__ */	170	#endif /* !__UBI_SCAN_H__ */
171		171

drivers/mtd/ubi/ubi-media.h

Diff comments View file @ fbd0107

drivers/mtd/ubi/vtbl.c

Diff comments View file @ fbd0107

 /*
  * Copyright (c) International Business Machines Corp., 2006
  * Copyright (c) Nokia Corporation, 2006, 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 (Битюцкий Артём)
  */
 /*
  * This file includes volume table manipulation code. The volume table is an
  * on-flash table containing volume meta-data like name, number of reserved
  * physical eraseblocks, type, etc. The volume table is stored in the so-called
  * "layout volume".
  *
  * The layout volume is an internal volume which is organized as follows. It
  * consists of two logical eraseblocks - LEB 0 and LEB 1. Each logical
  * eraseblock stores one volume table copy, i.e. LEB 0 and LEB 1 duplicate each
  * other. This redundancy guarantees robustness to unclean reboots. The volume
  * table is basically an array of volume table records. Each record contains
  * full information about the volume and protected by a CRC checksum.
  *
  * The volume table is changed, it is first changed in RAM. Then LEB 0 is
  * erased, and the updated volume table is written back to LEB 0. Then same for
  * LEB 1. This scheme guarantees recoverability from unclean reboots.
  *
  * In this UBI implementation the on-flash volume table does not contain any
- * information about how many data static volumes contain. This information may
+ * information about how much data static volumes contain.
- * be found from the scanning data.
  *
  * But it would still be beneficial to store this information in the volume
  * table. For example, suppose we have a static volume X, and all its physical
  * eraseblocks became bad for some reasons. Suppose we are attaching the
- * corresponding MTD device, the scanning has found no logical eraseblocks
+ * corresponding MTD device, for some reason we find no logical eraseblocks
  * corresponding to the volume X. According to the volume table volume X does
  * exist. So we don't know whether it is just empty or all its physical
- * eraseblocks went bad. So we cannot alarm the user about this corruption.
+ * eraseblocks went bad. So we cannot alarm the user properly.
  *
  * The volume table also stores so-called "update marker", which is used for
  * volume updates. Before updating the volume, the update marker is set, and
  * after the update operation is finished, the update marker is cleared. So if
  * the update operation was interrupted (e.g. by an unclean reboot) - the
  * update marker is still there and we know that the volume's contents is
  * damaged.
  */
 #include <linux/crc32.h>
 #include <linux/err.h>
 #include <linux/slab.h>
 #include <asm/div64.h>
 #include "ubi.h"
 static void self_vtbl_check(const struct ubi_device *ubi);
 /* Empty volume table record */
 static struct ubi_vtbl_record empty_vtbl_record;
 /**
  * ubi_change_vtbl_record - change volume table record.
  * @ubi: UBI device description object
  * @idx: table index to change
  * @vtbl_rec: new volume table record
  *
  * This function changes volume table record @idx. If @vtbl_rec is %NULL, empty
  * volume table record is written. The caller does not have to calculate CRC of
  * the record as it is done by this function. Returns zero in case of success
  * and a negative error code in case of failure.
  */
 int ubi_change_vtbl_record(struct ubi_device *ubi, int idx,
 			   struct ubi_vtbl_record *vtbl_rec)
 {
 	int i, err;
 	uint32_t crc;
 	struct ubi_volume *layout_vol;
 	ubi_assert(idx >= 0 && idx < ubi->vtbl_slots);
 	layout_vol = ubi->volumes[vol_id2idx(ubi, UBI_LAYOUT_VOLUME_ID)];
 	if (!vtbl_rec)
 		vtbl_rec = &empty_vtbl_record;
 	else {
 		crc = crc32(UBI_CRC32_INIT, vtbl_rec, UBI_VTBL_RECORD_SIZE_CRC);
 		vtbl_rec->crc = cpu_to_be32(crc);
 	}
 	memcpy(&ubi->vtbl[idx], vtbl_rec, sizeof(struct ubi_vtbl_record));
 	for (i = 0; i < UBI_LAYOUT_VOLUME_EBS; i++) {
 		err = ubi_eba_unmap_leb(ubi, layout_vol, i);
 		if (err)
 			return err;
 		err = ubi_eba_write_leb(ubi, layout_vol, i, ubi->vtbl, 0,
 					ubi->vtbl_size);
 		if (err)
 			return err;
 	}
 	self_vtbl_check(ubi);
 	return 0;
 }
 /**
  * ubi_vtbl_rename_volumes - rename UBI volumes in the volume table.
  * @ubi: UBI device description object
  * @rename_list: list of &struct ubi_rename_entry objects
  *
  * This function re-names multiple volumes specified in @req in the volume
  * table. Returns zero in case of success and a negative error code in case of
  * failure.
  */
 int ubi_vtbl_rename_volumes(struct ubi_device *ubi,
 			    struct list_head *rename_list)
 {
 	int i, err;
 	struct ubi_rename_entry *re;
 	struct ubi_volume *layout_vol;
 	list_for_each_entry(re, rename_list, list) {
 		uint32_t crc;
 		struct ubi_volume *vol = re->desc->vol;
 		struct ubi_vtbl_record *vtbl_rec = &ubi->vtbl[vol->vol_id];
 		if (re->remove) {
 			memcpy(vtbl_rec, &empty_vtbl_record,
 			       sizeof(struct ubi_vtbl_record));
 			continue;
 		}
 		vtbl_rec->name_len = cpu_to_be16(re->new_name_len);
 		memcpy(vtbl_rec->name, re->new_name, re->new_name_len);
 		memset(vtbl_rec->name + re->new_name_len, 0,
 		       UBI_VOL_NAME_MAX + 1 - re->new_name_len);
 		crc = crc32(UBI_CRC32_INIT, vtbl_rec,
 			    UBI_VTBL_RECORD_SIZE_CRC);
 		vtbl_rec->crc = cpu_to_be32(crc);
 	}
 	layout_vol = ubi->volumes[vol_id2idx(ubi, UBI_LAYOUT_VOLUME_ID)];
 	for (i = 0; i < UBI_LAYOUT_VOLUME_EBS; i++) {
 		err = ubi_eba_unmap_leb(ubi, layout_vol, i);
 		if (err)
 			return err;
 		err = ubi_eba_write_leb(ubi, layout_vol, i, ubi->vtbl, 0,
 					ubi->vtbl_size);
 		if (err)
 			return err;
 	}
 	return 0;
 }
 /**
  * vtbl_check - check if volume table is not corrupted and sensible.
  * @ubi: UBI device description object
  * @vtbl: volume table
  *
  * This function returns zero if @vtbl is all right, %1 if CRC is incorrect,
  * and %-EINVAL if it contains inconsistent data.
  */
 static int vtbl_check(const struct ubi_device *ubi,
 		      const struct ubi_vtbl_record *vtbl)
 {
 	int i, n, reserved_pebs, alignment, data_pad, vol_type, name_len;
 	int upd_marker, err;
 	uint32_t crc;
 	const char *name;
 	for (i = 0; i < ubi->vtbl_slots; i++) {
 		cond_resched();
 		reserved_pebs = be32_to_cpu(vtbl[i].reserved_pebs);
 		alignment = be32_to_cpu(vtbl[i].alignment);
 		data_pad = be32_to_cpu(vtbl[i].data_pad);
 		upd_marker = vtbl[i].upd_marker;
 		vol_type = vtbl[i].vol_type;
 		name_len = be16_to_cpu(vtbl[i].name_len);
 		name = &vtbl[i].name[0];
 		crc = crc32(UBI_CRC32_INIT, &vtbl[i], UBI_VTBL_RECORD_SIZE_CRC);
 		if (be32_to_cpu(vtbl[i].crc) != crc) {
 			ubi_err("bad CRC at record %u: %#08x, not %#08x",
 				 i, crc, be32_to_cpu(vtbl[i].crc));
 			ubi_dump_vtbl_record(&vtbl[i], i);
 			return 1;
 		}
 		if (reserved_pebs == 0) {
 			if (memcmp(&vtbl[i], &empty_vtbl_record,
 						UBI_VTBL_RECORD_SIZE)) {
 				err = 2;
 				goto bad;
 			}
 			continue;
 		}
 		if (reserved_pebs < 0 || alignment < 0 || data_pad < 0 ||
 		    name_len < 0) {
 			err = 3;
 			goto bad;
 		}
 		if (alignment > ubi->leb_size || alignment == 0) {
 			err = 4;
 			goto bad;
 		}
 		n = alignment & (ubi->min_io_size - 1);
 		if (alignment != 1 && n) {
 			err = 5;
 			goto bad;
 		}
 		n = ubi->leb_size % alignment;
 		if (data_pad != n) {
 			ubi_err("bad data_pad, has to be %d", n);
 			err = 6;
 			goto bad;
 		}
 		if (vol_type != UBI_VID_DYNAMIC && vol_type != UBI_VID_STATIC) {
 			err = 7;
 			goto bad;
 		}
 		if (upd_marker != 0 && upd_marker != 1) {
 			err = 8;
 			goto bad;
 		}
 		if (reserved_pebs > ubi->good_peb_count) {
 			ubi_err("too large reserved_pebs %d, good PEBs %d",
 				reserved_pebs, ubi->good_peb_count);
 			err = 9;
 			goto bad;
 		}
 		if (name_len > UBI_VOL_NAME_MAX) {
 			err = 10;
 			goto bad;
 		}
 		if (name[0] == '\0') {
 			err = 11;
 			goto bad;
 		}
 		if (name_len != strnlen(name, name_len + 1)) {
 			err = 12;
 			goto bad;
 		}
 	}
 	/* Checks that all names are unique */
 	for (i = 0; i < ubi->vtbl_slots - 1; i++) {
 		for (n = i + 1; n < ubi->vtbl_slots; n++) {
 			int len1 = be16_to_cpu(vtbl[i].name_len);
 			int len2 = be16_to_cpu(vtbl[n].name_len);
 			if (len1 > 0 && len1 == len2 &&
 			    !strncmp(vtbl[i].name, vtbl[n].name, len1)) {
 				ubi_err("volumes %d and %d have the same name"
 					" \"%s\"", i, n, vtbl[i].name);
 				ubi_dump_vtbl_record(&vtbl[i], i);
 				ubi_dump_vtbl_record(&vtbl[n], n);
 				return -EINVAL;
 			}
 		}
 	}
 	return 0;
 bad:
 	ubi_err("volume table check failed: record %d, error %d", i, err);
 	ubi_dump_vtbl_record(&vtbl[i], i);
 	return -EINVAL;
 }
 /**
  * create_vtbl - create a copy of volume table.
  * @ubi: UBI device description object
  * @ai: attaching information
  * @copy: number of the volume table copy
  * @vtbl: contents of the volume table
  *
  * This function returns zero in case of success and a negative error code in
  * case of failure.
  */
 static int create_vtbl(struct ubi_device *ubi, struct ubi_attach_info *ai,
 		       int copy, void *vtbl)
 {
 	int err, tries = 0;
 	struct ubi_vid_hdr *vid_hdr;
 	struct ubi_ainf_peb *new_aeb;
 	ubi_msg("create volume table (copy #%d)", copy + 1);
 	vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_KERNEL);
 	if (!vid_hdr)
 		return -ENOMEM;
 retry:
 	new_aeb = ubi_early_get_peb(ubi, ai);
 	if (IS_ERR(new_aeb)) {
 		err = PTR_ERR(new_aeb);
 		goto out_free;
 	}
 	vid_hdr->vol_type = UBI_LAYOUT_VOLUME_TYPE;
 	vid_hdr->vol_id = cpu_to_be32(UBI_LAYOUT_VOLUME_ID);
 	vid_hdr->compat = UBI_LAYOUT_VOLUME_COMPAT;
 	vid_hdr->data_size = vid_hdr->used_ebs =
 			     vid_hdr->data_pad = cpu_to_be32(0);
 	vid_hdr->lnum = cpu_to_be32(copy);
 	vid_hdr->sqnum = cpu_to_be64(++ai->max_sqnum);
 	/* The EC header is already there, write the VID header */
 	err = ubi_io_write_vid_hdr(ubi, new_aeb->pnum, vid_hdr);
 	if (err)
 		goto write_error;
 	/* Write the layout volume contents */
 	err = ubi_io_write_data(ubi, vtbl, new_aeb->pnum, 0, ubi->vtbl_size);
 	if (err)
 		goto write_error;
 	/*
 	 * And add it to the attaching information. Don't delete the old version
 	 * of this LEB as it will be deleted and freed in 'ubi_add_to_av()'.
 	 */
 	err = ubi_add_to_av(ubi, ai, new_aeb->pnum, new_aeb->ec, vid_hdr, 0);
 	kfree(new_aeb);
 	ubi_free_vid_hdr(ubi, vid_hdr);
 	return err;
 write_error:
 	if (err == -EIO && ++tries <= 5) {
 		/*
 		 * Probably this physical eraseblock went bad, try to pick
 		 * another one.
 		 */
 		list_add(&new_aeb->u.list, &ai->erase);
 		goto retry;
 	}
 	kfree(new_aeb);
 out_free:
 	ubi_free_vid_hdr(ubi, vid_hdr);
 	return err;
 }
 /**
  * process_lvol - process the layout volume.
  * @ubi: UBI device description object
  * @ai: attaching information
  * @av: layout volume attaching information
  *
  * This function is responsible for reading the layout volume, ensuring it is
  * not corrupted, and recovering from corruptions if needed. Returns volume
  * table in case of success and a negative error code in case of failure.
  */
 static struct ubi_vtbl_record *process_lvol(struct ubi_device *ubi,
 					    struct ubi_attach_info *ai,
 					    struct ubi_ainf_volume *av)
 {
 	int err;
 	struct rb_node *rb;
 	struct ubi_ainf_peb *aeb;
 	struct ubi_vtbl_record *leb[UBI_LAYOUT_VOLUME_EBS] = { NULL, NULL };
 	int leb_corrupted[UBI_LAYOUT_VOLUME_EBS] = {1, 1};
 	/*
 	 * UBI goes through the following steps when it changes the layout
 	 * volume:
 	 * a. erase LEB 0;
 	 * b. write new data to LEB 0;
 	 * c. erase LEB 1;
 	 * d. write new data to LEB 1.
 	 *
 	 * Before the change, both LEBs contain the same data.
 	 *
 	 * Due to unclean reboots, the contents of LEB 0 may be lost, but there
 	 * should LEB 1. So it is OK if LEB 0 is corrupted while LEB 1 is not.
 	 * Similarly, LEB 1 may be lost, but there should be LEB 0. And
 	 * finally, unclean reboots may result in a situation when neither LEB
 	 * 0 nor LEB 1 are corrupted, but they are different. In this case, LEB
 	 * 0 contains more recent information.
 	 *
 	 * So the plan is to first check LEB 0. Then
 	 * a. if LEB 0 is OK, it must be containing the most recent data; then
 	 *    we compare it with LEB 1, and if they are different, we copy LEB
 	 *    0 to LEB 1;
 	 * b. if LEB 0 is corrupted, but LEB 1 has to be OK, and we copy LEB 1
 	 *    to LEB 0.
 	 */
 	dbg_gen("check layout volume");
 	/* Read both LEB 0 and LEB 1 into memory */
 	ubi_rb_for_each_entry(rb, aeb, &av->root, u.rb) {
 		leb[aeb->lnum] = vzalloc(ubi->vtbl_size);
 		if (!leb[aeb->lnum]) {
 			err = -ENOMEM;
 			goto out_free;
 		}
 		err = ubi_io_read_data(ubi, leb[aeb->lnum], aeb->pnum, 0,
 				       ubi->vtbl_size);
 		if (err == UBI_IO_BITFLIPS || mtd_is_eccerr(err))
 			/*
 			 * Scrub the PEB later. Note, -EBADMSG indicates an
 			 * uncorrectable ECC error, but we have our own CRC and
 			 * the data will be checked later. If the data is OK,
 			 * the PEB will be scrubbed (because we set
 			 * aeb->scrub). If the data is not OK, the contents of
 			 * the PEB will be recovered from the second copy, and
 			 * aeb->scrub will be cleared in
 			 * 'ubi_add_to_av()'.
 			 */
 			aeb->scrub = 1;
 		else if (err)
 			goto out_free;
 	}
 	err = -EINVAL;
 	if (leb[0]) {
 		leb_corrupted[0] = vtbl_check(ubi, leb[0]);
 		if (leb_corrupted[0] < 0)
 			goto out_free;
 	}
 	if (!leb_corrupted[0]) {
 		/* LEB 0 is OK */
 		if (leb[1])
 			leb_corrupted[1] = memcmp(leb[0], leb[1],
 						  ubi->vtbl_size);
 		if (leb_corrupted[1]) {
 			ubi_warn("volume table copy #2 is corrupted");
 			err = create_vtbl(ubi, ai, 1, leb[0]);
 			if (err)
 				goto out_free;
 			ubi_msg("volume table was restored");
 		}
 		/* Both LEB 1 and LEB 2 are OK and consistent */
 		vfree(leb[1]);
 		return leb[0];
 	} else {
 		/* LEB 0 is corrupted or does not exist */
 		if (leb[1]) {
 			leb_corrupted[1] = vtbl_check(ubi, leb[1]);
 			if (leb_corrupted[1] < 0)
 				goto out_free;
 		}
 		if (leb_corrupted[1]) {
 			/* Both LEB 0 and LEB 1 are corrupted */
 			ubi_err("both volume tables are corrupted");
 			goto out_free;
 		}
 		ubi_warn("volume table copy #1 is corrupted");
 		err = create_vtbl(ubi, ai, 0, leb[1]);
 		if (err)
 			goto out_free;
 		ubi_msg("volume table was restored");
 		vfree(leb[0]);
 		return leb[1];
 	}
 out_free:
 	vfree(leb[0]);
 	vfree(leb[1]);
 	return ERR_PTR(err);
 }
 /**
  * create_empty_lvol - create empty layout volume.
  * @ubi: UBI device description object
  * @ai: attaching information
  *
  * This function returns volume table contents in case of success and a
  * negative error code in case of failure.
  */
 static struct ubi_vtbl_record *create_empty_lvol(struct ubi_device *ubi,
 						 struct ubi_attach_info *ai)
 {
 	int i;
 	struct ubi_vtbl_record *vtbl;
 	vtbl = vzalloc(ubi->vtbl_size);
 	if (!vtbl)
 		return ERR_PTR(-ENOMEM);
 	for (i = 0; i < ubi->vtbl_slots; i++)
 		memcpy(&vtbl[i], &empty_vtbl_record, UBI_VTBL_RECORD_SIZE);
 	for (i = 0; i < UBI_LAYOUT_VOLUME_EBS; i++) {
 		int err;
 		err = create_vtbl(ubi, ai, i, vtbl);
 		if (err) {
 			vfree(vtbl);
 			return ERR_PTR(err);
 		}
 	}
 	return vtbl;
 }
 /**
  * init_volumes - initialize volume information for existing volumes.
  * @ubi: UBI device description object
  * @ai: scanning information
  * @vtbl: volume table
  *
  * This function allocates volume description objects for existing volumes.
  * Returns zero in case of success and a negative error code in case of
  * failure.
  */
 static int init_volumes(struct ubi_device *ubi,
 			const struct ubi_attach_info *ai,
 			const struct ubi_vtbl_record *vtbl)
 {
 	int i, reserved_pebs = 0;
 	struct ubi_ainf_volume *av;
 	struct ubi_volume *vol;
 	for (i = 0; i < ubi->vtbl_slots; i++) {
 		cond_resched();
 		if (be32_to_cpu(vtbl[i].reserved_pebs) == 0)
 			continue; /* Empty record */
 		vol = kzalloc(sizeof(struct ubi_volume), GFP_KERNEL);
 		if (!vol)
 			return -ENOMEM;
 		vol->reserved_pebs = be32_to_cpu(vtbl[i].reserved_pebs);
 		vol->alignment = be32_to_cpu(vtbl[i].alignment);
 		vol->data_pad = be32_to_cpu(vtbl[i].data_pad);
 		vol->upd_marker = vtbl[i].upd_marker;
 		vol->vol_type = vtbl[i].vol_type == UBI_VID_DYNAMIC ?
 					UBI_DYNAMIC_VOLUME : UBI_STATIC_VOLUME;
 		vol->name_len = be16_to_cpu(vtbl[i].name_len);
 		vol->usable_leb_size = ubi->leb_size - vol->data_pad;
 		memcpy(vol->name, vtbl[i].name, vol->name_len);
 		vol->name[vol->name_len] = '\0';
 		vol->vol_id = i;
 		if (vtbl[i].flags & UBI_VTBL_AUTORESIZE_FLG) {
 			/* Auto re-size flag may be set only for one volume */
 			if (ubi->autoresize_vol_id != -1) {
 				ubi_err("more than one auto-resize volume (%d "
 					"and %d)", ubi->autoresize_vol_id, i);
 				kfree(vol);
 				return -EINVAL;
 			}
 			ubi->autoresize_vol_id = i;
 		}
 		ubi_assert(!ubi->volumes[i]);
 		ubi->volumes[i] = vol;
 		ubi->vol_count += 1;
 		vol->ubi = ubi;
 		reserved_pebs += vol->reserved_pebs;
 		/*
 		 * In case of dynamic volume UBI knows nothing about how many
 		 * data is stored there. So assume the whole volume is used.
 		 */
 		if (vol->vol_type == UBI_DYNAMIC_VOLUME) {
 			vol->used_ebs = vol->reserved_pebs;
 			vol->last_eb_bytes = vol->usable_leb_size;
 			vol->used_bytes =
 				(long long)vol->used_ebs * vol->usable_leb_size;
 			continue;
 		}
 		/* Static volumes only */
 		av = ubi_find_av(ai, i);
 		if (!av) {
 			/*
 			 * No eraseblocks belonging to this volume found. We
 			 * don't actually know whether this static volume is
 			 * completely corrupted or just contains no data. And
 			 * we cannot know this as long as data size is not
 			 * stored on flash. So we just assume the volume is
 			 * empty. FIXME: this should be handled.
 			 */
 			continue;
 		}
 		if (av->leb_count != av->used_ebs) {
 			/*
 			 * We found a static volume which misses several
 			 * eraseblocks. Treat it as corrupted.
 			 */
 			ubi_warn("static volume %d misses %d LEBs - corrupted",
 				 av->vol_id, av->used_ebs - av->leb_count);
 			vol->corrupted = 1;
 			continue;
 		}
 		vol->used_ebs = av->used_ebs;
 		vol->used_bytes =
 			(long long)(vol->used_ebs - 1) * vol->usable_leb_size;
 		vol->used_bytes += av->last_data_size;
 		vol->last_eb_bytes = av->last_data_size;
 	}
 	/* And add the layout volume */
 	vol = kzalloc(sizeof(struct ubi_volume), GFP_KERNEL);
 	if (!vol)
 		return -ENOMEM;
 	vol->reserved_pebs = UBI_LAYOUT_VOLUME_EBS;
 	vol->alignment = UBI_LAYOUT_VOLUME_ALIGN;
 	vol->vol_type = UBI_DYNAMIC_VOLUME;
 	vol->name_len = sizeof(UBI_LAYOUT_VOLUME_NAME) - 1;
 	memcpy(vol->name, UBI_LAYOUT_VOLUME_NAME, vol->name_len + 1);
 	vol->usable_leb_size = ubi->leb_size;
 	vol->used_ebs = vol->reserved_pebs;
 	vol->last_eb_bytes = vol->reserved_pebs;
 	vol->used_bytes =
 		(long long)vol->used_ebs * (ubi->leb_size - vol->data_pad);
 	vol->vol_id = UBI_LAYOUT_VOLUME_ID;
 	vol->ref_count = 1;
 	ubi_assert(!ubi->volumes[i]);
 	ubi->volumes[vol_id2idx(ubi, vol->vol_id)] = vol;
 	reserved_pebs += vol->reserved_pebs;
 	ubi->vol_count += 1;
 	vol->ubi = ubi;
 	if (reserved_pebs > ubi->avail_pebs) {
 		ubi_err("not enough PEBs, required %d, available %d",
 			reserved_pebs, ubi->avail_pebs);
 		if (ubi->corr_peb_count)
 			ubi_err("%d PEBs are corrupted and not used",
 				ubi->corr_peb_count);
 	}
 	ubi->rsvd_pebs += reserved_pebs;
 	ubi->avail_pebs -= reserved_pebs;
 	return 0;
 }
 /**
  * check_av - check volume attaching information.
  * @vol: UBI volume description object
  * @av: volume attaching information
  *
  * This function returns zero if the volume attaching information is consistent
  * to the data read from the volume tabla, and %-EINVAL if not.
  */
 static int check_av(const struct ubi_volume *vol,
 		    const struct ubi_ainf_volume *av)
 {
 	int err;
 	if (av->highest_lnum >= vol->reserved_pebs) {
 		err = 1;
 		goto bad;
 	}
 	if (av->leb_count > vol->reserved_pebs) {
 		err = 2;
 		goto bad;
 	}
 	if (av->vol_type != vol->vol_type) {
 		err = 3;
 		goto bad;
 	}
 	if (av->used_ebs > vol->reserved_pebs) {
 		err = 4;
 		goto bad;
 	}
 	if (av->data_pad != vol->data_pad) {
 		err = 5;
 		goto bad;
 	}
 	return 0;
 bad:
 	ubi_err("bad attaching information, error %d", err);
 	ubi_dump_av(av);
 	ubi_dump_vol_info(vol);
 	return -EINVAL;
 }
 /**
- * check_scanning_info - check that attaching information.
+ * check_attaching_info - check that attaching information.
  * @ubi: UBI device description object
  * @ai: attaching information
  *
  * Even though we protect on-flash data by CRC checksums, we still don't trust
  * the media. This function ensures that attaching information is consistent to
- * the information read from the volume table. Returns zero if the scanning
+ * the information read from the volume table. Returns zero if the attaching
  * information is OK and %-EINVAL if it is not.
  */
-static int check_scanning_info(const struct ubi_device *ubi,
+static int check_attaching_info(const struct ubi_device *ubi,
 			       struct ubi_attach_info *ai)
 {
 	int err, i;
 	struct ubi_ainf_volume *av;
 	struct ubi_volume *vol;
 	if (ai->vols_found > UBI_INT_VOL_COUNT + ubi->vtbl_slots) {
-		ubi_err("scanning found %d volumes, maximum is %d + %d",
+		ubi_err("found %d volumes while attaching, maximum is %d + %d",
 			ai->vols_found, UBI_INT_VOL_COUNT, ubi->vtbl_slots);
 		return -EINVAL;
 	}
 	if (ai->highest_vol_id >= ubi->vtbl_slots + UBI_INT_VOL_COUNT &&
 	    ai->highest_vol_id < UBI_INTERNAL_VOL_START) {
-		ubi_err("too large volume ID %d found by scanning",
+		ubi_err("too large volume ID %d found", ai->highest_vol_id);
-			ai->highest_vol_id);
 		return -EINVAL;
 	}
 	for (i = 0; i < ubi->vtbl_slots + UBI_INT_VOL_COUNT; i++) {
 		cond_resched();
 		av = ubi_find_av(ai, i);
 		vol = ubi->volumes[i];
 		if (!vol) {
 			if (av)
 				ubi_remove_av(ai, av);
 			continue;
 		}
 		if (vol->reserved_pebs == 0) {
 			ubi_assert(i < ubi->vtbl_slots);
 			if (!av)
 				continue;
 			/*
-			 * During scanning we found a volume which does not
+			 * During attaching we found a volume which does not
 			 * exist according to the information in the volume
 			 * table. This must have happened due to an unclean
 			 * reboot while the volume was being removed. Discard
 			 * these eraseblocks.
 			 */
 			ubi_msg("finish volume %d removal", av->vol_id);
 			ubi_remove_av(ai, av);
 		} else if (av) {
 			err = check_av(vol, av);
 			if (err)
 				return err;
 		}
 	}
 	return 0;
 }
 /**
  * ubi_read_volume_table - read the volume table.
  * @ubi: UBI device description object
  * @ai: attaching information
  *
  * This function reads volume table, checks it, recover from errors if needed,
  * or creates it if needed. Returns zero in case of success and a negative
  * error code in case of failure.
  */
 int ubi_read_volume_table(struct ubi_device *ubi, struct ubi_attach_info *ai)
 {
 	int i, err;
 	struct ubi_ainf_volume *av;
 	empty_vtbl_record.crc = cpu_to_be32(0xf116c36b);
 	/*
 	 * The number of supported volumes is limited by the eraseblock size
 	 * and by the UBI_MAX_VOLUMES constant.
 	 */
 	ubi->vtbl_slots = ubi->leb_size / UBI_VTBL_RECORD_SIZE;
 	if (ubi->vtbl_slots > UBI_MAX_VOLUMES)
 		ubi->vtbl_slots = UBI_MAX_VOLUMES;
 	ubi->vtbl_size = ubi->vtbl_slots * UBI_VTBL_RECORD_SIZE;
 	ubi->vtbl_size = ALIGN(ubi->vtbl_size, ubi->min_io_size);
 	av = ubi_find_av(ai, UBI_LAYOUT_VOLUME_ID);
 	if (!av) {
 		/*
 		 * No logical eraseblocks belonging to the layout volume were
 		 * found. This could mean that the flash is just empty. In
 		 * this case we create empty layout volume.
 		 *
 		 * But if flash is not empty this must be a corruption or the
 		 * MTD device just contains garbage.
 		 */
 		if (ai->is_empty) {
 			ubi->vtbl = create_empty_lvol(ubi, ai);
 			if (IS_ERR(ubi->vtbl))
 				return PTR_ERR(ubi->vtbl);
 		} else {
 			ubi_err("the layout volume was not found");
 			return -EINVAL;
 		}
 	} else {
 		if (av->leb_count > UBI_LAYOUT_VOLUME_EBS) {
 			/* This must not happen with proper UBI images */
 			ubi_err("too many LEBs (%d) in layout volume",
 				av->leb_count);
 			return -EINVAL;
 		}
 		ubi->vtbl = process_lvol(ubi, ai, av);
 		if (IS_ERR(ubi->vtbl))
 			return PTR_ERR(ubi->vtbl);
 	}
 	ubi->avail_pebs = ubi->good_peb_count - ubi->corr_peb_count;
 	/*
 	 * The layout volume is OK, initialize the corresponding in-RAM data
 	 * structures.
 	 */
 	err = init_volumes(ubi, ai, ubi->vtbl);
 	if (err)
 		goto out_free;
 	/*
 	 * Make sure that the attaching information is consistent to the
 	 * information stored in the volume table.
 	 */
-	err = check_scanning_info(ubi, ai);
+	err = check_attaching_info(ubi, ai);
 	if (err)
 		goto out_free;
 	return 0;
 out_free:
 	vfree(ubi->vtbl);
 	for (i = 0; i < ubi->vtbl_slots + UBI_INT_VOL_COUNT; i++) {
 		kfree(ubi->volumes[i]);
 		ubi->volumes[i] = NULL;
 	}
 	return err;
 }
 /**
  * self_vtbl_check - check volume table.
  * @ubi: UBI device description object
  */
 static void self_vtbl_check(const struct ubi_device *ubi)
 {
 	if (!ubi->dbg->chk_gen)
 		return;
 	if (vtbl_check(ubi, ubi->vtbl)) {
 		ubi_err("self-check failed");
 		BUG();
 	}
 }