Commit ccb5a491 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'upstream-3.19-rc1' of git://git.infradead.org/linux-ubifs 

Pull UBI/UBIFS updates from Artem Bityutskiy:
 "This includes the following UBI/UBIFS changes:
   - UBI debug messages now include the UBI device number.  This change
     is responsible for the big diffstat since it touched every
     debugging print statement.
   - An Xattr bug-fix which fixes SELinux support
   - Several error path fixes in UBI/UBIFS"

* tag 'upstream-3.19-rc1' of git://git.infradead.org/linux-ubifs:
  UBI: Fix invalid vfree()
  UBI: Fix double free after do_sync_erase()
  UBIFS: fix a couple bugs in UBIFS xattr length calculation
  UBI: vtbl: Use ubi_eba_atomic_leb_change()
  UBI: Extend UBI layer debug/messaging capabilities
  UBIFS: fix budget leak in error path
parents c05e14f7 f38aed97

drivers/mtd/ubi/attach.c

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


/**

 * validate_vid_hdr - check volume identifier header.

 * @ubi: UBI device description object

 * @vid_hdr: the volume identifier header to check

 * @av: information about the volume this logical eraseblock belongs to

 * @pnum: physical eraseblock number the VID header came from
@@ -188,7 +189,8 @@ static int add_corrupted(struct ubi_attach_info *ai, int pnum, int ec) 
 * information in the VID header is consistent to the information in other VID

 * headers of the same volume.

 */

