UBI: Extend UBI layer debug/messaging capabilities (32608703) · Commits · e / devices / android_kernel_fairphone_FP5

drivers/mtd/ubi/attach.c

+66 −60

Original line number	Original line	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.		* validate_vid_hdr - check volume identifier header.
			* @ubi: UBI device description object
	* @vid_hdr: the volume identifier header to check		* @vid_hdr: the volume identifier header to check
	* @av: information about the volume this logical eraseblock belongs to		* @av: information about the volume this logical eraseblock belongs to
	* @pnum: physical eraseblock number the VID header came from		* @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		* information in the VID header is consistent to the information in other VID
	* headers of the same volume.		* 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)		const struct ubi_ainf_volume *av, int pnum)
	{		{
	int vol_type = vid_hdr->vol_type;		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) {		if (vol_id != av->vol_id) {
	ubi_err("inconsistent vol_id");		ubi_err(ubi, "inconsistent vol_id");
	goto bad;		goto bad;
	}		}

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

	if (vol_type != av_vol_type) {		if (vol_type != av_vol_type) {
	ubi_err("inconsistent vol_type");		ubi_err(ubi, "inconsistent vol_type");
	goto bad;		goto bad;
	}		}

	if (used_ebs != av->used_ebs) {		if (used_ebs != av->used_ebs) {
	ubi_err("inconsistent used_ebs");		ubi_err(ubi, "inconsistent used_ebs");
	goto bad;		goto bad;
	}		}

	if (data_pad != av->data_pad) {		if (data_pad != av->data_pad) {
	ubi_err("inconsistent data_pad");		ubi_err(ubi, "inconsistent data_pad");
	goto bad;		goto bad;
	}		}
	}		}
	@@ -234,7 +236,7 @@ static int validate_vid_hdr(const struct ubi_vid_hdr *vid_hdr,
	return 0;		return 0;

	bad:		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_vid_hdr(vid_hdr);
	ubi_dump_av(av);		ubi_dump_av(av);
	return -EINVAL;		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,		* support these images anymore. Well, those images still work,
	* but only if no unclean reboots happened.		* but only if no unclean reboots happened.
	*/		*/
	ubi_err("unsupported on-flash UBI format");		ubi_err(ubi, "unsupported on-flash UBI format");
	return -EINVAL;		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)		if (err == UBI_IO_BITFLIPS)
	bitflips = 1;		bitflips = 1;
	else {		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);		pnum, err);
	if (err > 0)		if (err > 0)
	err = -EIO;		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.		* logical eraseblocks because there was an unclean reboot.
	*/		*/
	if (aeb->sqnum == sqnum && sqnum != 0) {		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);		sqnum);
	ubi_dump_aeb(aeb, 0);		ubi_dump_aeb(aeb, 0);
	ubi_dump_vid_hdr(vid_hdr);		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		* This logical eraseblock is newer than the one
	* found earlier.		* found earlier.
	*/		*/
	err = validate_vid_hdr(vid_hdr, av, pnum);		err = validate_vid_hdr(ubi, vid_hdr, av, pnum);
	if (err)		if (err)
	return 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.		* attaching information.
	*/		*/

	err = validate_vid_hdr(vid_hdr, av, pnum);		err = validate_vid_hdr(ubi, vid_hdr, av, pnum);
	if (err)		if (err)
	return 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 counter overflow. Upgrade UBI and use 64-bit
	* erase counters internally.		* 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;		return -EINVAL;
	}		}

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

	ubi_err("no free eraseblocks");		ubi_err(ubi, "no free eraseblocks");
	return ERR_PTR(-ENOSPC);		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))		if (ubi_check_pattern(ubi->peb_buf, 0xFF, ubi->leb_size))
	goto out_unlock;		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);		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);		ubi_dump_vid_hdr(vid_hdr);
	pr_err("hexdump of PEB %d offset %d, length %d",		pr_err("hexdump of PEB %d offset %d, length %d",
	pnum, ubi->leb_start, ubi->leb_size);		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;		bitflips = 1;
	break;		break;
	default:		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;		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 */		/* Make sure UBI version is OK */
	if (ech->version != UBI_VERSION) {		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);		UBI_VERSION, (int)ech->version);
	return -EINVAL;		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		* flash. Upgrade UBI and use 64-bit erase counters
	* internally.		* internally.
	*/		*/
	ubi_err("erase counter overflow, max is %d",		ubi_err(ubi, "erase counter overflow, max is %d",
	UBI_MAX_ERASECOUNTER);		UBI_MAX_ERASECOUNTER);
	ubi_dump_ec_hdr(ech);		ubi_dump_ec_hdr(ech);
	return -EINVAL;		return -EINVAL;
	@@ -903,7 +907,7 @@ static int scan_peb(struct ubi_device ubi, struct ubi_attach_info ai,
	if (!ubi->image_seq)		if (!ubi->image_seq)
	ubi->image_seq = image_seq;		ubi->image_seq = image_seq;
	if (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);		image_seq, pnum, ubi->image_seq);
	ubi_dump_ec_hdr(ech);		ubi_dump_ec_hdr(ech);
	return -EINVAL;		return -EINVAL;
	@@ -981,7 +985,7 @@ static int scan_peb(struct ubi_device ubi, struct ubi_attach_info ai,
	return err;		return err;
	goto adjust_mean_ec;		goto adjust_mean_ec;
	default:		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);		err);
	return -EINVAL;		return -EINVAL;
	}		}
	@@ -999,7 +1003,7 @@ static int scan_peb(struct ubi_device ubi, struct ubi_attach_info ai,
	case UBI_COMPAT_DELETE:		case UBI_COMPAT_DELETE:
	if (vol_id != UBI_FM_SB_VOLUME_ID		if (vol_id != UBI_FM_SB_VOLUME_ID
	&& vol_id != UBI_FM_DATA_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);		vol_id, lnum);
	}		}
	err = add_to_list(ai, pnum, 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;		return 0;

	case UBI_COMPAT_RO:		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);		vol_id, lnum);
	ubi->ro_mode = 1;		ubi->ro_mode = 1;
	break;		break;

	case UBI_COMPAT_PRESERVE:		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);		vol_id, lnum);
	err = add_to_list(ai, pnum, vol_id, lnum,		err = add_to_list(ai, pnum, vol_id, lnum,
	ec, 0, &ai->alien);		ec, 0, &ai->alien);
	@@ -1024,14 +1028,14 @@ static int scan_peb(struct ubi_device ubi, struct ubi_attach_info ai,
	return 0;		return 0;

	case UBI_COMPAT_REJECT:		case UBI_COMPAT_REJECT:
	ubi_err("incompatible internal volume %d:%d found",		ubi_err(ubi, "incompatible internal volume %d:%d found",
	vol_id, lnum);		vol_id, lnum);
	return -EINVAL;		return -EINVAL;
	}		}
	}		}

	if (ec_err)		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);		pnum);
	err = ubi_add_to_av(ubi, ai, pnum, ec, vidh, bitflips);		err = ubi_add_to_av(ubi, ai, pnum, ec, vidh, bitflips);
	if (err)		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.		* with the flash HW or driver.
	*/		*/
	if (ai->corr_peb_count) {		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);		ai->corr_peb_count);
	pr_err("Corrupted PEBs are:");		pr_err("Corrupted PEBs are:");
	list_for_each_entry(aeb, &ai->corr, u.list)		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.		* otherwise, only print a warning.
	*/		*/
	if (ai->corr_peb_count >= max_corr) {		if (ai->corr_peb_count >= max_corr) {
	ubi_err("too many corrupted PEBs, refusing");		ubi_err(ubi, "too many corrupted PEBs, refusing");
	return -EINVAL;		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) {		if (ai->maybe_bad_peb_count <= 2) {
	ai->is_empty = 1;		ai->is_empty = 1;
	ubi_msg("empty MTD device detected");		ubi_msg(ubi, "empty MTD device detected");
	get_random_bytes(&ubi->image_seq,		get_random_bytes(&ubi->image_seq,
	sizeof(ubi->image_seq));		sizeof(ubi->image_seq));
	} else {		} 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;		return -EINVAL;
	}		}

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

	ubi_msg("scanning is finished");		ubi_msg(ubi, "scanning is finished");

	/* Calculate mean erase counter */		/* Calculate mean erase counter */
	if (ai->ec_count)		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;		vols_found += 1;

	if (ai->is_empty) {		if (ai->is_empty) {
	ubi_err("bad is_empty flag");		ubi_err(ubi, "bad is_empty flag");
	goto bad_av;		goto bad_av;
	}		}

	if (av->vol_id < 0 \|\| av->highest_lnum < 0 \|\|		if (av->vol_id < 0 \|\| av->highest_lnum < 0 \|\|
	av->leb_count < 0 \|\| av->vol_type < 0 \|\| av->used_ebs < 0 \|\|		av->leb_count < 0 \|\| av->vol_type < 0 \|\| av->used_ebs < 0 \|\|
	av->data_pad < 0 \|\| av->last_data_size < 0) {		av->data_pad < 0 \|\| av->last_data_size < 0) {
	ubi_err("negative values");		ubi_err(ubi, "negative values");
	goto bad_av;		goto bad_av;
	}		}

	if (av->vol_id >= UBI_MAX_VOLUMES &&		if (av->vol_id >= UBI_MAX_VOLUMES &&
	av->vol_id < UBI_INTERNAL_VOL_START) {		av->vol_id < UBI_INTERNAL_VOL_START) {
	ubi_err("bad vol_id");		ubi_err(ubi, "bad vol_id");
	goto bad_av;		goto bad_av;
	}		}

	if (av->vol_id > ai->highest_vol_id) {		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);		ai->highest_vol_id, av->vol_id);
	goto out;		goto out;
	}		}

	if (av->vol_type != UBI_DYNAMIC_VOLUME &&		if (av->vol_type != UBI_DYNAMIC_VOLUME &&
	av->vol_type != UBI_STATIC_VOLUME) {		av->vol_type != UBI_STATIC_VOLUME) {
	ubi_err("bad vol_type");		ubi_err(ubi, "bad vol_type");
	goto bad_av;		goto bad_av;
	}		}

	if (av->data_pad > ubi->leb_size / 2) {		if (av->data_pad > ubi->leb_size / 2) {
	ubi_err("bad data_pad");		ubi_err(ubi, "bad data_pad");
	goto bad_av;		goto bad_av;
	}		}

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

	if (aeb->pnum < 0 \|\| aeb->ec < 0) {		if (aeb->pnum < 0 \|\| aeb->ec < 0) {
	ubi_err("negative values");		ubi_err(ubi, "negative values");
	goto bad_aeb;		goto bad_aeb;
	}		}

	if (aeb->ec < ai->min_ec) {		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);		ai->min_ec, aeb->ec);
	goto bad_aeb;		goto bad_aeb;
	}		}

	if (aeb->ec > ai->max_ec) {		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);		ai->max_ec, aeb->ec);
	goto bad_aeb;		goto bad_aeb;
	}		}

	if (aeb->pnum >= ubi->peb_count) {		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);		aeb->pnum, ubi->peb_count);
	goto bad_aeb;		goto bad_aeb;
	}		}

	if (av->vol_type == UBI_STATIC_VOLUME) {		if (av->vol_type == UBI_STATIC_VOLUME) {
	if (aeb->lnum >= av->used_ebs) {		if (aeb->lnum >= av->used_ebs) {
	ubi_err("bad lnum or used_ebs");		ubi_err(ubi, "bad lnum or used_ebs");
	goto bad_aeb;		goto bad_aeb;
	}		}
	} else {		} else {
	if (av->used_ebs != 0) {		if (av->used_ebs != 0) {
	ubi_err("non-zero used_ebs");		ubi_err(ubi, "non-zero used_ebs");
	goto bad_aeb;		goto bad_aeb;
	}		}
	}		}

	if (aeb->lnum > av->highest_lnum) {		if (aeb->lnum > av->highest_lnum) {
	ubi_err("incorrect highest_lnum or lnum");		ubi_err(ubi, "incorrect highest_lnum or lnum");
	goto bad_aeb;		goto bad_aeb;
	}		}
	}		}

	if (av->leb_count != leb_count) {		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);		leb_count);
	goto bad_av;		goto bad_av;
	}		}
	@@ -1609,13 +1613,13 @@ static int self_check_ai(struct ubi_device ubi, struct ubi_attach_info ai)
	aeb = last_aeb;		aeb = last_aeb;

	if (aeb->lnum != av->highest_lnum) {		if (aeb->lnum != av->highest_lnum) {
	ubi_err("bad highest_lnum");		ubi_err(ubi, "bad highest_lnum");
	goto bad_aeb;		goto bad_aeb;
	}		}
	}		}

	if (vols_found != ai->vols_found) {		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);		ai->vols_found, vols_found);
	goto out;		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);		err = ubi_io_read_vid_hdr(ubi, aeb->pnum, vidh, 1);
	if (err && err != UBI_IO_BITFLIPS) {		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)		if (err > 0)
	err = -EIO;		err = -EIO;
	return err;		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 ?		vol_type = vidh->vol_type == UBI_VID_DYNAMIC ?
	UBI_DYNAMIC_VOLUME : UBI_STATIC_VOLUME;		UBI_DYNAMIC_VOLUME : UBI_STATIC_VOLUME;
	if (av->vol_type != vol_type) {		if (av->vol_type != vol_type) {
	ubi_err("bad vol_type");		ubi_err(ubi, "bad vol_type");
	goto bad_vid_hdr;		goto bad_vid_hdr;
	}		}

	if (aeb->sqnum != be64_to_cpu(vidh->sqnum)) {		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;		goto bad_vid_hdr;
	}		}

	if (av->vol_id != be32_to_cpu(vidh->vol_id)) {		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;		goto bad_vid_hdr;
	}		}

	if (av->compat != vidh->compat) {		if (av->compat != vidh->compat) {
	ubi_err("bad compat %d", vidh->compat);		ubi_err(ubi, "bad compat %d", vidh->compat);
	goto bad_vid_hdr;		goto bad_vid_hdr;
	}		}

	if (aeb->lnum != be32_to_cpu(vidh->lnum)) {		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;		goto bad_vid_hdr;
	}		}

	if (av->used_ebs != be32_to_cpu(vidh->used_ebs)) {		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;		goto bad_vid_hdr;
	}		}

	if (av->data_pad != be32_to_cpu(vidh->data_pad)) {		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;		goto bad_vid_hdr;
	}		}
	}		}
	@@ -1680,12 +1685,13 @@ static int self_check_ai(struct ubi_device ubi, struct ubi_attach_info ai)
	continue;		continue;

	if (av->highest_lnum != be32_to_cpu(vidh->lnum)) {		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;		goto bad_vid_hdr;
	}		}

	if (av->last_data_size != be32_to_cpu(vidh->data_size)) {		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;		goto bad_vid_hdr;
	}		}
	}		}
	@@ -1726,7 +1732,7 @@ static int self_check_ai(struct ubi_device ubi, struct ubi_attach_info ai)
	err = 0;		err = 0;
	for (pnum = 0; pnum < ubi->peb_count; pnum++)		for (pnum = 0; pnum < ubi->peb_count; pnum++)
	if (!buf[pnum]) {		if (!buf[pnum]) {
	ubi_err("PEB %d is not referred", pnum);		ubi_err(ubi, "PEB %d is not referred", pnum);
	err = 1;		err = 1;
	}		}

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

	bad_aeb:		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_aeb(aeb, 0);
	ubi_dump_av(av);		ubi_dump_av(av);
	goto out;		goto out;

	bad_av:		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);		ubi_dump_av(av);
	goto out;		goto out;

	bad_vid_hdr:		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_av(av);
	ubi_dump_vid_hdr(vidh);		ubi_dump_vid_hdr(vidh);

