Merge branch 'linux-next' of git://git.infradead.org/~dedekind/ubi-2.6 (996abf05) · Commits · 戴 / test

drivers/mtd/ubi/build.c

+73 −26

Original line number	Diff line number	Diff line
		@@ -51,14 +51,13 @@
		* @name: MTD device name or number string
		* @vid_hdr_offs: VID header offset
		*/
		struct mtd_dev_param
		{
		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 mtd_devs = 0;
		static int mtd_devs;

		/* MTD devices specification parameters */
		static struct mtd_dev_param mtd_dev_param[UBI_MAX_DEVICES];
		@@ -160,8 +159,7 @@ void ubi_put_device(struct ubi_device *ubi)
		}

		/**
		* ubi_get_by_major - get UBI device description object by character device
		* major number.
		* 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
		@@ -354,16 +352,35 @@ static void kill_volumes(struct ubi_device *ubi)
		ubi_free_volume(ubi, ubi->volumes[i]);
		}

		/**
		* free_user_volumes - free all user volumes.
		* @ubi: UBI device description object
		*
		* Normally the volumes are freed at the release function of the volume device
		* objects. However, on error paths the volumes have to be freed before the
		* device objects have been initialized.
		*/
		static void free_user_volumes(struct ubi_device *ubi)
		{
		int i;

		for (i = 0; i < ubi->vtbl_slots; i++)
		if (ubi->volumes[i]) {
		kfree(ubi->volumes[i]->eba_tbl);
		kfree(ubi->volumes[i]);
		}
		}

		/**
		* uif_init - initialize user interfaces for an UBI device.
		* @ubi: UBI device description object
		*
		* This function returns zero in case of success and a negative error code in
		* case of failure.
		* case of failure. Note, this function destroys all volumes if it failes.
		*/
		static int uif_init(struct ubi_device *ubi)
		{
		int i, err;
		int i, err, do_free = 0;
		dev_t dev;

		sprintf(ubi->ubi_name, UBI_NAME_STR "%d", ubi->ubi_num);
		@@ -384,7 +401,7 @@ static int uif_init(struct ubi_device *ubi)

		ubi_assert(MINOR(dev) == 0);
		cdev_init(&ubi->cdev, &ubi_cdev_operations);
		dbg_msg("%s major is %u", ubi->ubi_name, MAJOR(dev));
		dbg_gen("%s major is %u", ubi->ubi_name, MAJOR(dev));
		ubi->cdev.owner = THIS_MODULE;

		err = cdev_add(&ubi->cdev, dev, 1);
		@@ -410,10 +427,13 @@ static int uif_init(struct ubi_device *ubi)

		out_volumes:
		kill_volumes(ubi);
		do_free = 0;
		out_sysfs:
		ubi_sysfs_close(ubi);
		cdev_del(&ubi->cdev);
		out_unreg:
		if (do_free)
		free_user_volumes(ubi);
		unregister_chrdev_region(ubi->cdev.dev, ubi->vtbl_slots + 1);
		ubi_err("cannot initialize UBI %s, error %d", ubi->ubi_name, err);
		return err;
		@@ -422,6 +442,10 @@ out_unreg:
		/**
		* 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)
		{
		@@ -431,6 +455,21 @@ static void uif_close(struct ubi_device *ubi)
		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
		@@ -475,6 +514,7 @@ static int attach_by_scanning(struct ubi_device *ubi)
		out_wl:
		ubi_wl_close(ubi);
		out_vtbl:
		free_internal_volumes(ubi);
		vfree(ubi->vtbl);
		out_si:
		ubi_scan_destroy_si(si);
		@@ -482,7 +522,7 @@ out_si:
		}

		/**
		* io_init - initialize I/O unit for a given UBI device.
		* 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
		@@ -530,7 +570,11 @@ static int io_init(struct ubi_device *ubi)
		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 */
		/*
		* 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);
		@@ -581,7 +625,7 @@ static int io_init(struct ubi_device *ubi)
		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) {
		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;
		@@ -646,7 +690,7 @@ static int autoresize(struct ubi_device *ubi, int vol_id)

		/*
		* Clear the auto-resize flag in the volume in-memory copy of the
		* volume table, and 'ubi_resize_volume()' will propogate this change
		* volume table, and 'ubi_resize_volume()' will propagate this change
		* to the flash.
		*/
		ubi->vtbl[vol_id].flags &= ~UBI_VTBL_AUTORESIZE_FLG;
		@@ -655,7 +699,7 @@ static int autoresize(struct ubi_device *ubi, int vol_id)
		struct ubi_vtbl_record vtbl_rec;

		/*
		* No avalilable PEBs to re-size the volume, clear the flag on
		* No available PEBs to re-size the volume, clear the flag on
		* flash and exit.
		*/
		memcpy(&vtbl_rec, &ubi->vtbl[vol_id],
		@@ -682,13 +726,13 @@ static int autoresize(struct ubi_device *ubi, int vol_id)

		/**
		* ubi_attach_mtd_dev - attach an MTD device.
		* @mtd_dev: MTD device description object
		* @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 nubert and assings it
		* 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.
		*
		@@ -698,7 +742,7 @@ static int autoresize(struct ubi_device *ubi, int vol_id)
		int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num, int vid_hdr_offset)
		{
		struct ubi_device *ubi;
		int i, err;
		int i, err, do_free = 1;

		/*
		* Check if we already have the same MTD device attached.
		@@ -735,7 +779,8 @@ int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num, int vid_hdr_offset)
		if (!ubi_devices[ubi_num])
		break;
		if (ubi_num == UBI_MAX_DEVICES) {
		dbg_err("only %d UBI devices may be created", UBI_MAX_DEVICES);
		dbg_err("only %d UBI devices may be created",
		UBI_MAX_DEVICES);
		return -ENFILE;
		}
		} else {
		@@ -760,6 +805,7 @@ int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num, int vid_hdr_offset)

		mutex_init(&ubi->buf_mutex);
		mutex_init(&ubi->ckvol_mutex);
		mutex_init(&ubi->mult_mutex);
		mutex_init(&ubi->volumes_mutex);
		spin_lock_init(&ubi->volumes_lock);

		@@ -798,7 +844,7 @@ int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num, int vid_hdr_offset)

		err = uif_init(ubi);
		if (err)
		goto out_detach;
		goto out_nofree;

		ubi->bgt_thread = kthread_create(ubi_thread, ubi, ubi->bgt_name);
		if (IS_ERR(ubi->bgt_thread)) {
		@@ -824,20 +870,22 @@ int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num, int vid_hdr_offset)
		ubi->beb_rsvd_pebs);
		ubi_msg("max/mean erase counter: %d/%d", ubi->max_ec, ubi->mean_ec);

		/* Enable the background thread */
		if (!DBG_DISABLE_BGT) {
		if (!DBG_DISABLE_BGT)
		ubi->thread_enabled = 1;
		wake_up_process(ubi->bgt_thread);
		}

		ubi_devices[ubi_num] = ubi;
		return ubi_num;

		out_uif:
		uif_close(ubi);
		out_nofree:
		do_free = 0;
		out_detach:
		ubi_eba_close(ubi);
		ubi_wl_close(ubi);
		if (do_free)
		free_user_volumes(ubi);
		free_internal_volumes(ubi);
		vfree(ubi->vtbl);
		out_free:
		vfree(ubi->peb_buf1);
		@@ -899,8 +947,8 @@ int ubi_detach_mtd_dev(int ubi_num, int anyway)
		kthread_stop(ubi->bgt_thread);

		uif_close(ubi);
		ubi_eba_close(ubi);
		ubi_wl_close(ubi);
		free_internal_volumes(ubi);
		vfree(ubi->vtbl);
		put_mtd_device(ubi->mtd);
		vfree(ubi->peb_buf1);
		@@ -1044,8 +1092,7 @@ static void __exit ubi_exit(void)
		module_exit(ubi_exit);

		/**
		* bytes_str_to_int - convert a string representing number of bytes to an
		* integer.
		* 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

drivers/mtd/ubi/cdev.c

+212 −22

Original line number	Diff line number	Diff line
		@@ -39,9 +39,9 @@
		#include <linux/stat.h>
		#include <linux/ioctl.h>
		#include <linux/capability.h>
		#include <linux/uaccess.h>
		#include <linux/smp_lock.h>
		#include <mtd/ubi-user.h>
		#include <asm/uaccess.h>
		#include <asm/div64.h>
		#include "ubi.h"

		@@ -116,7 +116,7 @@ static int vol_cdev_open(struct inode inode, struct file file)
		else
		mode = UBI_READONLY;

		dbg_msg("open volume %d, mode %d", vol_id, mode);
		dbg_gen("open volume %d, mode %d", vol_id, mode);

		desc = ubi_open_volume(ubi_num, vol_id, mode);
		unlock_kernel();
		@@ -132,7 +132,7 @@ static int vol_cdev_release(struct inode inode, struct file file)
		struct ubi_volume_desc *desc = file->private_data;
		struct ubi_volume *vol = desc->vol;

		dbg_msg("release volume %d, mode %d", vol->vol_id, desc->mode);
		dbg_gen("release volume %d, mode %d", vol->vol_id, desc->mode);

		if (vol->updating) {
		ubi_warn("update of volume %d not finished, volume is damaged",
		@@ -141,7 +141,7 @@ static int vol_cdev_release(struct inode inode, struct file file)
		vol->updating = 0;
		vfree(vol->upd_buf);
		} else if (vol->changing_leb) {
		dbg_msg("only %lld of %lld bytes received for atomic LEB change"
		dbg_gen("only %lld of %lld bytes received for atomic LEB change"
		" for volume %d:%d, cancel", vol->upd_received,
		vol->upd_bytes, vol->ubi->ubi_num, vol->vol_id);
		vol->changing_leb = 0;
		@@ -183,7 +183,7 @@ static loff_t vol_cdev_llseek(struct file *file, loff_t offset, int origin)
		return -EINVAL;
		}

		dbg_msg("seek volume %d, offset %lld, origin %d, new offset %lld",
		dbg_gen("seek volume %d, offset %lld, origin %d, new offset %lld",
		vol->vol_id, offset, origin, new_offset);

		file->f_pos = new_offset;
		@@ -201,7 +201,7 @@ static ssize_t vol_cdev_read(struct file file, __user char buf, size_t count,
		void *tbuf;
		uint64_t tmp;

		dbg_msg("read %zd bytes from offset %lld of volume %d",
		dbg_gen("read %zd bytes from offset %lld of volume %d",
		count, *offp, vol->vol_id);

		if (vol->updating) {
		@@ -216,7 +216,7 @@ static ssize_t vol_cdev_read(struct file file, __user char buf, size_t count,
		return 0;

		if (vol->corrupted)
		dbg_msg("read from corrupted volume %d", vol->vol_id);
		dbg_gen("read from corrupted volume %d", vol->vol_id);

		if (*offp + count > vol->used_bytes)
		count_save = count = vol->used_bytes - *offp;
		@@ -285,7 +285,7 @@ static ssize_t vol_cdev_direct_write(struct file file, const char __user buf,
		char *tbuf;
		uint64_t tmp;

		dbg_msg("requested: write %zd bytes to offset %lld of volume %u",
		dbg_gen("requested: write %zd bytes to offset %lld of volume %u",
		count, *offp, vol->vol_id);

		if (vol->vol_type == UBI_STATIC_VOLUME)
		@@ -295,7 +295,7 @@ static ssize_t vol_cdev_direct_write(struct file file, const char __user buf,
		off = do_div(tmp, vol->usable_leb_size);
		lnum = tmp;

		if (off % ubi->min_io_size) {
		if (off & (ubi->min_io_size - 1)) {
		dbg_err("unaligned position");
		return -EINVAL;
		}
		@@ -304,7 +304,7 @@ static ssize_t vol_cdev_direct_write(struct file file, const char __user buf,
		count_save = count = vol->used_bytes - *offp;

		/* We can write only in fractions of the minimum I/O unit */
		if (count % ubi->min_io_size) {
		if (count & (ubi->min_io_size - 1)) {
		dbg_err("unaligned write length");
		return -EINVAL;
		}
		@@ -352,7 +352,7 @@ static ssize_t vol_cdev_direct_write(struct file file, const char __user buf,
		}

		#else
		#define vol_cdev_direct_write(file, buf, count, offp) -EPERM
		#define vol_cdev_direct_write(file, buf, count, offp) (-EPERM)
		#endif /* CONFIG_MTD_UBI_DEBUG_USERSPACE_IO */

		static ssize_t vol_cdev_write(struct file file, const char __user buf,
		@@ -437,7 +437,8 @@ static int vol_cdev_ioctl(struct inode inode, struct file file,
		break;
		}

		rsvd_bytes = vol->reserved_pebs * (ubi->leb_size-vol->data_pad);
		rsvd_bytes = (long long)vol->reserved_pebs *
		ubi->leb_size-vol->data_pad;
		if (bytes < 0 \|\| bytes > rsvd_bytes) {
		err = -EINVAL;
		break;
		@@ -513,7 +514,7 @@ static int vol_cdev_ioctl(struct inode inode, struct file file,
		break;
		}

		dbg_msg("erase LEB %d:%d", vol->vol_id, lnum);
		dbg_gen("erase LEB %d:%d", vol->vol_id, lnum);
		err = ubi_eba_unmap_leb(ubi, vol, lnum);
		if (err)
		break;
		@@ -564,7 +565,7 @@ static int verify_mkvol_req(const struct ubi_device *ubi,
		if (req->alignment > ubi->leb_size)
		goto bad;

		n = req->alignment % ubi->min_io_size;
		n = req->alignment & (ubi->min_io_size - 1);
		if (req->alignment != 1 && n)
		goto bad;

		@@ -573,6 +574,10 @@ static int verify_mkvol_req(const struct ubi_device *ubi,
		goto bad;
		}

		n = strnlen(req->name, req->name_len + 1);
		if (n != req->name_len)
		goto bad;

		return 0;

		bad:
		@@ -600,6 +605,166 @@ static int verify_rsvol_req(const struct ubi_device *ubi,
		return 0;
		}

		/**
		* rename_volumes - rename UBI volumes.
		* @ubi: UBI device description object
		* @req: volumes re-name request
		*
		* This is a helper function for the volume re-name IOCTL which validates the
		* the request, opens the volume and calls corresponding volumes management
		* function. Returns zero in case of success and a negative error code in case
		* of failure.
		*/
		static int rename_volumes(struct ubi_device *ubi,
		struct ubi_rnvol_req *req)
		{
		int i, n, err;
		struct list_head rename_list;
		struct ubi_rename_entry re, re1;

		if (req->count < 0 \|\| req->count > UBI_MAX_RNVOL)
		return -EINVAL;

		if (req->count == 0)
		return 0;

		/* Validate volume IDs and names in the request */
		for (i = 0; i < req->count; i++) {
		if (req->ents[i].vol_id < 0 \|\|
		req->ents[i].vol_id >= ubi->vtbl_slots)
		return -EINVAL;
		if (req->ents[i].name_len < 0)
		return -EINVAL;
		if (req->ents[i].name_len > UBI_VOL_NAME_MAX)
		return -ENAMETOOLONG;
		req->ents[i].name[req->ents[i].name_len] = '\0';
		n = strlen(req->ents[i].name);
		if (n != req->ents[i].name_len)
		err = -EINVAL;
		}

		/* Make sure volume IDs and names are unique */
		for (i = 0; i < req->count - 1; i++) {
		for (n = i + 1; n < req->count; n++) {
		if (req->ents[i].vol_id == req->ents[n].vol_id) {
		dbg_err("duplicated volume id %d",
		req->ents[i].vol_id);
		return -EINVAL;
		}
		if (!strcmp(req->ents[i].name, req->ents[n].name)) {
		dbg_err("duplicated volume name \"%s\"",
		req->ents[i].name);
		return -EINVAL;
		}
		}
		}

		/* Create the re-name list */
		INIT_LIST_HEAD(&rename_list);
		for (i = 0; i < req->count; i++) {
		int vol_id = req->ents[i].vol_id;
		int name_len = req->ents[i].name_len;
		const char *name = req->ents[i].name;

		re = kzalloc(sizeof(struct ubi_rename_entry), GFP_KERNEL);
		if (!re) {
		err = -ENOMEM;
		goto out_free;
		}

		re->desc = ubi_open_volume(ubi->ubi_num, vol_id, UBI_EXCLUSIVE);
		if (IS_ERR(re->desc)) {
		err = PTR_ERR(re->desc);
		dbg_err("cannot open volume %d, error %d", vol_id, err);
		kfree(re);
		goto out_free;
		}

		/* Skip this re-naming if the name does not really change */
		if (re->desc->vol->name_len == name_len &&
		!memcmp(re->desc->vol->name, name, name_len)) {
		ubi_close_volume(re->desc);
		kfree(re);
		continue;
		}

		re->new_name_len = name_len;
		memcpy(re->new_name, name, name_len);
		list_add_tail(&re->list, &rename_list);
		dbg_msg("will rename volume %d from \"%s\" to \"%s\"",
		vol_id, re->desc->vol->name, name);
		}

		if (list_empty(&rename_list))
		return 0;

		/* Find out the volumes which have to be removed */
		list_for_each_entry(re, &rename_list, list) {
		struct ubi_volume_desc *desc;
		int no_remove_needed = 0;

		/*
		* Volume @re->vol_id is going to be re-named to
		* @re->new_name, while its current name is @name. If a volume
		* with name @re->new_name currently exists, it has to be
		* removed, unless it is also re-named in the request (@req).
		*/
		list_for_each_entry(re1, &rename_list, list) {
		if (re->new_name_len == re1->desc->vol->name_len &&
		!memcmp(re->new_name, re1->desc->vol->name,
		re1->desc->vol->name_len)) {
		no_remove_needed = 1;
		break;
		}
		}

		if (no_remove_needed)
		continue;

		/*
		* It seems we need to remove volume with name @re->new_name,
		* if it exists.
		*/
		desc = ubi_open_volume_nm(ubi->ubi_num, re->new_name, UBI_EXCLUSIVE);
		if (IS_ERR(desc)) {
		err = PTR_ERR(desc);
		if (err == -ENODEV)
		/* Re-naming into a non-existing volume name */
		continue;

		/* The volume exists but busy, or an error occurred */
		dbg_err("cannot open volume \"%s\", error %d",
		re->new_name, err);
		goto out_free;
		}

		re = kzalloc(sizeof(struct ubi_rename_entry), GFP_KERNEL);
		if (!re) {
		err = -ENOMEM;
		ubi_close_volume(desc);
		goto out_free;
		}

		re->remove = 1;
		re->desc = desc;
		list_add(&re->list, &rename_list);
		dbg_msg("will remove volume %d, name \"%s\"",
		re->desc->vol->vol_id, re->desc->vol->name);
		}

		mutex_lock(&ubi->volumes_mutex);
		err = ubi_rename_volumes(ubi, &rename_list);
		mutex_unlock(&ubi->volumes_mutex);

		out_free:
		list_for_each_entry_safe(re, re1, &rename_list, list) {
		ubi_close_volume(re->desc);
		list_del(&re->list);
		kfree(re);
		}
		return err;
		}

		static int ubi_cdev_ioctl(struct inode inode, struct file file,
		unsigned int cmd, unsigned long arg)
		{
		@@ -621,19 +786,18 @@ static int ubi_cdev_ioctl(struct inode inode, struct file file,
		{
		struct ubi_mkvol_req req;

		dbg_msg("create volume");
		dbg_gen("create volume");
		err = copy_from_user(&req, argp, sizeof(struct ubi_mkvol_req));
		if (err) {
		err = -EFAULT;
		break;
		}

		req.name[req.name_len] = '\0';
		err = verify_mkvol_req(ubi, &req);
		if (err)
		break;

		req.name[req.name_len] = '\0';

		mutex_lock(&ubi->volumes_mutex);
		err = ubi_create_volume(ubi, &req);
		mutex_unlock(&ubi->volumes_mutex);
		@@ -652,7 +816,7 @@ static int ubi_cdev_ioctl(struct inode inode, struct file file,
		{
		int vol_id;

		dbg_msg("remove volume");
		dbg_gen("remove volume");
		err = get_user(vol_id, (__user int32_t *)argp);
		if (err) {
		err = -EFAULT;
		@@ -666,7 +830,7 @@ static int ubi_cdev_ioctl(struct inode inode, struct file file,
		}

		mutex_lock(&ubi->volumes_mutex);
		err = ubi_remove_volume(desc);
		err = ubi_remove_volume(desc, 0);
		mutex_unlock(&ubi->volumes_mutex);

		/*
		@@ -685,7 +849,7 @@ static int ubi_cdev_ioctl(struct inode inode, struct file file,
		uint64_t tmp;
		struct ubi_rsvol_req req;

		dbg_msg("re-size volume");
		dbg_gen("re-size volume");
		err = copy_from_user(&req, argp, sizeof(struct ubi_rsvol_req));
		if (err) {
		err = -EFAULT;
		@@ -713,6 +877,32 @@ static int ubi_cdev_ioctl(struct inode inode, struct file file,
		break;
		}

		/* Re-name volumes command */
		case UBI_IOCRNVOL:
		{
		struct ubi_rnvol_req *req;

		dbg_msg("re-name volumes");
		req = kmalloc(sizeof(struct ubi_rnvol_req), GFP_KERNEL);
		if (!req) {
		err = -ENOMEM;
		break;
		};

		err = copy_from_user(req, argp, sizeof(struct ubi_rnvol_req));
		if (err) {
		err = -EFAULT;
		kfree(req);
		break;
		}

		mutex_lock(&ubi->mult_mutex);
		err = rename_volumes(ubi, req);
		mutex_unlock(&ubi->mult_mutex);
		kfree(req);
		break;
		}

		default:
		err = -ENOTTY;
		break;
		@@ -738,7 +928,7 @@ static int ctrl_cdev_ioctl(struct inode inode, struct file file,
		struct ubi_attach_req req;
		struct mtd_info *mtd;

		dbg_msg("attach MTD device");
		dbg_gen("attach MTD device");
		err = copy_from_user(&req, argp, sizeof(struct ubi_attach_req));
		if (err) {
		err = -EFAULT;
		@@ -778,7 +968,7 @@ static int ctrl_cdev_ioctl(struct inode inode, struct file file,
		{
		int ubi_num;

		dbg_msg("dettach MTD device");
		dbg_gen("dettach MTD device");
		err = get_user(ubi_num, (__user int32_t *)argp);
		if (err) {
		err = -EFAULT;

drivers/mtd/ubi/debug.c

+82 −76

File changed.

Preview size limit exceeded, changes collapsed.

drivers/mtd/ubi/debug.h

+47 −27

Original line number	Diff line number	Diff line
		@@ -24,21 +24,16 @@
		#ifdef CONFIG_MTD_UBI_DEBUG
		#include <linux/random.h>

		#define ubi_assert(expr) BUG_ON(!(expr))
		#define dbg_err(fmt, ...) ubi_err(fmt, ##__VA_ARGS__)
		#else
		#define ubi_assert(expr) ({})
		#define dbg_err(fmt, ...) ({})
		#endif

		#ifdef CONFIG_MTD_UBI_DEBUG_DISABLE_BGT
		#define DBG_DISABLE_BGT 1
		#else
		#define DBG_DISABLE_BGT 0
		#endif
		#define ubi_assert(expr) do { \
		if (unlikely(!(expr))) { \
		printk(KERN_CRIT "UBI assert failed in %s at %u (pid %d)\n", \
		__func__, __LINE__, current->pid); \
		ubi_dbg_dump_stack(); \
		} \
		} while (0)

		#ifdef CONFIG_MTD_UBI_DEBUG_MSG
		/* Generic debugging message */
		#define dbg_msg(fmt, ...) \
		printk(KERN_DEBUG "UBI DBG (pid %d): %s: " fmt "\n", \
		current->pid, __func__, ##__VA_ARGS__)
		@@ -61,36 +56,29 @@ void ubi_dbg_dump_sv(const struct ubi_scan_volume *sv);
		void ubi_dbg_dump_seb(const struct ubi_scan_leb *seb, int type);
		void ubi_dbg_dump_mkvol_req(const struct ubi_mkvol_req *req);

		#ifdef CONFIG_MTD_UBI_DEBUG_MSG
		/* General debugging messages */
		#define dbg_gen(fmt, ...) dbg_msg(fmt, ##__VA_ARGS__)
		#else

		#define dbg_msg(fmt, ...) ({})
		#define ubi_dbg_dump_stack() ({})
		#define ubi_dbg_dump_ec_hdr(ec_hdr) ({})
		#define ubi_dbg_dump_vid_hdr(vid_hdr) ({})
		#define ubi_dbg_dump_vol_info(vol) ({})
		#define ubi_dbg_dump_vtbl_record(r, idx) ({})
		#define ubi_dbg_dump_sv(sv) ({})
		#define ubi_dbg_dump_seb(seb, type) ({})
		#define ubi_dbg_dump_mkvol_req(req) ({})

		#endif /* CONFIG_MTD_UBI_DEBUG_MSG */
		#define dbg_gen(fmt, ...) ({})
		#endif

		#ifdef CONFIG_MTD_UBI_DEBUG_MSG_EBA
		/* Messages from the eraseblock association unit */
		/* Messages from the eraseblock association sub-system */
		#define dbg_eba(fmt, ...) dbg_msg(fmt, ##__VA_ARGS__)
		#else
		#define dbg_eba(fmt, ...) ({})
		#endif

		#ifdef CONFIG_MTD_UBI_DEBUG_MSG_WL
		/* Messages from the wear-leveling unit */
		/* Messages from the wear-leveling sub-system */
		#define dbg_wl(fmt, ...) dbg_msg(fmt, ##__VA_ARGS__)
		#else
		#define dbg_wl(fmt, ...) ({})
		#endif

		#ifdef CONFIG_MTD_UBI_DEBUG_MSG_IO
		/* Messages from the input/output unit */
		/* Messages from the input/output sub-system */
		#define dbg_io(fmt, ...) dbg_msg(fmt, ##__VA_ARGS__)
		#else
		#define dbg_io(fmt, ...) ({})
		@@ -105,6 +93,12 @@ void ubi_dbg_dump_mkvol_req(const struct ubi_mkvol_req *req);
		#define UBI_IO_DEBUG 0
		#endif

		#ifdef CONFIG_MTD_UBI_DEBUG_DISABLE_BGT
		#define DBG_DISABLE_BGT 1
		#else
		#define DBG_DISABLE_BGT 0
		#endif

		#ifdef CONFIG_MTD_UBI_DEBUG_EMULATE_BITFLIPS
		/**
		* ubi_dbg_is_bitflip - if it is time to emulate a bit-flip.
		@@ -149,4 +143,30 @@ static inline int ubi_dbg_is_erase_failure(void)
		#define ubi_dbg_is_erase_failure() 0
		#endif

		#else

		#define ubi_assert(expr) ({})
		#define dbg_err(fmt, ...) ({})
		#define dbg_msg(fmt, ...) ({})
		#define dbg_gen(fmt, ...) ({})
		#define dbg_eba(fmt, ...) ({})
		#define dbg_wl(fmt, ...) ({})
		#define dbg_io(fmt, ...) ({})
		#define dbg_bld(fmt, ...) ({})
		#define ubi_dbg_dump_stack() ({})
		#define ubi_dbg_dump_ec_hdr(ec_hdr) ({})
		#define ubi_dbg_dump_vid_hdr(vid_hdr) ({})
		#define ubi_dbg_dump_vol_info(vol) ({})
		#define ubi_dbg_dump_vtbl_record(r, idx) ({})
		#define ubi_dbg_dump_sv(sv) ({})
		#define ubi_dbg_dump_seb(seb, type) ({})
		#define ubi_dbg_dump_mkvol_req(req) ({})

		#define UBI_IO_DEBUG 0
		#define DBG_DISABLE_BGT 0
		#define ubi_dbg_is_bitflip() 0
		#define ubi_dbg_is_write_failure() 0
		#define ubi_dbg_is_erase_failure() 0

		#endif /* !CONFIG_MTD_UBI_DEBUG */
		#endif /* !__UBI_DEBUG_H__ */

drivers/mtd/ubi/eba.c

+22 −55

Original line number	Diff line number	Diff line
		@@ -19,20 +19,20 @@
		*/

		/*
		* The UBI Eraseblock Association (EBA) unit.
		* The UBI Eraseblock Association (EBA) sub-system.
		*
		* This unit is responsible for I/O to/from logical eraseblock.
		* This sub-system is responsible for I/O to/from logical eraseblock.
		*
		* Although in this implementation the EBA table is fully kept and managed in
		* RAM, which assumes poor scalability, it might be (partially) maintained on
		* flash in future implementations.
		*
		* The EBA unit implements per-logical eraseblock locking. Before accessing a
		* logical eraseblock it is locked for reading or writing. The per-logical
		* eraseblock locking is implemented by means of the lock tree. The lock tree
		* is an RB-tree which refers all the currently locked logical eraseblocks. The
		* lock tree elements are &struct ubi_ltree_entry objects. They are indexed by
		* (@vol_id, @lnum) pairs.
		* The EBA sub-system implements per-logical eraseblock locking. Before
		* accessing a logical eraseblock it is locked for reading or writing. The
		* per-logical eraseblock locking is implemented by means of the lock tree. The
		* lock tree is an RB-tree which refers all the currently locked logical
		* eraseblocks. The lock tree elements are &struct ubi_ltree_entry objects.
		* They are indexed by (@vol_id, @lnum) pairs.
		*
		* EBA also maintains the global sequence counter which is incremented each
		* time a logical eraseblock is mapped to a physical eraseblock and it is
		@@ -189,9 +189,7 @@ static struct ubi_ltree_entry ltree_add_entry(struct ubi_device ubi,
		le->users += 1;
		spin_unlock(&ubi->ltree_lock);

		if (le_free)
		kfree(le_free);

		return le;
		}

		@@ -223,22 +221,18 @@ static int leb_read_lock(struct ubi_device *ubi, int vol_id, int lnum)
		*/
		static void leb_read_unlock(struct ubi_device *ubi, int vol_id, int lnum)
		{
		int free = 0;
		struct ubi_ltree_entry *le;

		spin_lock(&ubi->ltree_lock);
		le = ltree_lookup(ubi, vol_id, lnum);
		le->users -= 1;
		ubi_assert(le->users >= 0);
		up_read(&le->mutex);
		if (le->users == 0) {
		rb_erase(&le->rb, &ubi->ltree);
		free = 1;
		kfree(le);
		}
		spin_unlock(&ubi->ltree_lock);

		up_read(&le->mutex);
		if (free)
		kfree(le);
		}

		/**
		@@ -274,7 +268,6 @@ static int leb_write_lock(struct ubi_device *ubi, int vol_id, int lnum)
		*/
		static int leb_write_trylock(struct ubi_device *ubi, int vol_id, int lnum)
		{
		int free;
		struct ubi_ltree_entry *le;

		le = ltree_add_entry(ubi, vol_id, lnum);
		@@ -289,12 +282,9 @@ static int leb_write_trylock(struct ubi_device *ubi, int vol_id, int lnum)
		ubi_assert(le->users >= 0);
		if (le->users == 0) {
		rb_erase(&le->rb, &ubi->ltree);
		free = 1;
		} else
		free = 0;
		spin_unlock(&ubi->ltree_lock);
		if (free)
		kfree(le);
		}
		spin_unlock(&ubi->ltree_lock);

		return 1;
		}
		@@ -307,24 +297,19 @@ static int leb_write_trylock(struct ubi_device *ubi, int vol_id, int lnum)
		*/
		static void leb_write_unlock(struct ubi_device *ubi, int vol_id, int lnum)
		{
		int free;
		struct ubi_ltree_entry *le;

		spin_lock(&ubi->ltree_lock);
		le = ltree_lookup(ubi, vol_id, lnum);
		le->users -= 1;
		ubi_assert(le->users >= 0);
		up_write(&le->mutex);
		if (le->users == 0) {
		rb_erase(&le->rb, &ubi->ltree);
		free = 1;
		} else
		free = 0;
		spin_unlock(&ubi->ltree_lock);

		up_write(&le->mutex);
		if (free)
		kfree(le);
		}
		spin_unlock(&ubi->ltree_lock);
		}

		/**
		* ubi_eba_unmap_leb - un-map logical eraseblock.
		@@ -516,9 +501,8 @@ static int recover_peb(struct ubi_device *ubi, int pnum, int vol_id, int lnum,
		struct ubi_vid_hdr *vid_hdr;

		vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS);
		if (!vid_hdr) {
		if (!vid_hdr)
		return -ENOMEM;
		}

		mutex_lock(&ubi->buf_mutex);

		@@ -752,7 +736,7 @@ int ubi_eba_write_leb_st(struct ubi_device ubi, struct ubi_volume vol,
		/* If this is the last LEB @len may be unaligned */
		len = ALIGN(data_size, ubi->min_io_size);
		else
		ubi_assert(len % ubi->min_io_size == 0);
		ubi_assert(!(len & (ubi->min_io_size - 1)));

		vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS);
		if (!vid_hdr)
		@@ -919,7 +903,7 @@ retry:
		}

		if (vol->eba_tbl[lnum] >= 0) {
		err = ubi_wl_put_peb(ubi, vol->eba_tbl[lnum], 1);
		err = ubi_wl_put_peb(ubi, vol->eba_tbl[lnum], 0);
		if (err)
		goto out_leb_unlock;
		}
		@@ -1141,7 +1125,7 @@ out_unlock_leb:
		}

		/**
		* ubi_eba_init_scan - initialize the EBA unit using scanning information.
		* ubi_eba_init_scan - initialize the EBA sub-system using scanning information.
		* @ubi: UBI device description object
		* @si: scanning information
		*
		@@ -1156,7 +1140,7 @@ int ubi_eba_init_scan(struct ubi_device ubi, struct ubi_scan_info si)
		struct ubi_scan_leb *seb;
		struct rb_node *rb;

		dbg_eba("initialize EBA unit");
		dbg_eba("initialize EBA sub-system");

		spin_lock_init(&ubi->ltree_lock);
		mutex_init(&ubi->alc_mutex);
		@@ -1222,7 +1206,7 @@ int ubi_eba_init_scan(struct ubi_device ubi, struct ubi_scan_info si)
		ubi->rsvd_pebs += ubi->beb_rsvd_pebs;
		}

		dbg_eba("EBA unit is initialized");
		dbg_eba("EBA sub-system is initialized");
		return 0;

		out_free:
		@@ -1233,20 +1217,3 @@ out_free:
		}
		return err;
		}

		/**
		* ubi_eba_close - close EBA unit.
		* @ubi: UBI device description object
		*/
		void ubi_eba_close(const struct ubi_device *ubi)
		{
		int i, num_volumes = ubi->vtbl_slots + UBI_INT_VOL_COUNT;

		dbg_eba("close EBA unit");

		for (i = 0; i < num_volumes; i++) {
		if (!ubi->volumes[i])
		continue;
		kfree(ubi->volumes[i]->eba_tbl);
		}
		}

Admin message