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

Commit b2a43417 authored by Tanya Brokhman's avatar Tanya Brokhman
Browse files

mtd: 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.
Add some debug messages.

Change-Id: Iafccf7d90f1d10ff7a03a277eeb7900e6bd98304
Signed-off-by: default avatarTanya Brokhman <tlinder@codeaurora.org>
parent f9e5104e

drivers/mtd/ubi/attach.c

+81 −60
Original line number Diff line number Diff line
@@ -205,6 +205,7 @@ static int add_corrupted(struct ubi_attach_info *ai, int pnum, 


/**

 * 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
@@ -217,7 +218,8 @@ static int add_corrupted(struct ubi_attach_info *ai, int pnum, 
 * 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;
@@ -235,7 +237,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->ubi_num, "inconsistent vol_id");

			goto bad;

		}
@@ -245,17 +247,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->ubi_num, "inconsistent vol_type");

			goto bad;

		}



		if (used_ebs != av->used_ebs) {

			ubi_err("inconsistent used_ebs");

			ubi_err(ubi->ubi_num, "inconsistent used_ebs");

			goto bad;

		}



		if (data_pad != av->data_pad) {

			ubi_err("inconsistent data_pad");

			ubi_err(ubi->ubi_num, "inconsistent data_pad");

			goto bad;

		}

	}
@@ -263,7 +265,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->ubi_num, "inconsistent VID header at PEB %d", pnum);

	ubi_dump_vid_hdr(vid_hdr);

	ubi_dump_av(av);

	return -EINVAL;
@@ -365,7 +367,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->ubi_num, "unsupported on-flash UBI format");

		return -EINVAL;

	}
@@ -406,7 +408,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->ubi_num, "VID of PEB %d header is bad, but it was OK earlier, err %d",

					pnum, err);

				if (err > 0)

					err = -EIO;
@@ -540,7 +542,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->ubi_num, "two LEBs with same sequence number %llu",

				sqnum);

			ubi_dump_aeb(aeb, 0);

			ubi_dump_vid_hdr(vid_hdr);
@@ -560,7 +562,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;
@@ -603,7 +605,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;
@@ -711,7 +713,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->ubi_num,

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

		return -EINVAL;

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

	}



	ubi_err("no free eraseblocks");

	ubi_err(ubi->ubi_num, "no free eraseblocks");

	return ERR_PTR(-ENOSPC);

}
@@ -834,9 +837,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->ubi_num, "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->ubi_num, "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);
@@ -914,7 +917,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_num,

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

		return -EINVAL;

	}
@@ -923,7 +927,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->ubi_num, "this UBI version is %d, image version is %d",

				UBI_VERSION, (int)ech->version);

			return -EINVAL;

		}
@@ -947,7 +951,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->ubi_num, "erase counter overflow, max is %d",

				UBI_MAX_ERASECOUNTER);

			ubi_dump_ec_hdr(ech);

			return -EINVAL;
@@ -969,7 +973,7 @@ static int scan_peb(struct ubi_device *ubi, struct ubi_attach_info *ai, 
			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",

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

				image_seq, pnum, ubi->image_seq);

			ubi_dump_ec_hdr(ech);

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

		goto adjust_mean_av_stat;

	default:

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

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

			err);

		return -EINVAL;

	}
@@ -1068,7 +1072,9 @@ 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->ubi_num,

				   "\"delete\" compatible internal volume %d:%d"

				   " found, will remove it",

					vol_id, lnum);

			}

			err = add_to_list(ai, pnum, vol_id, lnum,
@@ -1079,13 +1085,17 @@ 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->ubi_num,

				"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->ubi_num,

				"\"preserve\" compatible internal "

				"volume %d:%d found",

				vol_id, lnum);

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

					  ec, last_erase_time,
@@ -1095,14 +1105,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->ubi_num, "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->ubi_num, "valid VID header but corrupted EC header at PEB %d",

			 pnum);



	err = ubi_add_to_av(ubi, ai, pnum, ec, last_erase_time,
@@ -1150,7 +1160,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->ubi_num, "%d PEBs are corrupted and preserved",

			ai->corr_peb_count);

		pr_err("Corrupted PEBs are:");

		list_for_each_entry(aeb, &ai->corr, u.list)
@@ -1162,7 +1172,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->ubi_num, "too many corrupted PEBs, refusing");

			return -EINVAL;

		}

	}
@@ -1185,11 +1195,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->ubi_num, "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->ubi_num, "MTD device is not UBI-formatted and possibly contains non-UBI data - refusing it");

			return -EINVAL;

		}
@@ -1323,7 +1333,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->ubi_num, "scanning is finished");



	/* Calculate mean erase counter */

	if (ai->ec_count)
@@ -1587,37 +1597,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->ubi_num, "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->ubi_num, "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->ubi_num, "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->ubi_num, "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->ubi_num, "bad vol_type");

			goto bad_av;

		}



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

			ubi_err("bad data_pad");

			ubi_err(ubi->ubi_num, "bad data_pad");

			goto bad_av;

		}