static int validate_vid_hdr(const struct ubi_vid_hdr *vid_hdr,

static int validate_vid_hdr(const struct ubi_device *ubi,

			    const struct ubi_vid_hdr *vid_hdr,

			    const struct ubi_ainf_volume *av, int pnum)

{

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



		if (vol_id != av->vol_id) {

			ubi_err("inconsistent vol_id");

			ubi_err(ubi, "inconsistent vol_id");

			goto bad;

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



		if (vol_type != av_vol_type) {

			ubi_err("inconsistent vol_type");

			ubi_err(ubi, "inconsistent vol_type");

			goto bad;

		}



		if (used_ebs != av->used_ebs) {

			ubi_err("inconsistent used_ebs");

			ubi_err(ubi, "inconsistent used_ebs");

			goto bad;

		}



		if (data_pad != av->data_pad) {

			ubi_err("inconsistent data_pad");

			ubi_err(ubi, "inconsistent data_pad");

			goto bad;

		}

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



bad:

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

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

	ubi_dump_vid_hdr(vid_hdr);

	ubi_dump_av(av);

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

		 * but only if no unclean reboots happened.

		 */

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

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

		return -EINVAL;

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

				bitflips = 1;

			else {

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

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

					pnum, err);

				if (err > 0)

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

		 */

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

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

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

				sqnum);

			ubi_dump_aeb(aeb, 0);

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

			 * found earlier.

			 */

			err = validate_vid_hdr(vid_hdr, av, pnum);

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

			if (err)

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

	 */



	err = validate_vid_hdr(vid_hdr, av, pnum);

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

	if (err)

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

		 * erase counters internally.

		 */

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

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

			pnum, ec);

		return -EINVAL;

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

	}



	ubi_err("no free eraseblocks");

	ubi_err(ubi, "no free eraseblocks");

	return ERR_PTR(-ENOSPC);

}
@@ -785,9 +788,9 @@ static int check_corruption(struct ubi_device *ubi, struct ubi_vid_hdr *vid_hdr, 
	if (ubi_check_pattern(ubi->peb_buf, 0xFF, ubi->leb_size))

		goto out_unlock;



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

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

		pnum);

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

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

	ubi_dump_vid_hdr(vid_hdr);

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

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

		break;

	default:

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

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

			err);

		return -EINVAL;

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


		/* Make sure UBI version is OK */

		if (ech->version != UBI_VERSION) {

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

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

				UBI_VERSION, (int)ech->version);

			return -EINVAL;

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

			 * internally.

			 */

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

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

				UBI_MAX_ERASECOUNTER);

			ubi_dump_ec_hdr(ech);

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

			ubi->image_seq = image_seq;

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

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

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

				image_seq, pnum, ubi->image_seq);

			ubi_dump_ec_hdr(ech);

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

		goto adjust_mean_ec;

	default:

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

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

			err);

		return -EINVAL;

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

			if (vol_id != UBI_FM_SB_VOLUME_ID

			    && vol_id != UBI_FM_DATA_VOLUME_ID) {

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

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

					vol_id, lnum);

			}

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



		case UBI_COMPAT_RO:

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

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

				vol_id, lnum);

			ubi->ro_mode = 1;

			break;



		case UBI_COMPAT_PRESERVE:

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

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

				vol_id, lnum);

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

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



		case UBI_COMPAT_REJECT:

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

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

				vol_id, lnum);

			return -EINVAL;

		}

	}



	if (ec_err)

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

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

			 pnum);

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

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

	 */

	if (ai->corr_peb_count) {

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

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

			ai->corr_peb_count);

		pr_err("Corrupted PEBs are:");

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

		 */

		if (ai->corr_peb_count >= max_corr) {

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

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

			return -EINVAL;

		}

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

		if (ai->maybe_bad_peb_count <= 2) {

			ai->is_empty = 1;

			ubi_msg("empty MTD device detected");

			ubi_msg(ubi, "empty MTD device detected");

			get_random_bytes(&ubi->image_seq,

					 sizeof(ubi->image_seq));

		} else {

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

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

			return -EINVAL;

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

	}



	ubi_msg("scanning is finished");

	ubi_msg(ubi, "scanning is finished");



	/* Calculate mean erase counter */

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



		if (ai->is_empty) {

			ubi_err("bad is_empty flag");

			ubi_err(ubi, "bad is_empty flag");

			goto bad_av;

		}



		if (av->vol_id < 0 || av->highest_lnum < 0 ||

		    av->leb_count < 0 || av->vol_type < 0 || av->used_ebs < 0 ||

		    av->data_pad < 0 || av->last_data_size < 0) {

			ubi_err("negative values");

			ubi_err(ubi, "negative values");

			goto bad_av;

		}



		if (av->vol_id >= UBI_MAX_VOLUMES &&

		    av->vol_id < UBI_INTERNAL_VOL_START) {

			ubi_err("bad vol_id");

			ubi_err(ubi, "bad vol_id");

			goto bad_av;

		}



		if (av->vol_id > ai->highest_vol_id) {

			ubi_err("highest_vol_id is %d, but vol_id %d is there",

			ubi_err(ubi, "highest_vol_id is %d, but vol_id %d is there",

				ai->highest_vol_id, av->vol_id);

			goto out;

		}



		if (av->vol_type != UBI_DYNAMIC_VOLUME &&

		    av->vol_type != UBI_STATIC_VOLUME) {

			ubi_err("bad vol_type");

			ubi_err(ubi, "bad vol_type");

			goto bad_av;

		}



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

			ubi_err("bad data_pad");

			ubi_err(ubi, "bad data_pad");

			goto bad_av;

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



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

				ubi_err("negative values");

				ubi_err(ubi, "negative values");

				goto bad_aeb;

			}



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

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

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

					ai->min_ec, aeb->ec);

				goto bad_aeb;

			}



			if (aeb->ec > ai->max_ec) {

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

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

					ai->max_ec, aeb->ec);

				goto bad_aeb;

			}



			if (aeb->pnum >= ubi->peb_count) {

				ubi_err("too high PEB number %d, total PEBs %d",

				ubi_err(ubi, "too high PEB number %d, total PEBs %d",

					aeb->pnum, ubi->peb_count);

				goto bad_aeb;

			}



			if (av->vol_type == UBI_STATIC_VOLUME) {

				if (aeb->lnum >= av->used_ebs) {

					ubi_err("bad lnum or used_ebs");

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

					goto bad_aeb;

				}

			} else {

				if (av->used_ebs != 0) {

					ubi_err("non-zero used_ebs");

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

					goto bad_aeb;

				}

			}



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

				ubi_err("incorrect highest_lnum or lnum");

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

				goto bad_aeb;

			}

		}



		if (av->leb_count != leb_count) {

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

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

				leb_count);

			goto bad_av;

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



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

			ubi_err("bad highest_lnum");

			ubi_err(ubi, "bad highest_lnum");

			goto bad_aeb;

		}

	}



	if (vols_found != ai->vols_found) {

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

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

			ai->vols_found, vols_found);

		goto out;

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


			err = ubi_io_read_vid_hdr(ubi, aeb->pnum, vidh, 1);

			if (err && err != UBI_IO_BITFLIPS) {

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

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

					err);

				if (err > 0)

					err = -EIO;

				return err;
