Merge branch 'linux-next' of git://git.infradead.org/ubi-2.6 (d6be791c) · Commits · 戴 / test

drivers/mtd/ubi/build.c

+6 −0

Original line number	Diff line number	Diff line
		@@ -657,6 +657,11 @@ static int io_init(struct ubi_device *ubi)
		if (ubi->mtd->block_isbad && ubi->mtd->block_markbad)
		ubi->bad_allowed = 1;

		if (ubi->mtd->type == MTD_NORFLASH) {
		ubi_assert(ubi->mtd->writesize == 1);
		ubi->nor_flash = 1;
		}

		ubi->min_io_size = ubi->mtd->writesize;
		ubi->hdrs_min_io_size = ubi->mtd->writesize >> ubi->mtd->subpage_sft;

		@@ -996,6 +1001,7 @@ int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num, int vid_hdr_offset)
		ubi_msg("number of PEBs reserved for bad PEB handling: %d",
		ubi->beb_rsvd_pebs);
		ubi_msg("max/mean erase counter: %d/%d", ubi->max_ec, ubi->mean_ec);
		ubi_msg("image sequence number: %d", ubi->image_seq);

		/*
		* The below lock makes sure we do not race with 'ubi_thread()' which

drivers/mtd/ubi/debug.c

+2 −0

Original line number	Diff line number	Diff line
		@@ -44,6 +44,8 @@ void ubi_dbg_dump_ec_hdr(const struct ubi_ec_hdr *ec_hdr)
		be32_to_cpu(ec_hdr->vid_hdr_offset));
		printk(KERN_DEBUG "\tdata_offset %d\n",
		be32_to_cpu(ec_hdr->data_offset));
		printk(KERN_DEBUG "\timage_seq %d\n",
		be32_to_cpu(ec_hdr->image_seq));
		printk(KERN_DEBUG "\thdr_crc %#08x\n",
		be32_to_cpu(ec_hdr->hdr_crc));
		printk(KERN_DEBUG "erase counter header hexdump:\n");

drivers/mtd/ubi/debug.h

+7 −0

Original line number	Diff line number	Diff line
		@@ -93,6 +93,12 @@ void ubi_dbg_dump_mkvol_req(const struct ubi_mkvol_req *req);
		#define UBI_IO_DEBUG 0
		#endif

		#ifdef CONFIG_MTD_UBI_DEBUG_PARANOID
		int ubi_dbg_check_all_ff(struct ubi_device *ubi, int pnum, int offset, int len);
		#else
		#define ubi_dbg_check_all_ff(ubi, pnum, offset, len) 0
		#endif

		#ifdef CONFIG_MTD_UBI_DEBUG_DISABLE_BGT
		#define DBG_DISABLE_BGT 1
		#else
		@@ -167,6 +173,7 @@ static inline int ubi_dbg_is_erase_failure(void)
		#define ubi_dbg_is_bitflip() 0
		#define ubi_dbg_is_write_failure() 0
		#define ubi_dbg_is_erase_failure() 0
		#define ubi_dbg_check_all_ff(ubi, pnum, offset, len) 0

		#endif /* !CONFIG_MTD_UBI_DEBUG */
		#endif /* !__UBI_DEBUG_H__ */

drivers/mtd/ubi/io.c

+61 −96