drivers/mtd/ubi/block.c

+20 −21

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

	len = strnlen(val, UBIBLOCK_PARAM_LEN);		len = strnlen(val, UBIBLOCK_PARAM_LEN);
	if (len == 0) {		if (len == 0) {
	ubi_warn("block: empty 'block=' parameter - ignored\n");		pr_warn("UBI: block: empty 'block=' parameter - ignored\n");
	return 0;		return 0;
	}		}

	if (len == UBIBLOCK_PARAM_LEN) {		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);		val, UBIBLOCK_PARAM_LEN);
	return -EINVAL;		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);		ret = ubi_read(dev->desc, leb, buffer, offset, len);
	if (ret) {		if (ret) {
	ubi_err("%s: error %d while reading from LEB %d (offset %d, "		dev_err(disk_to_dev(dev->gd), "%d while reading from LEB %d (offset %d, length %d)",
	"length %d)", dev->gd->disk_name, ret, leb, offset,		ret, leb, offset, len);
	len);
	return ret;		return ret;
	}		}
	return 0;		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);		dev->desc = ubi_open_volume(dev->ubi_num, dev->vol_id, UBI_READONLY);
	if (IS_ERR(dev->desc)) {		if (IS_ERR(dev->desc)) {
	ubi_err("%s failed to open ubi volume %d_%d",		dev_err(disk_to_dev(dev->gd), "failed to open ubi volume %d_%d",
	dev->gd->disk_name, dev->ubi_num, dev->vol_id);		dev->ubi_num, dev->vol_id);
	ret = PTR_ERR(dev->desc);		ret = PTR_ERR(dev->desc);
	dev->desc = NULL;		dev->desc = NULL;
	goto out_unlock;		goto out_unlock;
	@@ -405,7 +404,7 @@ int ubiblock_create(struct ubi_volume_info *vi)
	/* Initialize the gendisk of this ubiblock device */		/* Initialize the gendisk of this ubiblock device */
	gd = alloc_disk(1);		gd = alloc_disk(1);
	if (!gd) {		if (!gd) {
	ubi_err("block: alloc_disk failed");		pr_err("UBI: block: alloc_disk failed");
	ret = -ENODEV;		ret = -ENODEV;
	goto out_free_dev;		goto out_free_dev;
	}		}
	@@ -421,7 +420,7 @@ int ubiblock_create(struct ubi_volume_info *vi)
	spin_lock_init(&dev->queue_lock);		spin_lock_init(&dev->queue_lock);
	dev->rq = blk_init_queue(ubiblock_request, &dev->queue_lock);		dev->rq = blk_init_queue(ubiblock_request, &dev->queue_lock);
	if (!dev->rq) {		if (!dev->rq) {
	ubi_err("block: blk_init_queue failed");		dev_err(disk_to_dev(gd), "blk_init_queue failed");
	ret = -ENODEV;		ret = -ENODEV;
	goto out_put_disk;		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 */		/* Must be the last step: anyone can call file ops from now on */
	add_disk(dev->gd);		add_disk(dev->gd);
	ubi_msg("%s created from ubi%d:%d(%s)",		dev_info(disk_to_dev(dev->gd), "created from ubi%d:%d(%s)",
	dev->gd->disk_name, dev->ubi_num, dev->vol_id, vi->name);		dev->ubi_num, dev->vol_id, vi->name);
	return 0;		return 0;

	out_free_queue:		out_free_queue:
	@@ -464,7 +463,7 @@ static void ubiblock_cleanup(struct ubiblock *dev)
	{		{
	del_gendisk(dev->gd);		del_gendisk(dev->gd);
	blk_cleanup_queue(dev->rq);		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);		put_disk(dev->gd);
	}		}

	@@ -518,8 +517,8 @@ static int ubiblock_resize(struct ubi_volume_info *vi)
	}		}
	if ((sector_t)disk_capacity != disk_capacity) {		if ((sector_t)disk_capacity != disk_capacity) {
	mutex_unlock(&devices_mutex);		mutex_unlock(&devices_mutex);
	ubi_warn("%s: the volume is too big (%d LEBs), cannot resize",		dev_warn(disk_to_dev(dev->gd), "the volume is too big (%d LEBs), cannot resize",
	dev->gd->disk_name, vi->size);		vi->size);
	return -EFBIG;		return -EFBIG;
	}		}

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

	if (get_capacity(dev->gd) != disk_capacity) {		if (get_capacity(dev->gd) != disk_capacity) {
	set_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);		vi->used_bytes);
	}		}
	mutex_unlock(&dev->dev_mutex);		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);		desc = open_volume_desc(p->name, p->ubi_num, p->vol_id);
	if (IS_ERR(desc)) {		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));		PTR_ERR(desc));
	ret = PTR_ERR(desc);		ret = PTR_ERR(desc);
	break;		break;
	@@ -607,7 +606,7 @@ static int __init ubiblock_create_from_param(void)

	ret = ubiblock_create(&vi);		ret = ubiblock_create(&vi);
	if (ret) {		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);		vi.name, ret);
	break;		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	Original line	Diff line number	Diff line
	@@ -48,13 +48,14 @@

	/**		/**
	* get_exclusive - get exclusive access to an UBI volume.		* get_exclusive - get exclusive access to an UBI volume.
			* @ubi: UBI device description object
	* @desc: volume descriptor		* @desc: volume descriptor
	*		*
	* This function changes UBI volume open mode to "exclusive". Returns previous		* This function changes UBI volume open mode to "exclusive". Returns previous
	* mode value (positive integer) in case of success and a negative error code		* mode value (positive integer) in case of success and a negative error code
	* in case of failure.		* 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;		int users, err;
	struct ubi_volume *vol = desc->vol;		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;		users = vol->readers + vol->writers + vol->exclusive;
	ubi_assert(users > 0);		ubi_assert(users > 0);
	if (users > 1) {		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;		err = -EBUSY;
	} else {		} else {
	vol->readers = vol->writers = 0;		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);		vol->ubi->ubi_num, vol->vol_id, desc->mode);

	if (vol->updating) {		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);		vol->vol_id);
	ubi_assert(!vol->changing_leb);		ubi_assert(!vol->changing_leb);
	vol->updating = 0;		vol->updating = 0;
	@@ -158,7 +159,7 @@ static loff_t vol_cdev_llseek(struct file *file, loff_t offset, int origin)

	if (vol->updating) {		if (vol->updating) {
	/* Update is in progress, seeking is prohibited */		/* Update is in progress, seeking is prohibited */
	ubi_err("updating");		ubi_err(vol->ubi, "updating");
	return -EBUSY;		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);		count, *offp, vol->vol_id);

	if (vol->updating) {		if (vol->updating) {
	ubi_err("updating");		ubi_err(vol->ubi, "updating");
	return -EBUSY;		return -EBUSY;
	}		}
	if (vol->upd_marker) {		if (vol->upd_marker) {
	ubi_err("damaged volume, update marker is set");		ubi_err(vol->ubi, "damaged volume, update marker is set");
	return -EBADF;		return -EBADF;
	}		}
	if (*offp == vol->used_bytes \|\| count == 0)		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);		lnum = div_u64_rem(*offp, vol->usable_leb_size, &off);
	if (off & (ubi->min_io_size - 1)) {		if (off & (ubi->min_io_size - 1)) {
	ubi_err("unaligned position");		ubi_err(ubi, "unaligned position");
	return -EINVAL;		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 */		/* We can write only in fractions of the minimum I/O unit */
	if (count & (ubi->min_io_size - 1)) {		if (count & (ubi->min_io_size - 1)) {
	ubi_err("unaligned write length");		ubi_err(ubi, "unaligned write length");
	return -EINVAL;		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);		err = ubi_more_leb_change_data(ubi, vol, buf, count);

	if (err < 0) {		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);		count, err);
	return err;		return err;
	}		}
	@@ -370,7 +371,7 @@ static ssize_t vol_cdev_write(struct file file, const char __user buf,
	return err;		return err;

	if (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->vol_id, ubi->ubi_num);
	vol->corrupted = 1;		vol->corrupted = 1;
	}		}
	@@ -420,7 +421,7 @@ static long vol_cdev_ioctl(struct file *file, unsigned int cmd,
	break;		break;
	}		}

	err = get_exclusive(desc);		err = get_exclusive(ubi, desc);
	if (err < 0)		if (err < 0)
	break;		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)		req.bytes < 0 \|\| req.lnum >= vol->usable_leb_size)
	break;		break;

	err = get_exclusive(desc);		err = get_exclusive(ubi, desc);
	if (err < 0)		if (err < 0)
	break;		break;

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

	bad:		bad:
	ubi_err("bad volume creation request");		ubi_err(ubi, "bad volume creation request");
	ubi_dump_mkvol_req(req);		ubi_dump_mkvol_req(req);
	return err;		return err;
	}		}
	@@ -708,12 +709,12 @@ static int rename_volumes(struct ubi_device *ubi,
	for (i = 0; i < req->count - 1; i++) {		for (i = 0; i < req->count - 1; i++) {
	for (n = i + 1; n < req->count; n++) {		for (n = i + 1; n < req->count; n++) {
	if (req->ents[i].vol_id == req->ents[n].vol_id) {		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);		req->ents[i].vol_id);
	return -EINVAL;		return -EINVAL;
	}		}
	if (!strcmp(req->ents[i].name, req->ents[n].name)) {		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);		req->ents[i].name);
	return -EINVAL;		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);		re->desc = ubi_open_volume(ubi->ubi_num, vol_id, UBI_READWRITE);
	if (IS_ERR(re->desc)) {		if (IS_ERR(re->desc)) {
	err = PTR_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);		kfree(re);
	goto out_free;		goto out_free;
	}		}
	@@ -795,7 +797,7 @@ static int rename_volumes(struct ubi_device *ubi,
	continue;		continue;

	/* The volume exists but busy, or an error occurred */		/* 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);		re->new_name, err);
	goto out_free;		goto out_free;
	}		}

drivers/mtd/ubi/debug.c

+5 −5

Original line number	Original line	Diff line number	Diff line
	@@ -43,12 +43,12 @@ void ubi_dump_flash(struct ubi_device *ubi, int pnum, int offset, int len)
	return;		return;
	err = mtd_read(ubi->mtd, addr, len, &read, buf);		err = mtd_read(ubi->mtd, addr, len, &read, buf);
	if (err && err != -EUCLEAN) {		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);		err, len, pnum, offset, read);
	goto out;		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);		len, pnum, offset);
	print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1, buf, len, 1);		print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1, buf, len, 1);
	out:		out:
	@@ -238,7 +238,7 @@ int ubi_debugfs_init(void)
	if (IS_ERR_OR_NULL(dfs_rootdir)) {		if (IS_ERR_OR_NULL(dfs_rootdir)) {
	int err = dfs_rootdir ? -ENODEV : PTR_ERR(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);		err);
	return err;		return err;
	}		}
	@@ -433,7 +433,7 @@ int ubi_debugfs_init_dev(struct ubi_device *ubi)
	debugfs_remove_recursive(d->dfs_dir);		debugfs_remove_recursive(d->dfs_dir);
	out:		out:
	err = dent ? PTR_ERR(dent) : -ENODEV;		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);		fname, err);
	return err;		return err;
	}		}