@@ -1629,48 +1639,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->ubi_num, "negative values");

				goto bad_aeb;

			}



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

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

				ubi_err(ubi->ubi_num, "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->ubi_num, "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->ubi_num, "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->ubi_num, "bad lnum or used_ebs");

					goto bad_aeb;

				}

			} else {

				if (av->used_ebs != 0) {

					ubi_err("non-zero used_ebs");

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

					goto bad_aeb;

				}

			}



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

				ubi_err("incorrect highest_lnum or lnum");

				ubi_err(ubi->ubi_num, "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->ubi_num, "bad leb_count, %d objects in the tree",

				leb_count);

			goto bad_av;

		}
@@ -1681,13 +1691,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->ubi_num, "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->ubi_num, "bad ai->vols_found %d, should be %d",

			ai->vols_found, vols_found);

		goto out;

	}
@@ -1704,7 +1714,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->ubi_num,

					"VID header is not OK (%d)", err);

				if (err > 0)

					err = -EIO;

				return err;
@@ -1713,37 +1724,42 @@ 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->ubi_num, "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->ubi_num,

					"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->ubi_num,

					"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->ubi_num,

					"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->ubi_num, "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->ubi_num,

					"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->ubi_num,

					"bad data_pad %d", av->data_pad);

				goto bad_vid_hdr;

			}

		}
@@ -1752,12 +1768,14 @@ 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->ubi_num,

				"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->ubi_num,

				"bad last_data_size %d", av->last_data_size);

			goto bad_vid_hdr;

		}

	}
@@ -1798,7 +1816,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->ubi_num, "PEB %d is not referred", pnum);

			err = 1;

		}
@@ -1808,18 +1826,21 @@ 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->ubi_num, "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->ubi_num, "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->ubi_num, "bad attaching information about volume %d",

		av->vol_id);

	ubi_dump_av(av);

	ubi_dump_vid_hdr(vidh);

drivers/mtd/ubi/build.c

+77 −52

File changed.

Preview size limit exceeded, changes collapsed.

drivers/mtd/ubi/cdev.c

+20 −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,8 @@ 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->ubi_num, "%d users for volume %d",

			users, vol->vol_id);

		err = -EBUSY;

	} else {

		vol->readers = vol->writers = 0;
@@ -134,7 +136,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->ubi_num, "update of volume %d not finished, volume is damaged",

			 vol->vol_id);

		ubi_assert(!vol->changing_leb);

		vol->updating = 0;
@@ -158,7 +160,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->ubi_num, "updating");

		return -EBUSY;

	}
@@ -193,11 +195,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->ubi_num, "updating");

		return -EBUSY;

	}

	if (vol->upd_marker) {

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

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

		return -EBADF;

	}

	if (*offp == vol->used_bytes || count == 0)
@@ -277,7 +279,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->ubi_num, "unaligned position");

		return -EINVAL;

	}
@@ -286,7 +288,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->ubi_num, "unaligned write length");

		return -EINVAL;

	}
@@ -348,7 +350,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->ubi_num, "cannot accept more %zd bytes of data, error %d",

			count, err);

		return err;

	}
@@ -370,7 +372,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->ubi_num, "volume %d on UBI device %d is corrupted",

				 vol->vol_id, ubi->ubi_num);

			vol->corrupted = 1;

		}