Original line number	Diff line number	Diff line
		@@ -98,17 +98,12 @@ static int paranoid_check_ec_hdr(const struct ubi_device *ubi, int pnum,
		static int paranoid_check_peb_vid_hdr(const struct ubi_device *ubi, int pnum);
		static int paranoid_check_vid_hdr(const struct ubi_device *ubi, int pnum,
		const struct ubi_vid_hdr *vid_hdr);
		static int paranoid_check_all_ff(struct ubi_device *ubi, int pnum, int offset,
		int len);
		static int paranoid_check_empty(struct ubi_device *ubi, int pnum);
		#else
		#define paranoid_check_not_bad(ubi, pnum) 0
		#define paranoid_check_peb_ec_hdr(ubi, pnum) 0
		#define paranoid_check_ec_hdr(ubi, pnum, ec_hdr) 0
		#define paranoid_check_peb_vid_hdr(ubi, pnum) 0
		#define paranoid_check_vid_hdr(ubi, pnum, vid_hdr) 0
		#define paranoid_check_all_ff(ubi, pnum, offset, len) 0
		#define paranoid_check_empty(ubi, pnum) 0
		#endif

		/**
		@@ -244,7 +239,7 @@ int ubi_io_write(struct ubi_device ubi, const void buf, int pnum, int offset,
		return err > 0 ? -EINVAL : err;

		/* The area we are writing to has to contain all 0xFF bytes */
		err = paranoid_check_all_ff(ubi, pnum, offset, len);
		err = ubi_dbg_check_all_ff(ubi, pnum, offset, len);
		if (err)
		return err > 0 ? -EINVAL : err;

		@@ -350,7 +345,7 @@ retry:
		return -EIO;
		}

		err = paranoid_check_all_ff(ubi, pnum, 0, ubi->peb_size);
		err = ubi_dbg_check_all_ff(ubi, pnum, 0, ubi->peb_size);
		if (err)
		return err > 0 ? -EINVAL : err;

		@@ -458,6 +453,54 @@ out:
		return err;
		}

		/**
		* nor_erase_prepare - prepare a NOR flash PEB for erasure.
		* @ubi: UBI device description object
		* @pnum: physical eraseblock number to prepare
		*
		* NOR flash, or at least some of them, have peculiar embedded PEB erasure
		* algorithm: the PEB is first filled with zeroes, then it is erased. And
		* filling with zeroes starts from the end of the PEB. This was observed with
		* Spansion S29GL512N NOR flash.
		*
		* This means that in case of a power cut we may end up with intact data at the
		* beginning of the PEB, and all zeroes at the end of PEB. In other words, the
		* EC and VID headers are OK, but a large chunk of data at the end of PEB is
		* zeroed. This makes UBI mistakenly treat this PEB as used and associate it
		* with an LEB, which leads to subsequent failures (e.g., UBIFS fails).
		*
		* This function is called before erasing NOR PEBs and it zeroes out EC and VID
		* magic numbers in order to invalidate them and prevent the failures. Returns
		* zero in case of success and a negative error code in case of failure.
		*/
		static int nor_erase_prepare(struct ubi_device *ubi, int pnum)
		{
		int err;
		size_t written;
		loff_t addr;
		uint32_t data = 0;

		addr = (loff_t)pnum * ubi->peb_size;
		err = ubi->mtd->write(ubi->mtd, addr, 4, &written, (void *)&data);
		if (err) {
		ubi_err("error %d while writing 4 bytes to PEB %d:%d, written "
		"%zd bytes", err, pnum, 0, written);
		ubi_dbg_dump_stack();
		return err;
		}

		addr += ubi->vid_hdr_aloffset;
		err = ubi->mtd->write(ubi->mtd, addr, 4, &written, (void *)&data);
		if (err) {
		ubi_err("error %d while writing 4 bytes to PEB %d:%d, written "
		"%zd bytes", err, pnum, ubi->vid_hdr_aloffset, written);
		ubi_dbg_dump_stack();
		return err;
		}

		return 0;
		}

		/**
		* ubi_io_sync_erase - synchronously erase a physical eraseblock.
		* @ubi: UBI device description object
		@@ -489,6 +532,12 @@ int ubi_io_sync_erase(struct ubi_device *ubi, int pnum, int torture)
		return -EROFS;
		}

		if (ubi->nor_flash) {
		err = nor_erase_prepare(ubi, pnum);
		if (err)
		return err;
		}

		if (torture) {
		ret = torture_peb(ubi, pnum);
		if (ret < 0)
		@@ -672,11 +721,6 @@ int ubi_io_read_ec_hdr(struct ubi_device *ubi, int pnum,
		if (read_err != -EBADMSG &&
		check_pattern(ec_hdr, 0xFF, UBI_EC_HDR_SIZE)) {
		/* The physical eraseblock is supposedly empty */
		err = paranoid_check_all_ff(ubi, pnum, 0,
		ubi->peb_size);
		if (err)
		return err > 0 ? UBI_IO_BAD_EC_HDR : err;

		if (verbose)
		ubi_warn("no EC header found at PEB %d, "
		"only 0xFF bytes", pnum);
		@@ -752,6 +796,7 @@ int ubi_io_write_ec_hdr(struct ubi_device *ubi, int pnum,
		ec_hdr->version = UBI_VERSION;
		ec_hdr->vid_hdr_offset = cpu_to_be32(ubi->vid_hdr_offset);
		ec_hdr->data_offset = cpu_to_be32(ubi->leb_start);
		ec_hdr->image_seq = cpu_to_be32(ubi->image_seq);
		crc = crc32(UBI_CRC32_INIT, ec_hdr, UBI_EC_HDR_SIZE_CRC);
		ec_hdr->hdr_crc = cpu_to_be32(crc);

		@@ -947,15 +992,6 @@ int ubi_io_read_vid_hdr(struct ubi_device *ubi, int pnum,
		if (read_err != -EBADMSG &&
		check_pattern(vid_hdr, 0xFF, UBI_VID_HDR_SIZE)) {
		/* The physical eraseblock is supposedly free */

		/*
		* The below is just a paranoid check, it has to be
		* compiled out if paranoid checks are disabled.
		*/
		err = paranoid_check_empty(ubi, pnum);
		if (err)
		return err > 0 ? UBI_IO_BAD_VID_HDR : err;

		if (verbose)
		ubi_warn("no VID header found at PEB %d, "
		"only 0xFF bytes", pnum);
		@@ -1229,7 +1265,7 @@ exit:
		}

		/**
		* paranoid_check_all_ff - check that a region of flash is empty.
		* ubi_dbg_check_all_ff - check that a region of flash is empty.
		* @ubi: UBI device description object
		* @pnum: the physical eraseblock number to check
		* @offset: the starting offset within the physical eraseblock to check
		@@ -1239,8 +1275,7 @@ exit:
		* @offset of the physical eraseblock @pnum, %1 if not, and a negative error
		* code if an error occurred.
		*/
		static int paranoid_check_all_ff(struct ubi_device *ubi, int pnum, int offset,
		int len)
		int ubi_dbg_check_all_ff(struct ubi_device *ubi, int pnum, int offset, int len)
		{
		size_t read;
		int err;
		@@ -1276,74 +1311,4 @@ error:
		return err;
		}

		/**
		* paranoid_check_empty - whether a PEB is empty.
		* @ubi: UBI device description object
		* @pnum: the physical eraseblock number to check
		*
		* This function makes sure PEB @pnum is empty, which means it contains only
		* %0xFF data bytes. Returns zero if the PEB is empty, %1 if not, and a
		* negative error code in case of failure.
		*
		* Empty PEBs have the EC header, and do not have the VID header. The caller of
		* this function should have already made sure the PEB does not have the VID
		* header. However, this function re-checks that, because it is possible that
		* the header and data has already been written to the PEB.
		*
		* Let's consider a possible scenario. Suppose there are 2 tasks - A and B.
		* Task A is in 'wear_leveling_worker()'. It is reading VID header of PEB X to
		* find which LEB it corresponds to. PEB X is currently unmapped, and has no
		* VID header. Task B is trying to write to PEB X.
		*
		* Task A: in 'ubi_io_read_vid_hdr()': reads the VID header from PEB X. The
		* read data contain all 0xFF bytes;
		* Task B: writes VID header and some data to PEB X;
		* Task A: assumes PEB X is empty, calls 'paranoid_check_empty()'. And if we
		* do not re-read the VID header, and do not cancel the checking if it
		* is there, we fail.
		*/
		static int paranoid_check_empty(struct ubi_device *ubi, int pnum)
		{
		int err, offs = ubi->vid_hdr_aloffset, len = ubi->vid_hdr_alsize;
		size_t read;
		uint32_t magic;
		const struct ubi_vid_hdr *vid_hdr;

		mutex_lock(&ubi->dbg_buf_mutex);
		err = ubi->mtd->read(ubi->mtd, offs, len, &read, ubi->dbg_peb_buf);
		if (err && err != -EUCLEAN) {
		ubi_err("error %d while reading %d bytes from PEB %d:%d, "
		"read %zd bytes", err, len, pnum, offs, read);
		goto error;
		}

		vid_hdr = ubi->dbg_peb_buf;
		magic = be32_to_cpu(vid_hdr->magic);
		if (magic == UBI_VID_HDR_MAGIC)
		/* The PEB contains VID header, so it is not empty */
		goto out;

		err = check_pattern(ubi->dbg_peb_buf, 0xFF, len);
		if (err == 0) {
		ubi_err("flash region at PEB %d:%d, length %d does not "
		"contain all 0xFF bytes", pnum, offs, len);
		goto fail;
		}

		out:
		mutex_unlock(&ubi->dbg_buf_mutex);
		return 0;

		fail:
		ubi_err("paranoid check failed for PEB %d", pnum);
		ubi_msg("hex dump of the %d-%d region", offs, offs + len);
		print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1,
		ubi->dbg_peb_buf, len, 1);
		err = 1;
		error:
		ubi_dbg_dump_stack();
		mutex_unlock(&ubi->dbg_buf_mutex);
		return err;
		}

		#endif /* CONFIG_MTD_UBI_DEBUG_PARANOID */

drivers/mtd/ubi/scan.c

+14 −0

Original line number	Diff line number	Diff line
		@@ -757,6 +757,8 @@ static int process_eb(struct ubi_device ubi, struct ubi_scan_info si,
		si->is_empty = 0;

		if (!ec_corr) {
		int image_seq;

		/* Make sure UBI version is OK */
		if (ech->version != UBI_VERSION) {
		ubi_err("this UBI version is %d, image version is %d",
		@@ -778,6 +780,18 @@ static int process_eb(struct ubi_device ubi, struct ubi_scan_info si,
		ubi_dbg_dump_ec_hdr(ech);
		return -EINVAL;
		}

		image_seq = be32_to_cpu(ech->ec);
		if (!si->image_seq_set) {
		ubi->image_seq = image_seq;
		si->image_seq_set = 1;
		} else if (ubi->image_seq != image_seq) {
		ubi_err("bad image sequence number %d in PEB %d, "
		"expected %d", image_seq, pnum, ubi->image_seq);
		ubi_dbg_dump_ec_hdr(ech);
		return -EINVAL;
		}

		}

		/* OK, we've done with the EC header, let's look at the VID header */

Admin message