Merge "mtd: ubi: Extend UBI layer debug/messaging capabilities" (86cc1b62) · Commits · e / devices / android_kernel_sony_msm8994

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)
		@@ -1588,37 +1598,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;
		}

		@@ -1630,48 +1640,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;
		}
		@@ -1682,13 +1692,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;
		}
		@@ -1705,7 +1715,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;
		@@ -1714,37 +1725,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;
		}
		}
		@@ -1753,12 +1769,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;
		}
		}
		@@ -1799,7 +1817,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;
		}

		@@ -1809,18 +1827,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;