@@ -420,7 +422,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;
@@ -454,7 +456,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;
@@ -620,7 +622,7 @@ static int verify_mkvol_req(const struct ubi_device *ubi, 
	return 0;



bad:

	ubi_err("bad volume creation request");

	ubi_err(ubi->ubi_num, "bad volume creation request");

	ubi_dump_mkvol_req(req);

	return err;

}
@@ -686,12 +688,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->ubi_num, "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->ubi_num, "duplicated volume name \"%s\"",

					req->ents[i].name);

				return -EINVAL;

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

		if (IS_ERR(re->desc)) {

			err = PTR_ERR(re->desc);

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

			ubi_err(ubi->ubi_num,

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

			kfree(re);

			goto out_free;

		}
@@ -773,7 +776,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->ubi_num, "cannot open volume \"%s\", error %d",

				re->new_name, err);

			goto out_free;

		}

drivers/mtd/ubi/debug.c

+8 −6
Original line number Diff line number Diff line
@@ -46,7 +46,8 @@ 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->ubi_num,

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

			err, len, pnum, offset, read);

		goto out;

	}
@@ -54,12 +55,13 @@ void ubi_dump_flash(struct ubi_device *ubi, int pnum, int offset, int len) 
		if (ubi->lookuptbl[pnum]->rc < UBI_MAX_READCOUNTER)

			ubi->lookuptbl[pnum]->rc++;

		else

			ubi_err("read counter overflow at PEB %d, RC %d",

			ubi_err(ubi->ubi_num,

				"read counter overflow at PEB %d, RC %d",

					pnum, ubi->lookuptbl[pnum]->rc);

	} else

		ubi_err("Can't update RC. No lookuptbl");

		ubi_err(ubi->ubi_num, "Can't update RC. No lookuptbl");



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

	ubi_msg(ubi->ubi_num, "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:
@@ -249,7 +251,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",

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

			err);

		return err;

	}
@@ -444,7 +446,7 @@ out_remove: 
	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->ubi_num, "cannot create \"%s\" debugfs file or directory, error %d\n",

		fname, err);

	return err;

}

drivers/mtd/ubi/eba.c