@@ -1641,37 +1646,37 @@ static int self_check_ai(struct ubi_device *ubi, struct ubi_attach_info *ai) 
			vol_type = vidh->vol_type == UBI_VID_DYNAMIC ?

				   UBI_DYNAMIC_VOLUME : UBI_STATIC_VOLUME;

			if (av->vol_type != vol_type) {

				ubi_err("bad vol_type");

				ubi_err(ubi, "bad vol_type");

				goto bad_vid_hdr;

			}



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

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

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

				goto bad_vid_hdr;

			}



			if (av->vol_id != be32_to_cpu(vidh->vol_id)) {

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

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

				goto bad_vid_hdr;

			}



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

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

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

				goto bad_vid_hdr;

			}



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

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

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

				goto bad_vid_hdr;

			}



			if (av->used_ebs != be32_to_cpu(vidh->used_ebs)) {

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

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

				goto bad_vid_hdr;

			}



			if (av->data_pad != be32_to_cpu(vidh->data_pad)) {

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

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

				goto bad_vid_hdr;

			}

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



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

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

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

			goto bad_vid_hdr;

		}



		if (av->last_data_size != be32_to_cpu(vidh->data_size)) {

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

			ubi_err(ubi, "bad last_data_size %d",

				av->last_data_size);

			goto bad_vid_hdr;

		}

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

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

		if (!buf[pnum]) {

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

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

			err = 1;

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



bad_aeb:

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

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

	ubi_dump_aeb(aeb, 0);

	ubi_dump_av(av);

	goto out;



bad_av:

	ubi_err("bad attaching information about volume %d", av->vol_id);

	ubi_err(ubi, "bad attaching information about volume %d", av->vol_id);

	ubi_dump_av(av);

	goto out;



bad_vid_hdr:

	ubi_err("bad attaching information about volume %d", av->vol_id);

	ubi_err(ubi, "bad attaching information about volume %d", av->vol_id);

	ubi_dump_av(av);

	ubi_dump_vid_hdr(vidh);

drivers/mtd/ubi/block.c

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


	len = strnlen(val, UBIBLOCK_PARAM_LEN);

	if (len == 0) {

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

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

		return 0;

	}



	if (len == UBIBLOCK_PARAM_LEN) {

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

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

		       val, UBIBLOCK_PARAM_LEN);

		return -EINVAL;

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


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

	if (ret) {

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

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

			len);

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

			ret, leb, offset, len);

		return ret;

	}

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


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

	if (IS_ERR(dev->desc)) {

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

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

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

			dev->ubi_num, dev->vol_id);

		ret = PTR_ERR(dev->desc);

		dev->desc = NULL;

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

	gd = alloc_disk(1);

	if (!gd) {

		ubi_err("block: alloc_disk failed");

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

		ret = -ENODEV;

		goto out_free_dev;

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

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

	if (!dev->rq) {

		ubi_err("block: blk_init_queue failed");

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

		ret = -ENODEV;

		goto out_put_disk;

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


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

	add_disk(dev->gd);

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

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

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

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

	return 0;



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

	del_gendisk(dev->gd);

	blk_cleanup_queue(dev->rq);

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

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

	put_disk(dev->gd);

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

	if ((sector_t)disk_capacity != disk_capacity) {

		mutex_unlock(&devices_mutex);

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

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

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

			 vi->size);

		return -EFBIG;

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


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

		set_capacity(dev->gd, disk_capacity);

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

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

			 vi->used_bytes);

	}

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


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

		if (IS_ERR(desc)) {

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

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

			       PTR_ERR(desc));

			ret = PTR_ERR(desc);

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


		ret = ubiblock_create(&vi);

		if (ret) {

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

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

			       vi.name, ret);

			break;

		}

drivers/mtd/ubi/build.c

+67 −59

File changed.

Preview size limit exceeded, changes collapsed.

drivers/mtd/ubi/cdev.c

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


/**

 * get_exclusive - get exclusive access to an UBI volume.

 * @ubi: UBI device description object

 * @desc: volume descriptor

 *

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

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

 * in case of failure.

 */

static int get_exclusive(struct ubi_volume_desc *desc)

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

{

	int users, err;

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

	ubi_assert(users > 0);

	if (users > 1) {

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

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

		err = -EBUSY;

	} else {

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



	if (vol->updating) {

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

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

			 vol->vol_id);

		ubi_assert(!vol->changing_leb);

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


	if (vol->updating) {

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

		ubi_err("updating");

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

		return -EBUSY;

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



	if (vol->updating) {

		ubi_err("updating");

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

		return -EBUSY;

	}

	if (vol->upd_marker) {

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

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

		return -EBADF;

	}

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


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

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

		ubi_err("unaligned position");

		ubi_err(ubi, "unaligned position");

		return -EINVAL;

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


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

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

		ubi_err("unaligned write length");

		ubi_err(ubi, "unaligned write length");

		return -EINVAL;

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



	if (err < 0) {

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

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

			count, err);

		return err;

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



		if (err) {

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

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

				 vol->vol_id, ubi->ubi_num);

			vol->corrupted = 1;

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

		}



		err = get_exclusive(desc);

		err = get_exclusive(ubi, desc);

		if (err < 0)

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

			break;



		err = get_exclusive(desc);

		err = get_exclusive(ubi, desc);

		if (err < 0)

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



bad:

	ubi_err("bad volume creation request");

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

	ubi_dump_mkvol_req(req);

	return err;

}
@@ -708,12 +709,12 @@ static int rename_volumes(struct ubi_device *ubi, 
	for (i = 0; i < req->count - 1; i++) {

		for (n = i + 1; n < req->count; n++) {

			if (req->ents[i].vol_id == req->ents[n].vol_id) {

				ubi_err("duplicated volume id %d",

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

					req->ents[i].vol_id);

				return -EINVAL;

			}

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

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

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

					req->ents[i].name);

				return -EINVAL;

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

		if (IS_ERR(re->desc)) {

			err = PTR_ERR(re->desc);

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

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

				vol_id, err);

			kfree(re);

			goto out_free;

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



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

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

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

				re->new_name, err);

			goto out_free;

		}

drivers/mtd/ubi/debug.c

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

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

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

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

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

			err, len, pnum, offset, read);

		goto out;

	}



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

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

		len, pnum, offset);

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

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

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



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

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

		       err);

		return err;

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

		fname, err);

	return err;

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE