Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 32608703 authored by Tanya Brokhman's avatar Tanya Brokhman Committed by Artem Bityutskiy
Browse files

UBI: Extend UBI layer debug/messaging capabilities 



If there is more then one UBI device mounted, there is no way to
distinguish between messages from different UBI devices.
Add device number to all ubi layer message types.

The R/O block driver messages were replaced by pr_* since
ubi_device structure is not used by it.

Amended a bit by Artem.

Signed-off-by: default avatarTanya Brokhman <tlinder@codeaurora.org>
Signed-off-by: default avatarArtem Bityutskiy <artem.bityutskiy@linux.intel.com>
parent 789c8993

drivers/mtd/ubi/attach.c

+66 −60
Original line number Diff line number Diff line
@@ -176,6 +176,7 @@ static int add_corrupted(struct ubi_attach_info *ai, int pnum, int ec) 


/**

 * validate_vid_hdr - check volume identifier header.

 * @ubi: UBI device description object

 * @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
@@ -188,7 +189,8 @@ static int add_corrupted(struct ubi_attach_info *ai, int pnum, int ec) 
 * 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,

static int validate_vid_hdr(const struct ubi_device *ubi,

			    const struct ubi_vid_hdr *vid_hdr,

			    const struct ubi_ainf_volume *av, int pnum)

{

	int vol_type = vid_hdr->vol_type;
@@ -206,7 +208,7 @@ static int validate_vid_hdr(const struct ubi_vid_hdr *vid_hdr, 
		 */



		if (vol_id != av->vol_id) {

			ubi_err("inconsistent vol_id");

			ubi_err(ubi, "inconsistent vol_id");

			goto bad;

		}
@@ -216,17 +218,17 @@ static int validate_vid_hdr(const struct ubi_vid_hdr *vid_hdr, 
			av_vol_type = UBI_VID_DYNAMIC;



		if (vol_type != av_vol_type) {

			ubi_err("inconsistent vol_type");

			ubi_err(ubi, "inconsistent vol_type");

			goto bad;

		}



		if (used_ebs != av->used_ebs) {

			ubi_err("inconsistent used_ebs");

			ubi_err(ubi, "inconsistent used_ebs");

			goto bad;

		}



		if (data_pad != av->data_pad) {

			ubi_err("inconsistent data_pad");

			ubi_err(ubi, "inconsistent data_pad");

			goto bad;

		}

	}
@@ -234,7 +236,7 @@ static int validate_vid_hdr(const struct ubi_vid_hdr *vid_hdr, 
	return 0;



bad:

	ubi_err("inconsistent VID header at PEB %d", pnum);

	ubi_err(ubi, "inconsistent VID header at PEB %d", pnum);

	ubi_dump_vid_hdr(vid_hdr);

	ubi_dump_av(av);

	return -EINVAL;
@@ -336,7 +338,7 @@ int ubi_compare_lebs(struct ubi_device *ubi, const struct ubi_ainf_peb *aeb, 
		 * support these images anymore. Well, those images still work,

		 * but only if no unclean reboots happened.

		 */

		ubi_err("unsupported on-flash UBI format");

		ubi_err(ubi, "unsupported on-flash UBI format");

		return -EINVAL;

	}
@@ -377,7 +379,7 @@ int ubi_compare_lebs(struct ubi_device *ubi, const struct ubi_ainf_peb *aeb, 
			if (err == UBI_IO_BITFLIPS)

				bitflips = 1;

			else {

				ubi_err("VID of PEB %d header is bad, but it was OK earlier, err %d",

				ubi_err(ubi, "VID of PEB %d header is bad, but it was OK earlier, err %d",

					pnum, err);

				if (err > 0)

					err = -EIO;
@@ -507,7 +509,7 @@ int ubi_add_to_av(struct ubi_device *ubi, struct ubi_attach_info *ai, int pnum, 
		 * logical eraseblocks because there was an unclean reboot.

		 */

		if (aeb->sqnum == sqnum && sqnum != 0) {

			ubi_err("two LEBs with same sequence number %llu",

			ubi_err(ubi, "two LEBs with same sequence number %llu",

				sqnum);

			ubi_dump_aeb(aeb, 0);

			ubi_dump_vid_hdr(vid_hdr);
@@ -527,7 +529,7 @@ int ubi_add_to_av(struct ubi_device *ubi, struct ubi_attach_info *ai, int pnum, 
			 * This logical eraseblock is newer than the one

			 * found earlier.

			 */

			err = validate_vid_hdr(vid_hdr, av, pnum);

			err = validate_vid_hdr(ubi, vid_hdr, av, pnum);

			if (err)

				return err;
@@ -565,7 +567,7 @@ int ubi_add_to_av(struct ubi_device *ubi, struct ubi_attach_info *ai, int pnum, 
	 * attaching information.

	 */



	err = validate_vid_hdr(vid_hdr, av, pnum);

	err = validate_vid_hdr(ubi, vid_hdr, av, pnum);

	if (err)

		return err;
@@ -668,7 +670,8 @@ static int early_erase_peb(struct ubi_device *ubi, 
		 * Erase counter overflow. Upgrade UBI and use 64-bit

		 * erase counters internally.

		 */

		ubi_err("erase counter overflow at PEB %d, EC %d", pnum, ec);

		ubi_err(ubi, "erase counter overflow at PEB %d, EC %d",

			pnum, ec);

		return -EINVAL;

	}
@@ -736,7 +739,7 @@ struct ubi_ainf_peb *ubi_early_get_peb(struct ubi_device *ubi, 
		return aeb;

	}



	ubi_err("no free eraseblocks");

	ubi_err(ubi, "no free eraseblocks");

	return ERR_PTR(-ENOSPC);

}
@@ -785,9 +788,9 @@ static int check_corruption(struct ubi_device *ubi, struct ubi_vid_hdr *vid_hdr, 
	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",

	ubi_err(ubi, "PEB %d contains corrupted VID header, and the data does not contain all 0xFF",

		pnum);

	ubi_err("this may be a non-UBI PEB or a severe VID header corruption which requires manual inspection");

	ubi_err(ubi, "this may be a non-UBI PEB or a severe VID header corruption which requires manual inspection");

	ubi_dump_vid_hdr(vid_hdr);

	pr_err("hexdump of PEB %d offset %d, length %d",

	       pnum, ubi->leb_start, ubi->leb_size);
@@ -859,7 +862,8 @@ static int scan_peb(struct ubi_device *ubi, struct ubi_attach_info *ai, 
		bitflips = 1;

		break;

	default:

		ubi_err("'ubi_io_read_ec_hdr()' returned unknown code %d", err);

		ubi_err(ubi, "'ubi_io_read_ec_hdr()' returned unknown code %d",

			err);

		return -EINVAL;

	}
@@ -868,7 +872,7 @@ static int scan_peb(struct ubi_device *ubi, struct ubi_attach_info *ai, 


		/* Make sure UBI version is OK */

		if (ech->version != UBI_VERSION) {

			ubi_err("this UBI version is %d, image version is %d",

			ubi_err(ubi, "this UBI version is %d, image version is %d",

				UBI_VERSION, (int)ech->version);

			return -EINVAL;

		}
@@ -882,7 +886,7 @@ static int scan_peb(struct ubi_device *ubi, struct ubi_attach_info *ai, 
			 * flash. Upgrade UBI and use 64-bit erase counters

			 * internally.

			 */

			ubi_err("erase counter overflow, max is %d",

			ubi_err(ubi, "erase counter overflow, max is %d",

				UBI_MAX_ERASECOUNTER);

			ubi_dump_ec_hdr(ech);

			return -EINVAL;
@@ -903,7 +907,7 @@ static int scan_peb(struct ubi_device *ubi, struct ubi_attach_info *ai, 
		if (!ubi->image_seq)

			ubi->image_seq = image_seq;

		if (image_seq && ubi->image_seq != image_seq) {

			ubi_err("bad image sequence number %d in PEB %d, expected %d",

			ubi_err(ubi, "bad image sequence number %d in PEB %d, expected %d",

				image_seq, pnum, ubi->image_seq);

			ubi_dump_ec_hdr(ech);

			return -EINVAL;
@@ -981,7 +985,7 @@ static int scan_peb(struct ubi_device *ubi, struct ubi_attach_info *ai, 
			return err;

		goto adjust_mean_ec;

	default:

		ubi_err("'ubi_io_read_vid_hdr()' returned unknown code %d",

		ubi_err(ubi, "'ubi_io_read_vid_hdr()' returned unknown code %d",

			err);

		return -EINVAL;

	}
@@ -999,7 +1003,7 @@ static int scan_peb(struct ubi_device *ubi, struct ubi_attach_info *ai, 
		case UBI_COMPAT_DELETE:

			if (vol_id != UBI_FM_SB_VOLUME_ID

			    && vol_id != UBI_FM_DATA_VOLUME_ID) {

				ubi_msg("\"delete\" compatible internal volume %d:%d found, will remove it",

				ubi_msg(ubi, "\"delete\" compatible internal volume %d:%d found, will remove it",

					vol_id, lnum);

			}

			err = add_to_list(ai, pnum, vol_id, lnum,
@@ -1009,13 +1013,13 @@ static int scan_peb(struct ubi_device *ubi, struct ubi_attach_info *ai, 
			return 0;



		case UBI_COMPAT_RO:

			ubi_msg("read-only compatible internal volume %d:%d found, switch to read-only mode",

			ubi_msg(ubi, "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",

			ubi_msg(ubi, "\"preserve\" compatible internal volume %d:%d found",

				vol_id, lnum);

			err = add_to_list(ai, pnum, vol_id, lnum,

					  ec, 0, &ai->alien);
@@ -1024,14 +1028,14 @@ static int scan_peb(struct ubi_device *ubi, struct ubi_attach_info *ai, 
			return 0;



		case UBI_COMPAT_REJECT:

			ubi_err("incompatible internal volume %d:%d found",

			ubi_err(ubi, "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",

		ubi_warn(ubi, "valid VID header but corrupted EC header at PEB %d",

			 pnum);

	err = ubi_add_to_av(ubi, ai, pnum, ec, vidh, bitflips);

	if (err)
@@ -1075,7 +1079,7 @@ static int late_analysis(struct ubi_device *ubi, struct ubi_attach_info *ai) 
	 * with the flash HW or driver.

	 */

	if (ai->corr_peb_count) {

		ubi_err("%d PEBs are corrupted and preserved",

		ubi_err(ubi, "%d PEBs are corrupted and preserved",

			ai->corr_peb_count);

		pr_err("Corrupted PEBs are:");

		list_for_each_entry(aeb, &ai->corr, u.list)
@@ -1087,7 +1091,7 @@ static int late_analysis(struct ubi_device *ubi, struct ubi_attach_info *ai) 
		 * otherwise, only print a warning.

		 */

		if (ai->corr_peb_count >= max_corr) {

			ubi_err("too many corrupted PEBs, refusing");

			ubi_err(ubi, "too many corrupted PEBs, refusing");

			return -EINVAL;

		}

	}
@@ -1110,11 +1114,11 @@ static int late_analysis(struct ubi_device *ubi, struct ubi_attach_info *ai) 
		 */

		if (ai->maybe_bad_peb_count <= 2) {

			ai->is_empty = 1;

			ubi_msg("empty MTD device detected");

			ubi_msg(ubi, "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");

			ubi_err(ubi, "MTD device is not UBI-formatted and possibly contains non-UBI data - refusing it");

			return -EINVAL;

		}
@@ -1248,7 +1252,7 @@ static int scan_all(struct ubi_device *ubi, struct ubi_attach_info *ai, 
			goto out_vidh;

	}



	ubi_msg("scanning is finished");

	ubi_msg(ubi, "scanning is finished");



	/* Calculate mean erase counter */

	if (ai->ec_count)
@@ -1515,37 +1519,37 @@ static int self_check_ai(struct ubi_device *ubi, struct ubi_attach_info *ai) 
		vols_found += 1;



		if (ai->is_empty) {

			ubi_err("bad is_empty flag");

			ubi_err(ubi, "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");

			ubi_err(ubi, "negative values");

			goto bad_av;

		}



		if (av->vol_id >= UBI_MAX_VOLUMES &&

		    av->vol_id < UBI_INTERNAL_VOL_START) {

			ubi_err("bad vol_id");

			ubi_err(ubi, "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",

			ubi_err(ubi, "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");

			ubi_err(ubi, "bad vol_type");

			goto bad_av;

		}



		if (av->data_pad > ubi->leb_size / 2) {

			ubi_err("bad data_pad");

			ubi_err(ubi, "bad data_pad");

			goto bad_av;

		}
@@ -1557,48 +1561,48 @@ static int self_check_ai(struct ubi_device *ubi, struct ubi_attach_info *ai) 
			leb_count += 1;



			if (aeb->pnum < 0 || aeb->ec < 0) {

				ubi_err("negative values");

				ubi_err(ubi, "negative values");

				goto bad_aeb;

			}



			if (aeb->ec < ai->min_ec) {

				ubi_err("bad ai->min_ec (%d), %d found",

				ubi_err(ubi, "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",

				ubi_err(ubi, "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",

				ubi_err(ubi, "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");

					ubi_err(ubi, "bad lnum or used_ebs");

					goto bad_aeb;

				}

			} else {

				if (av->used_ebs != 0) {

					ubi_err("non-zero used_ebs");

					ubi_err(ubi, "non-zero used_ebs");

					goto bad_aeb;

				}

			}



			if (aeb->lnum > av->highest_lnum) {

				ubi_err("incorrect highest_lnum or lnum");

				ubi_err(ubi, "incorrect highest_lnum or lnum");

				goto bad_aeb;

			}

		}



		if (av->leb_count != leb_count) {

			ubi_err("bad leb_count, %d objects in the tree",

			ubi_err(ubi, "bad leb_count, %d objects in the tree",

				leb_count);

			goto bad_av;

		}
@@ -1609,13 +1613,13 @@ static int self_check_ai(struct ubi_device *ubi, struct ubi_attach_info *ai) 
		aeb = last_aeb;



		if (aeb->lnum != av->highest_lnum) {

			ubi_err("bad highest_lnum");

			ubi_err(ubi, "bad highest_lnum");

			goto bad_aeb;

		}

	}



	if (vols_found != ai->vols_found) {

		ubi_err("bad ai->vols_found %d, should be %d",

		ubi_err(ubi, "bad ai->vols_found %d, should be %d",

			ai->vols_found, vols_found);

		goto out;

	}
@@ -1632,7 +1636,8 @@ static int self_check_ai(struct ubi_device *ubi, struct ubi_attach_info *ai) 


			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);

				ubi_err(ubi, "VID header is not OK (%d)",

					err);

				if (err > 0)

					err = -EIO;

				return err;
@@ -1641,37 +1646,37 @@ static int self_check_ai(struct ubi_device *ubi, struct ubi_attach_info *ai) 
			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");

				ubi_err(ubi, "bad vol_type");

				goto bad_vid_hdr;

			}



			if (aeb->sqnum != be64_to_cpu(vidh->sqnum)) {

				ubi_err("bad sqnum %llu", aeb->sqnum);

				ubi_err(ubi, "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);

				ubi_err(ubi, "bad vol_id %d", av->vol_id);

				goto bad_vid_hdr;

			}



			if (av->compat != vidh->compat) {

				ubi_err("bad compat %d", vidh->compat);

				ubi_err(ubi, "bad compat %d", vidh->compat);

				goto bad_vid_hdr;

			}



			if (aeb->lnum != be32_to_cpu(vidh->lnum)) {

				ubi_err("bad lnum %d", aeb->lnum);

				ubi_err(ubi, "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);

				ubi_err(ubi, "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);

				ubi_err(ubi, "bad data_pad %d", av->data_pad);

				goto bad_vid_hdr;

			}

		}
@@ -1680,12 +1685,13 @@ static int self_check_ai(struct ubi_device *ubi, struct ubi_attach_info *ai) 
			continue;



		if (av->highest_lnum != be32_to_cpu(vidh->lnum)) {

			ubi_err("bad highest_lnum %d", av->highest_lnum);

			ubi_err(ubi, "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);

			ubi_err(ubi, "bad last_data_size %d",

				av->last_data_size);

			goto bad_vid_hdr;

		}

	}
@@ -1726,7 +1732,7 @@ static int self_check_ai(struct ubi_device *ubi, struct ubi_attach_info *ai) 
	err = 0;

	for (pnum = 0; pnum < ubi->peb_count; pnum++)

		if (!buf[pnum]) {

			ubi_err("PEB %d is not referred", pnum);

			ubi_err(ubi, "PEB %d is not referred", pnum);

			err = 1;

		}
@@ -1736,18 +1742,18 @@ static int self_check_ai(struct ubi_device *ubi, struct ubi_attach_info *ai) 
	return 0;



bad_aeb:

	ubi_err("bad attaching information about LEB %d", aeb->lnum);

	ubi_err(ubi, "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_err(ubi, "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_err(ubi, "bad attaching information about volume %d", av->vol_id);

	ubi_dump_av(av);

	ubi_dump_vid_hdr(vidh);

drivers/mtd/ubi/block.c

+20 −21
Original line number Diff line number Diff line
@@ -111,12 +111,12 @@ static int __init ubiblock_set_param(const char *val, 


	len = strnlen(val, UBIBLOCK_PARAM_LEN);

	if (len == 0) {

		ubi_warn("block: empty 'block=' parameter - ignored\n");

		pr_warn("UBI: block: empty 'block=' parameter - ignored\n");

		return 0;

	}



	if (len == UBIBLOCK_PARAM_LEN) {

		ubi_err("block: parameter \"%s\" is too long, max. is %d\n",

		pr_err("UBI: block: parameter \"%s\" is too long, max. is %d\n",

		       val, UBIBLOCK_PARAM_LEN);

		return -EINVAL;

	}
@@ -188,9 +188,8 @@ static int ubiblock_read_to_buf(struct ubiblock *dev, char *buffer, 


	ret = ubi_read(dev->desc, leb, buffer, offset, len);

	if (ret) {

		ubi_err("%s: error %d while reading from LEB %d (offset %d, "

		        "length %d)", dev->gd->disk_name, ret, leb, offset,

			len);

		dev_err(disk_to_dev(dev->gd), "%d while reading from LEB %d (offset %d, length %d)",

			ret, leb, offset, len);

		return ret;

	}

	return 0;
@@ -328,8 +327,8 @@ static int ubiblock_open(struct block_device *bdev, fmode_t mode) 


	dev->desc = ubi_open_volume(dev->ubi_num, dev->vol_id, UBI_READONLY);

	if (IS_ERR(dev->desc)) {

		ubi_err("%s failed to open ubi volume %d_%d",

			dev->gd->disk_name, dev->ubi_num, dev->vol_id);

		dev_err(disk_to_dev(dev->gd), "failed to open ubi volume %d_%d",

			dev->ubi_num, dev->vol_id);

		ret = PTR_ERR(dev->desc);

		dev->desc = NULL;

		goto out_unlock;
@@ -405,7 +404,7 @@ int ubiblock_create(struct ubi_volume_info *vi) 
	/* Initialize the gendisk of this ubiblock device */

	gd = alloc_disk(1);

	if (!gd) {

		ubi_err("block: alloc_disk failed");

		pr_err("UBI: block: alloc_disk failed");

		ret = -ENODEV;

		goto out_free_dev;

	}
@@ -421,7 +420,7 @@ int ubiblock_create(struct ubi_volume_info *vi) 
	spin_lock_init(&dev->queue_lock);

	dev->rq = blk_init_queue(ubiblock_request, &dev->queue_lock);

	if (!dev->rq) {

		ubi_err("block: blk_init_queue failed");

		dev_err(disk_to_dev(gd), "blk_init_queue failed");

		ret = -ENODEV;

		goto out_put_disk;

	}
@@ -446,8 +445,8 @@ int ubiblock_create(struct ubi_volume_info *vi) 


	/* Must be the last step: anyone can call file ops from now on */

	add_disk(dev->gd);

	ubi_msg("%s created from ubi%d:%d(%s)",

		dev->gd->disk_name, dev->ubi_num, dev->vol_id, vi->name);

	dev_info(disk_to_dev(dev->gd), "created from ubi%d:%d(%s)",

		 dev->ubi_num, dev->vol_id, vi->name);

	return 0;



out_free_queue:
@@ -464,7 +463,7 @@ static void ubiblock_cleanup(struct ubiblock *dev) 
{

	del_gendisk(dev->gd);

	blk_cleanup_queue(dev->rq);

	ubi_msg("%s released", dev->gd->disk_name);

	dev_info(disk_to_dev(dev->gd), "released");

	put_disk(dev->gd);

}
@@ -518,8 +517,8 @@ static int ubiblock_resize(struct ubi_volume_info *vi) 
	}

	if ((sector_t)disk_capacity != disk_capacity) {

		mutex_unlock(&devices_mutex);

		ubi_warn("%s: the volume is too big (%d LEBs), cannot resize",

			 dev->gd->disk_name, vi->size);

		dev_warn(disk_to_dev(dev->gd), "the volume is too big (%d LEBs), cannot resize",

			 vi->size);

		return -EFBIG;

	}
@@ -527,7 +526,7 @@ static int ubiblock_resize(struct ubi_volume_info *vi) 


	if (get_capacity(dev->gd) != disk_capacity) {

		set_capacity(dev->gd, disk_capacity);

		ubi_msg("%s resized to %lld bytes", dev->gd->disk_name,

		dev_info(disk_to_dev(dev->gd), "resized to %lld bytes",

			 vi->used_bytes);

	}

	mutex_unlock(&dev->dev_mutex);
@@ -596,7 +595,7 @@ static int __init ubiblock_create_from_param(void) 


		desc = open_volume_desc(p->name, p->ubi_num, p->vol_id);

		if (IS_ERR(desc)) {

			ubi_err("block: can't open volume, err=%ld\n",

			pr_err("UBI: block: can't open volume, err=%ld\n",

			       PTR_ERR(desc));

			ret = PTR_ERR(desc);

			break;
@@ -607,7 +606,7 @@ static int __init ubiblock_create_from_param(void) 


		ret = ubiblock_create(&vi);

		if (ret) {

			ubi_err("block: can't add '%s' volume, err=%d\n",

			pr_err("UBI: block: can't add '%s' volume, err=%d\n",

			       vi.name, ret);

			break;

		}

drivers/mtd/ubi/build.c

+67 −59

File changed.

Preview size limit exceeded, changes collapsed.

drivers/mtd/ubi/cdev.c

+19 −17
Original line number Diff line number Diff line
@@ -48,13 +48,14 @@ 


/**

 * get_exclusive - get exclusive access to an UBI volume.

 * @ubi: UBI device description object

 * @desc: volume descriptor

 *

 * This function changes UBI volume open mode to "exclusive". Returns previous

 * mode value (positive integer) in case of success and a negative error code

 * in case of failure.

 */

static int get_exclusive(struct ubi_volume_desc *desc)

static int get_exclusive(struct ubi_device *ubi, struct ubi_volume_desc *desc)

{

	int users, err;

	struct ubi_volume *vol = desc->vol;
@@ -63,7 +64,7 @@ static int get_exclusive(struct ubi_volume_desc *desc) 
	users = vol->readers + vol->writers + vol->exclusive;

	ubi_assert(users > 0);

	if (users > 1) {

		ubi_err("%d users for volume %d", users, vol->vol_id);

		ubi_err(ubi, "%d users for volume %d", users, vol->vol_id);

		err = -EBUSY;

	} else {

		vol->readers = vol->writers = 0;
@@ -134,7 +135,7 @@ static int vol_cdev_release(struct inode *inode, struct file *file) 
		vol->ubi->ubi_num, vol->vol_id, desc->mode);



	if (vol->updating) {

		ubi_warn("update of volume %d not finished, volume is damaged",

		ubi_warn(vol->ubi, "update of volume %d not finished, volume is damaged",

			 vol->vol_id);

		ubi_assert(!vol->changing_leb);

		vol->updating = 0;
@@ -158,7 +159,7 @@ static loff_t vol_cdev_llseek(struct file *file, loff_t offset, int origin) 


	if (vol->updating) {

		/* Update is in progress, seeking is prohibited */

		ubi_err("updating");

		ubi_err(vol->ubi, "updating");

		return -EBUSY;

	}
@@ -193,11 +194,11 @@ static ssize_t vol_cdev_read(struct file *file, __user char *buf, size_t count, 
		count, *offp, vol->vol_id);



	if (vol->updating) {

		ubi_err("updating");

		ubi_err(vol->ubi, "updating");

		return -EBUSY;

	}

	if (vol->upd_marker) {

		ubi_err("damaged volume, update marker is set");

		ubi_err(vol->ubi, "damaged volume, update marker is set");

		return -EBADF;

	}

	if (*offp == vol->used_bytes || count == 0)
@@ -277,7 +278,7 @@ static ssize_t vol_cdev_direct_write(struct file *file, const char __user *buf, 


	lnum = div_u64_rem(*offp, vol->usable_leb_size, &off);

	if (off & (ubi->min_io_size - 1)) {

		ubi_err("unaligned position");

		ubi_err(ubi, "unaligned position");

		return -EINVAL;

	}
@@ -286,7 +287,7 @@ static ssize_t vol_cdev_direct_write(struct file *file, const char __user *buf, 


	/* We can write only in fractions of the minimum I/O unit */

	if (count & (ubi->min_io_size - 1)) {

		ubi_err("unaligned write length");

		ubi_err(ubi, "unaligned write length");

		return -EINVAL;

	}
@@ -348,7 +349,7 @@ static ssize_t vol_cdev_write(struct file *file, const char __user *buf, 
		err = ubi_more_leb_change_data(ubi, vol, buf, count);



	if (err < 0) {

		ubi_err("cannot accept more %zd bytes of data, error %d",

		ubi_err(ubi, "cannot accept more %zd bytes of data, error %d",

			count, err);

		return err;

	}
@@ -370,7 +371,7 @@ static ssize_t vol_cdev_write(struct file *file, const char __user *buf, 
			return err;



		if (err) {

			ubi_warn("volume %d on UBI device %d is corrupted",

			ubi_warn(ubi, "volume %d on UBI device %d is corrupted",

				 vol->vol_id, ubi->ubi_num);

			vol->corrupted = 1;

		}
@@ -420,7 +421,7 @@ static long vol_cdev_ioctl(struct file *file, unsigned int cmd, 
			break;

		}



		err = get_exclusive(desc);

		err = get_exclusive(ubi, desc);

		if (err < 0)

			break;
@@ -456,7 +457,7 @@ static long vol_cdev_ioctl(struct file *file, unsigned int cmd, 
		    req.bytes < 0 || req.lnum >= vol->usable_leb_size)

			break;



		err = get_exclusive(desc);

		err = get_exclusive(ubi, desc);

		if (err < 0)

			break;
@@ -642,7 +643,7 @@ static int verify_mkvol_req(const struct ubi_device *ubi, 
	return 0;



bad:

	ubi_err("bad volume creation request");

	ubi_err(ubi, "bad volume creation request");

	ubi_dump_mkvol_req(req);

	return err;

}
@@ -708,12 +709,12 @@ static int rename_volumes(struct ubi_device *ubi, 
	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) {

				ubi_err("duplicated volume id %d",

				ubi_err(ubi, "duplicated volume id %d",

					req->ents[i].vol_id);

				return -EINVAL;

			}

			if (!strcmp(req->ents[i].name, req->ents[n].name)) {

				ubi_err("duplicated volume name \"%s\"",

				ubi_err(ubi, "duplicated volume name \"%s\"",

					req->ents[i].name);

				return -EINVAL;

			}
@@ -736,7 +737,8 @@ static int rename_volumes(struct ubi_device *ubi, 
		re->desc = ubi_open_volume(ubi->ubi_num, vol_id, UBI_READWRITE);

		if (IS_ERR(re->desc)) {

			err = PTR_ERR(re->desc);

			ubi_err("cannot open volume %d, error %d", vol_id, err);

			ubi_err(ubi, "cannot open volume %d, error %d",

				vol_id, err);

			kfree(re);

			goto out_free;

		}
@@ -795,7 +797,7 @@ static int rename_volumes(struct ubi_device *ubi, 
				continue;



			/* The volume exists but busy, or an error occurred */

			ubi_err("cannot open volume \"%s\", error %d",

			ubi_err(ubi, "cannot open volume \"%s\", error %d",

				re->new_name, err);

			goto out_free;

		}

drivers/mtd/ubi/debug.c

+5 −5
Original line number Diff line number Diff line
@@ -43,12 +43,12 @@ void ubi_dump_flash(struct ubi_device *ubi, int pnum, int offset, int len) 
		return;

	err = mtd_read(ubi->mtd, addr, len, &read, buf);

	if (err && err != -EUCLEAN) {

		ubi_err("error %d while reading %d bytes from PEB %d:%d, read %zd bytes",

		ubi_err(ubi, "err %d while reading %d bytes from PEB %d:%d, read %zd bytes",

			err, len, pnum, offset, read);

		goto out;

	}



	ubi_msg("dumping %d bytes of data from PEB %d, offset %d",

	ubi_msg(ubi, "dumping %d bytes of data from PEB %d, offset %d",

		len, pnum, offset);

	print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1, buf, len, 1);

out:
@@ -238,7 +238,7 @@ int ubi_debugfs_init(void) 
	if (IS_ERR_OR_NULL(dfs_rootdir)) {

		int err = dfs_rootdir ? -ENODEV : PTR_ERR(dfs_rootdir);



		ubi_err("cannot create \"ubi\" debugfs directory, error %d\n",

		pr_err("UBI error: cannot create \"ubi\" debugfs directory, error %d\n",

		       err);

		return err;

	}
@@ -433,7 +433,7 @@ int ubi_debugfs_init_dev(struct ubi_device *ubi) 
	debugfs_remove_recursive(d->dfs_dir);

out:

	err = dent ? PTR_ERR(dent) : -ENODEV;

	ubi_err("cannot create \"%s\" debugfs file or directory, error %d\n",

	ubi_err(ubi, "cannot create \"%s\" debugfs file or directory, error %d\n",

		fname, err);

	return err;

}