+28 −26
Original line number Diff line number Diff line
@@ -425,7 +425,7 @@ retry: 
				 */

				if (err == UBI_IO_BAD_HDR_EBADMSG ||

				    err == UBI_IO_BAD_HDR) {

					ubi_warn("corrupted VID header at PEB %d, LEB %d:%d",

					ubi_warn(ubi->ubi_num, "corrupted VID header at PEB %d, LEB %d:%d",

						 pnum, vol_id, lnum);

					err = -EBADMSG;

				} else
@@ -452,7 +452,7 @@ retry: 
				goto out_unlock;

			scrub = 1;

			if (!check) {

				ubi_msg("force data checking");

				ubi_msg(ubi->ubi_num, "force data checking");

				check = 1;

				goto retry;

			}
@@ -463,7 +463,7 @@ retry: 
	if (check) {

		uint32_t crc1 = crc32(UBI_CRC32_INIT, buf, len);

		if (crc1 != crc) {

			ubi_warn("CRC error: calculated %#08x, must be %#08x",

			ubi_warn(ubi->ubi_num, "CRC error: calculated %#08x, must be %#08x",

				 crc1, crc);

			err = -EBADMSG;

			goto out_unlock;
@@ -519,7 +519,8 @@ retry: 
		return new_pnum;

	}



	ubi_msg("recover PEB %d, move data to PEB %d", pnum, new_pnum);

	ubi_msg(ubi->ubi_num, "recover PEB %d, move data to PEB %d",

		pnum, new_pnum);



	err = ubi_io_read_vid_hdr(ubi, pnum, vid_hdr, 1);

	if (err && err != UBI_IO_BITFLIPS) {
@@ -560,7 +561,7 @@ retry: 
	up_read(&ubi->fm_sem);

	ubi_wl_put_peb(ubi, vol_id, lnum, pnum, 1);



	ubi_msg("data was successfully recovered");

	ubi_msg(ubi->ubi_num, "data was successfully recovered");

	return 0;



out_unlock:
@@ -575,13 +576,13 @@ write_error: 
	 * Bad luck? This physical eraseblock is bad too? Crud. Let's try to

	 * get another one.

	 */

	ubi_warn("failed to write to PEB %d", new_pnum);

	ubi_warn(ubi->ubi_num, "failed to write to PEB %d", new_pnum);

	ubi_wl_put_peb(ubi, vol_id, lnum, new_pnum, 1);

	if (++tries > UBI_IO_RETRIES) {

		ubi_free_vid_hdr(ubi, vid_hdr);

		return err;

	}

	ubi_msg("try again");

	ubi_msg(ubi->ubi_num, "try again");

	goto retry;

}
@@ -619,7 +620,8 @@ int ubi_eba_write_leb(struct ubi_device *ubi, struct ubi_volume *vol, int lnum, 


		err = ubi_io_write_data(ubi, buf, pnum, offset, len);

		if (err) {

			ubi_warn("failed to write data to PEB %d", pnum);

			ubi_warn(ubi->ubi_num,

				 "failed to write data to PEB %d", pnum);

			if (err == -EIO && ubi->bad_allowed)

				err = recover_peb(ubi, pnum, vol_id, lnum, buf,

						  offset, len);
@@ -660,7 +662,7 @@ retry: 


	err = ubi_io_write_vid_hdr(ubi, pnum, vid_hdr);

	if (err) {

		ubi_warn("failed to write VID header to LEB %d:%d, PEB %d",

		ubi_warn(ubi->ubi_num, "failed to write VID header to LEB %d:%d, PEB %d",

			 vol_id, lnum, pnum);

		goto write_error;

	}
@@ -668,7 +670,7 @@ retry: 
	if (len) {

		err = ubi_io_write_data(ubi, buf, pnum, offset, len);

		if (err) {

			ubi_warn("failed to write %d bytes at offset %d of LEB %d:%d, PEB %d",

			ubi_warn(ubi->ubi_num, "failed to write %d bytes at offset %d of LEB %d:%d, PEB %d",

				 len, offset, vol_id, lnum, pnum);

			goto write_error;

		}
@@ -704,7 +706,7 @@ write_error: 
	}



	vid_hdr->sqnum = cpu_to_be64(ubi_next_sqnum(ubi));

	ubi_msg("try another PEB");

	ubi_msg(ubi->ubi_num, "try another PEB");

	goto retry;

}
@@ -781,14 +783,14 @@ retry: 


	err = ubi_io_write_vid_hdr(ubi, pnum, vid_hdr);

	if (err) {

		ubi_warn("failed to write VID header to LEB %d:%d, PEB %d",

		ubi_warn(ubi->ubi_num, "failed to write VID header to LEB %d:%d, PEB %d",

			 vol_id, lnum, pnum);

		goto write_error;

	}



	err = ubi_io_write_data(ubi, buf, pnum, 0, len);

	if (err) {

		ubi_warn("failed to write %d bytes of data to PEB %d",

		ubi_warn(ubi->ubi_num, "failed to write %d bytes of data to PEB %d",

			 len, pnum);

		goto write_error;

	}
@@ -824,7 +826,7 @@ write_error: 
	}



	vid_hdr->sqnum = cpu_to_be64(ubi_next_sqnum(ubi));

	ubi_msg("try another PEB");

	ubi_msg(ubi->ubi_num, "try another PEB");

	goto retry;

}
@@ -899,14 +901,14 @@ retry: 


	err = ubi_io_write_vid_hdr(ubi, pnum, vid_hdr);

	if (err) {

		ubi_warn("failed to write VID header to LEB %d:%d, PEB %d",

		ubi_warn(ubi->ubi_num, "failed to write VID header to LEB %d:%d, PEB %d",

			 vol_id, lnum, pnum);

		goto write_error;

	}



	err = ubi_io_write_data(ubi, buf, pnum, 0, len);

	if (err) {

		ubi_warn("failed to write %d bytes of data to PEB %d",

		ubi_warn(ubi->ubi_num, "failed to write %d bytes of data to PEB %d",

			 len, pnum);

		goto write_error;

	}
@@ -946,7 +948,7 @@ write_error: 
	}



	vid_hdr->sqnum = cpu_to_be64(ubi_next_sqnum(ubi));

	ubi_msg("try another PEB");

	ubi_msg(ubi->ubi_num, "try another PEB");

	goto retry;

}
@@ -1069,7 +1071,7 @@ int ubi_eba_copy_leb(struct ubi_device *ubi, int from, int to, 
	dbg_wl("read %d bytes of data", aldata_size);

	err = ubi_io_read_data(ubi, ubi->peb_buf, from, 0, aldata_size);

	if (err && err != UBI_IO_BITFLIPS) {

		ubi_warn("error %d while reading data from PEB %d",

		ubi_warn(ubi->ubi_num, "error %d while reading data from PEB %d",

			 err, from);

		err = MOVE_SOURCE_RD_ERR;

		goto out_unlock_buf;
@@ -1119,7 +1121,7 @@ int ubi_eba_copy_leb(struct ubi_device *ubi, int from, int to, 
	err = ubi_io_read_vid_hdr(ubi, to, vid_hdr, 1);

	if (err) {

		if (err != UBI_IO_BITFLIPS) {

			ubi_warn("error %d while reading VID header back from PEB %d",

			ubi_warn(ubi->ubi_num, "error %d while reading VID header back from PEB %d",

				 err, to);

			if (is_error_sane(err))

				err = MOVE_TARGET_RD_ERR;
@@ -1146,7 +1148,7 @@ int ubi_eba_copy_leb(struct ubi_device *ubi, int from, int to, 
		err = ubi_io_read_data(ubi, ubi->peb_buf, to, 0, aldata_size);

		if (err) {

			if (err != UBI_IO_BITFLIPS) {

				ubi_warn("error %d while reading data back from PEB %d",

				ubi_warn(ubi->ubi_num, "error %d while reading data back from PEB %d",

					 err, to);

				if (is_error_sane(err))

					err = MOVE_TARGET_RD_ERR;
@@ -1158,7 +1160,7 @@ int ubi_eba_copy_leb(struct ubi_device *ubi, int from, int to, 
		cond_resched();



		if (crc != crc32(UBI_CRC32_INIT, ubi->peb_buf, data_size)) {

			ubi_warn("read data back from PEB %d and it is different",

			ubi_warn(ubi->ubi_num, "read data back from PEB %d and it is different",

				 to);

			err = -EINVAL;

			goto out_unlock_buf;
@@ -1211,10 +1213,10 @@ static void print_rsvd_warning(struct ubi_device *ubi, 
			return;

	}



	ubi_warn("cannot reserve enough PEBs for bad PEB handling, reserved %d, need %d",

	ubi_warn(ubi->ubi_num, "cannot reserve enough PEBs for bad PEB handling, reserved %d, need %d",

		 ubi->beb_rsvd_pebs, ubi->beb_rsvd_level);

	if (ubi->corr_peb_count)

		ubi_warn("%d PEBs are corrupted and not used",

		ubi_warn(ubi->ubi_num, "%d PEBs are corrupted and not used",

			 ubi->corr_peb_count);

}
@@ -1292,7 +1294,7 @@ int self_check_eba(struct ubi_device *ubi, struct ubi_attach_info *ai_fastmap, 
					fm_eba[i][j] == UBI_LEB_UNMAPPED)

					continue;



				ubi_err("LEB:%i:%i is PEB:%i instead of %i!",

				ubi_err(ubi->ubi_num, "LEB:%i:%i is PEB:%i instead of %i!",

					vol->vol_id, i, fm_eba[i][j],

					scan_eba[i][j]);

				ubi_assert(0);
@@ -1372,10 +1374,10 @@ int ubi_eba_init(struct ubi_device *ubi, struct ubi_attach_info *ai) 
	}



	if (ubi->avail_pebs < EBA_RESERVED_PEBS) {

		ubi_err("no enough physical eraseblocks (%d, need %d)",

		ubi_err(ubi->ubi_num, "no enough physical eraseblocks (%d, need %d)",

			ubi->avail_pebs, EBA_RESERVED_PEBS);

		if (ubi->corr_peb_count)

			ubi_err("%d PEBs are corrupted and not used",

			ubi_err(ubi->ubi_num, "%d PEBs are corrupted and not used",

				ubi->corr_peb_count);

		err = -ENOSPC;

		goto out_free;