自学教程：C++ ubi_io_read函数代码示例

/** * self_check_peb_ec_hdr - check erase counter header. * @ubi: UBI device description object * @pnum: the physical eraseblock number to check * * This function returns zero if the erase counter header is all right and and * a negative error code if not or if an error occurred. */static int self_check_peb_ec_hdr(const struct ubi_device *ubi, int pnum){	int err;	uint32_t crc, hdr_crc;	struct ubi_ec_hdr *ec_hdr;	if (!ubi_dbg_chk_io(ubi))		return 0;	ec_hdr = kzalloc(ubi->ec_hdr_alsize, GFP_NOFS);	if (!ec_hdr)		return -ENOMEM;	err = ubi_io_read(ubi, ec_hdr, pnum, 0, UBI_EC_HDR_SIZE);	if (err && err != UBI_IO_BITFLIPS && !mtd_is_eccerr(err))		goto exit;	crc = crc32(UBI_CRC32_INIT, ec_hdr, UBI_EC_HDR_SIZE_CRC);	hdr_crc = be32_to_cpu(ec_hdr->hdr_crc);	if (hdr_crc != crc) {		ubi_err(ubi, "bad CRC, calculated %#08x, read %#08x",			crc, hdr_crc);		ubi_err(ubi, "self-check failed for PEB %d", pnum);		ubi_dump_ec_hdr(ec_hdr);		dump_stack();		err = -EINVAL;		goto exit;	}	err = self_check_ec_hdr(ubi, pnum, ec_hdr);exit:	kfree(ec_hdr);	return err;}

/** * paranoid_check_peb_vid_hdr - check volume identifier header. * @ubi: UBI device description object * @pnum: the physical eraseblock number to check * * This function returns zero if the volume identifier header is all right, * and a negative error code if not or if an error occurred. */static int paranoid_check_peb_vid_hdr(const struct ubi_device *ubi, int pnum){	int err;	uint32_t crc, hdr_crc;	struct ubi_vid_hdr *vid_hdr;	void *p;	vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS);	if (!vid_hdr)		return -ENOMEM;	p = (char *)vid_hdr - ubi->vid_hdr_shift;	err = ubi_io_read(ubi, p, pnum, ubi->vid_hdr_aloffset,			  ubi->vid_hdr_alsize);	if (err && err != UBI_IO_BITFLIPS && err != -EBADMSG)		goto exit;	crc = crc32(UBI_CRC32_INIT, vid_hdr, UBI_EC_HDR_SIZE_CRC);	hdr_crc = be32_to_cpu(vid_hdr->hdr_crc);	if (hdr_crc != crc) {		ubi_err("bad VID header CRC at PEB %d, calculated %#08x, "			"read %#08x", pnum, crc, hdr_crc);		ubi_err("paranoid check failed for PEB %d", pnum);		ubi_dbg_dump_vid_hdr(vid_hdr);		ubi_dbg_dump_stack();		err = -EINVAL;		goto exit;	}	err = paranoid_check_vid_hdr(ubi, pnum, vid_hdr);exit:	ubi_free_vid_hdr(ubi, vid_hdr);	return err;}

static int ubi_io_read_vid_hdr(struct ubi_scan_info *ubi, int pnum,			       struct ubi_vid_hdr *vh, int unused){	u32 magic;	int res;	/* No point in rescanning a corrupt block */	if (test_bit(pnum, ubi->corrupt))		return UBI_IO_BAD_HDR;	/*	 * If the block has been scanned already, no need to rescan	 */	if (test_and_set_bit(pnum, ubi->scanned))		return 0;	res = ubi_io_read(ubi, vh, pnum, ubi->vid_offset, sizeof(*vh));	/*	 * Bad block, unrecoverable ECC error, skip the block	 */	if (res) {		ubi_dbg("Skipping bad or unreadable block %d", pnum);		vh->magic = 0;		generic_set_bit(pnum, ubi->corrupt);		return res;	}	/* Magic number available ? */	magic = be32_to_cpu(vh->magic);	if (magic != UBI_VID_HDR_MAGIC) {		generic_set_bit(pnum, ubi->corrupt);		if (magic == 0xffffffff)			return UBI_IO_FF;		ubi_msg("Bad magic in block 0%d %08x", pnum, magic);		return UBI_IO_BAD_HDR;	}	/* Header CRC correct ? */	if (crc32(UBI_CRC32_INIT, vh, UBI_VID_HDR_SIZE_CRC) !=	    be32_to_cpu(vh->hdr_crc)) {		ubi_msg("Bad CRC in block 0%d", pnum);		generic_set_bit(pnum, ubi->corrupt);		return UBI_IO_BAD_HDR;	}	ubi_dbg("RV: pnum: %i sqnum %llu", pnum, be64_to_cpu(vh->sqnum));	return 0;}

/** * ubi_dbg_check_write - make sure write succeeded. * @ubi: UBI device description object * @buf: buffer with data which were written * @pnum: physical eraseblock number the data were written to * @offset: offset within the physical eraseblock the data were written to * @len: how many bytes were written * * This functions reads data which were recently written and compares it with * the original data buffer - the data have to match. Returns zero if the data * match and a negative error code if not or in case of failure. */int ubi_dbg_check_write(struct ubi_device *ubi, const void *buf, int pnum,			int offset, int len){	int err, i;	mutex_lock(&ubi->dbg_buf_mutex);	err = ubi_io_read(ubi, ubi->dbg_peb_buf, pnum, offset, len);	if (err)		goto out_unlock;	for (i = 0; i < len; i++) {		uint8_t c = ((uint8_t *)buf)[i];		uint8_t c1 = ((uint8_t *)ubi->dbg_peb_buf)[i];		int dump_len;		if (c == c1)			continue;		ubi_err("paranoid check failed for PEB %d:%d, len %d",			pnum, offset, len);		ubi_msg("data differ at position %d", i);		dump_len = max_t(int, 128, len - i);		ubi_msg("hex dump of the original buffer from %d to %d",			i, i + dump_len);		print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1,			       buf + i, dump_len, 1);		ubi_msg("hex dump of the read buffer from %d to %d",			i, i + dump_len);		print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1,			       ubi->dbg_peb_buf + i, dump_len, 1);		ubi_dbg_dump_stack();		err = -EINVAL;		goto out_unlock;	}	mutex_unlock(&ubi->dbg_buf_mutex);	return 0;out_unlock:	mutex_unlock(&ubi->dbg_buf_mutex);	return err;}

/** * self_check_peb_vid_hdr - check volume identifier header. * @ubi: UBI device description object * @pnum: the physical eraseblock number to check * * This function returns zero if the volume identifier header is all right, * and a negative error code if not or if an error occurred. */static int self_check_peb_vid_hdr(const struct ubi_device *ubi, int pnum){	int err;	uint32_t crc, hdr_crc;	struct ubi_vid_io_buf *vidb;	struct ubi_vid_hdr *vid_hdr;	void *p;	if (!ubi_dbg_chk_io(ubi))		return 0;	vidb = ubi_alloc_vid_buf(ubi, GFP_NOFS);	if (!vidb)		return -ENOMEM;	vid_hdr = ubi_get_vid_hdr(vidb);	p = vidb->buffer;	err = ubi_io_read(ubi, p, pnum, ubi->vid_hdr_aloffset,			  ubi->vid_hdr_alsize);	if (err && err != UBI_IO_BITFLIPS && !mtd_is_eccerr(err))		goto exit;	crc = crc32(UBI_CRC32_INIT, vid_hdr, UBI_VID_HDR_SIZE_CRC);	hdr_crc = be32_to_cpu(vid_hdr->hdr_crc);	if (hdr_crc != crc) {		ubi_err(ubi, "bad VID header CRC at PEB %d, calculated %#08x, read %#08x",			pnum, crc, hdr_crc);		ubi_err(ubi, "self-check failed for PEB %d", pnum);		ubi_dump_vid_hdr(vid_hdr);		dump_stack();		err = -EINVAL;		goto exit;	}	err = self_check_vid_hdr(ubi, pnum, vid_hdr);exit:	ubi_free_vid_buf(vidb);	return err;}

/** * ubi_io_read_ec_hdr - read and check an erase counter header. * @ubi: UBI device description object * @pnum: physical eraseblock to read from * @ec_hdr: a &struct ubi_ec_hdr object where to store the read erase counter * header * @verbose: be verbose if the header is corrupted or was not found * * This function reads erase counter header from physical eraseblock @pnum and * stores it in @ec_hdr. This function also checks CRC checksum of the read * erase counter header. The following codes may be returned: * * o %0 if the CRC checksum is correct and the header was successfully read; * o %UBI_IO_BITFLIPS if the CRC is correct, but bit-flips were detected *   and corrected by the flash driver; this is harmless but may indicate that *   this eraseblock may become bad soon (but may be not); * o %UBI_IO_BAD_HDR if the erase counter header is corrupted (a CRC error); * o %UBI_IO_BAD_HDR_EBADMSG is the same as %UBI_IO_BAD_HDR, but there also was *   a data integrity error (uncorrectable ECC error in case of NAND); * o %UBI_IO_FF if only 0xFF bytes were read (the PEB is supposedly empty) * o a negative error code in case of failure. */int ubi_io_read_ec_hdr(struct ubi_device *ubi, int pnum,		       struct ubi_ec_hdr *ec_hdr, int verbose){	int err, read_err;	uint32_t crc, magic, hdr_crc;	dbg_io("read EC header from PEB %d", pnum);	ubi_assert(pnum >= 0 && pnum < ubi->peb_count);	read_err = ubi_io_read(ubi, ec_hdr, pnum, 0, UBI_EC_HDR_SIZE);	if (read_err) {		if (read_err != UBI_IO_BITFLIPS && !mtd_is_eccerr(read_err))			return read_err;		/*		 * We read all the data, but either a correctable bit-flip		 * occurred, or MTD reported a data integrity error		 * (uncorrectable ECC error in case of NAND). The former is		 * harmless, the later may mean that the read data is		 * corrupted. But we have a CRC check-sum and we will detect		 * this. If the EC header is still OK, we just report this as		 * there was a bit-flip, to force scrubbing.		 */	}	magic = be32_to_cpu(ec_hdr->magic);	if (magic != UBI_EC_HDR_MAGIC) {		if (mtd_is_eccerr(read_err))			return UBI_IO_BAD_HDR_EBADMSG;		/*		 * The magic field is wrong. Let's check if we have read all		 * 0xFF. If yes, this physical eraseblock is assumed to be		 * empty.		 */		if (ubi_check_pattern(ec_hdr, 0xFF, UBI_EC_HDR_SIZE)) {			/* The physical eraseblock is supposedly empty */			if (verbose)				ubi_warn(ubi, "no EC header found at PEB %d, only 0xFF bytes",					 pnum);			dbg_bld("no EC header found at PEB %d, only 0xFF bytes",				pnum);			if (!read_err)				return UBI_IO_FF;			else				return UBI_IO_FF_BITFLIPS;		}		/*		 * This is not a valid erase counter header, and these are not		 * 0xFF bytes. Report that the header is corrupted.		 */		if (verbose) {			ubi_warn(ubi, "bad magic number at PEB %d: %08x instead of %08x",				 pnum, magic, UBI_EC_HDR_MAGIC);			ubi_dump_ec_hdr(ec_hdr);		}		dbg_bld("bad magic number at PEB %d: %08x instead of %08x",			pnum, magic, UBI_EC_HDR_MAGIC);		return UBI_IO_BAD_HDR;	}	crc = crc32(UBI_CRC32_INIT, ec_hdr, UBI_EC_HDR_SIZE_CRC);	hdr_crc = be32_to_cpu(ec_hdr->hdr_crc);	if (hdr_crc != crc) {		if (verbose) {			ubi_warn(ubi, "bad EC header CRC at PEB %d, calculated %#08x, read %#08x",				 pnum, crc, hdr_crc);			ubi_dump_ec_hdr(ec_hdr);		}		dbg_bld("bad EC header CRC at PEB %d, calculated %#08x, read %#08x",			pnum, crc, hdr_crc);		if (!read_err)			return UBI_IO_BAD_HDR;		else			return UBI_IO_BAD_HDR_EBADMSG;//.........这里部分代码省略.........

/** * torture_peb - test a supposedly bad physical eraseblock. * @ubi: UBI device description object * @pnum: the physical eraseblock number to test * * This function returns %-EIO if the physical eraseblock did not pass the * test, a positive number of erase operations done if the test was * successfully passed, and other negative error codes in case of other errors. */static int torture_peb(struct ubi_device *ubi, int pnum){	int err, i, patt_count;	ubi_msg(ubi, "run torture test for PEB %d", pnum);	patt_count = ARRAY_SIZE(patterns);	ubi_assert(patt_count > 0);	mutex_lock(&ubi->buf_mutex);	for (i = 0; i < patt_count; i++) {		err = do_sync_erase(ubi, pnum);		if (err)			goto out;		/* Make sure the PEB contains only 0xFF bytes */		err = ubi_io_read(ubi, ubi->peb_buf, pnum, 0, ubi->peb_size);		if (err)			goto out;		err = ubi_check_pattern(ubi->peb_buf, 0xFF, ubi->peb_size);		if (err == 0) {			ubi_err(ubi, "erased PEB %d, but a non-0xFF byte found",				pnum);			err = -EIO;			goto out;		}		/* Write a pattern and check it */		memset(ubi->peb_buf, patterns[i], ubi->peb_size);		err = ubi_io_write(ubi, ubi->peb_buf, pnum, 0, ubi->peb_size);		if (err)			goto out;		memset(ubi->peb_buf, ~patterns[i], ubi->peb_size);		err = ubi_io_read(ubi, ubi->peb_buf, pnum, 0, ubi->peb_size);		if (err)			goto out;		err = ubi_check_pattern(ubi->peb_buf, patterns[i],					ubi->peb_size);		if (err == 0) {			ubi_err(ubi, "pattern %x checking failed for PEB %d",				patterns[i], pnum);			err = -EIO;			goto out;		}	}	err = patt_count;	ubi_msg(ubi, "PEB %d passed torture test, do not mark it as bad", pnum);out:	mutex_unlock(&ubi->buf_mutex);	if (err == UBI_IO_BITFLIPS || mtd_is_eccerr(err)) {		/*		 * If a bit-flip or data integrity error was detected, the test		 * has not passed because it happened on a freshly erased		 * physical eraseblock which means something is wrong with it.		 */		ubi_err(ubi, "read problems on freshly erased PEB %d, must be bad",			pnum);		err = -EIO;	}	return err;}

/** * ubi_io_read_vid_hdr - read and check a volume identifier header. * @ubi: UBI device description object * @pnum: physical eraseblock number to read from * @vid_hdr: &struct ubi_vid_hdr object where to store the read volume * identifier header * @verbose: be verbose if the header is corrupted or wasn't found * * This function reads the volume identifier header from physical eraseblock * @pnum and stores it in @vid_hdr. It also checks CRC checksum of the read * volume identifier header. The error codes are the same as in * 'ubi_io_read_ec_hdr()'. * * Note, the implementation of this function is also very similar to * 'ubi_io_read_ec_hdr()', so refer commentaries in 'ubi_io_read_ec_hdr()'. */int ubi_io_read_vid_hdr(struct ubi_device *ubi, int pnum,			struct ubi_vid_hdr *vid_hdr, int verbose){	int err, read_err;	uint32_t crc, magic, hdr_crc;	void *p;	dbg_io("read VID header from PEB %d", pnum);	ubi_assert(pnum >= 0 &&  pnum < ubi->peb_count);	p = (char *)vid_hdr - ubi->vid_hdr_shift;	read_err = ubi_io_read(ubi, p, pnum, ubi->vid_hdr_aloffset,			  ubi->vid_hdr_alsize);	if (read_err && read_err != UBI_IO_BITFLIPS && !mtd_is_eccerr(read_err))		return read_err;	magic = be32_to_cpu(vid_hdr->magic);	if (magic != UBI_VID_HDR_MAGIC) {		if (mtd_is_eccerr(read_err))			return UBI_IO_BAD_HDR_EBADMSG;		if (ubi_check_pattern(vid_hdr, 0xFF, UBI_VID_HDR_SIZE)) {			if (verbose)				ubi_warn(ubi, "no VID header found at PEB %d, only 0xFF bytes",					 pnum);			dbg_bld("no VID header found at PEB %d, only 0xFF bytes",				pnum);			if (!read_err)				return UBI_IO_FF;			else				return UBI_IO_FF_BITFLIPS;		}		if (verbose) {			ubi_warn(ubi, "bad magic number at PEB %d: %08x instead of %08x",				 pnum, magic, UBI_VID_HDR_MAGIC);			ubi_dump_vid_hdr(vid_hdr);		}		dbg_bld("bad magic number at PEB %d: %08x instead of %08x",			pnum, magic, UBI_VID_HDR_MAGIC);		return UBI_IO_BAD_HDR;	}	crc = crc32(UBI_CRC32_INIT, vid_hdr, UBI_VID_HDR_SIZE_CRC);	hdr_crc = be32_to_cpu(vid_hdr->hdr_crc);	if (hdr_crc != crc) {		if (verbose) {			ubi_warn(ubi, "bad CRC at PEB %d, calculated %#08x, read %#08x",				 pnum, crc, hdr_crc);			ubi_dump_vid_hdr(vid_hdr);		}		dbg_bld("bad CRC at PEB %d, calculated %#08x, read %#08x",			pnum, crc, hdr_crc);		if (!read_err)			return UBI_IO_BAD_HDR;		else			return UBI_IO_BAD_HDR_EBADMSG;	}	err = validate_vid_hdr(ubi, vid_hdr);	if (err) {		ubi_err(ubi, "validation failed for PEB %d", pnum);		return -EINVAL;	}	return read_err ? UBI_IO_BITFLIPS : 0;}

/** * ubi_io_read_vid_hdr - read and check a volume identifier header. * @ubi: UBI device description object * @pnum: physical eraseblock number to read from * @vid_hdr: &struct ubi_vid_hdr object where to store the read volume * identifier header * @verbose: be verbose if the header is corrupted or wasn't found * * This function reads the volume identifier header from physical eraseblock * @pnum and stores it in @vid_hdr. It also checks CRC checksum of the read * volume identifier header. The following codes may be returned: * * o %0 if the CRC checksum is correct and the header was successfully read; * o %UBI_IO_BITFLIPS if the CRC is correct, but bit-flips were detected *   and corrected by the flash driver; this is harmless but may indicate that *   this eraseblock may become bad soon; * o %UBI_IO_BAD_VID_HDR if the volume identifier header is corrupted (a CRC *   error detected); * o %UBI_IO_PEB_FREE if the physical eraseblock is free (i.e., there is no VID *   header there); * o a negative error code in case of failure. */int ubi_io_read_vid_hdr(struct ubi_device *ubi, int pnum,			struct ubi_vid_hdr *vid_hdr, int verbose){	int err, read_err = 0;	uint32_t crc, magic, hdr_crc;	void *p;	dbg_io("read VID header from PEB %d", pnum);	ubi_assert(pnum >= 0 &&  pnum < ubi->peb_count);	p = (char *)vid_hdr - ubi->vid_hdr_shift;	err = ubi_io_read(ubi, p, pnum, ubi->vid_hdr_aloffset,			  ubi->vid_hdr_alsize);	if (err) {		if (err != UBI_IO_BITFLIPS && err != -EBADMSG)			return err;		/*		 * We read all the data, but either a correctable bit-flip		 * occurred, or MTD reported about some data integrity error,		 * like an ECC error in case of NAND. The former is harmless,		 * the later may mean the read data is corrupted. But we have a		 * CRC check-sum and we will identify this. If the VID header is		 * still OK, we just report this as there was a bit-flip.		 */		read_err = err;	}	magic = be32_to_cpu(vid_hdr->magic);	if (magic != UBI_VID_HDR_MAGIC) {		/*		 * If we have read all 0xFF bytes, the VID header probably does		 * not exist and the physical eraseblock is assumed to be free.		 *		 * But if there was a read error, we do not test the data for		 * 0xFFs. Even if it does contain all 0xFFs, this error		 * indicates that something is still wrong with this physical		 * eraseblock and it cannot be regarded as free.		 */		if (read_err != -EBADMSG &&		    check_pattern(vid_hdr, 0xFF, UBI_VID_HDR_SIZE)) {			/* The physical eraseblock is supposedly free */			if (verbose)				ubi_warn("no VID header found at PEB %d, "					 "only 0xFF bytes", pnum);			else if (UBI_IO_DEBUG)				dbg_msg("no VID header found at PEB %d, "					"only 0xFF bytes", pnum);			return UBI_IO_PEB_FREE;		}		/*		 * This is not a valid VID header, and these are not 0xFF		 * bytes. Report that the header is corrupted.		 */		if (verbose) {			ubi_warn("bad magic number at PEB %d: %08x instead of "				 "%08x", pnum, magic, UBI_VID_HDR_MAGIC);			ubi_dbg_dump_vid_hdr(vid_hdr);		} else if (UBI_IO_DEBUG)			dbg_msg("bad magic number at PEB %d: %08x instead of "				"%08x", pnum, magic, UBI_VID_HDR_MAGIC);		return UBI_IO_BAD_VID_HDR;	}	crc = crc32(UBI_CRC32_INIT, vid_hdr, UBI_VID_HDR_SIZE_CRC);	hdr_crc = be32_to_cpu(vid_hdr->hdr_crc);	if (hdr_crc != crc) {		if (verbose) {			ubi_warn("bad CRC at PEB %d, calculated %#08x, "				 "read %#08x", pnum, crc, hdr_crc);			ubi_dbg_dump_vid_hdr(vid_hdr);		} else if (UBI_IO_DEBUG)			dbg_msg("bad CRC at PEB %d, calculated %#08x, "				"read %#08x", pnum, crc, hdr_crc);		return UBI_IO_BAD_VID_HDR;	}//.........这里部分代码省略.........

/** * ubi_io_read_ec_hdr - read and check an erase counter header. * @ubi: UBI device description object * @pnum: physical eraseblock to read from * @ec_hdr: a &struct ubi_ec_hdr object where to store the read erase counter * header * @verbose: be verbose if the header is corrupted or was not found * * This function reads erase counter header from physical eraseblock @pnum and * stores it in @ec_hdr. This function also checks CRC checksum of the read * erase counter header. The following codes may be returned: * * o %0 if the CRC checksum is correct and the header was successfully read; * o %UBI_IO_BITFLIPS if the CRC is correct, but bit-flips were detected *   and corrected by the flash driver; this is harmless but may indicate that *   this eraseblock may become bad soon (but may be not); * o %UBI_IO_BAD_EC_HDR if the erase counter header is corrupted (a CRC error); * o %UBI_IO_PEB_EMPTY if the physical eraseblock is empty; * o a negative error code in case of failure. */int ubi_io_read_ec_hdr(struct ubi_device *ubi, int pnum,		       struct ubi_ec_hdr *ec_hdr, int verbose){	int err, read_err = 0;	uint32_t crc, magic, hdr_crc;	dbg_io("read EC header from PEB %d", pnum);	ubi_assert(pnum >= 0 && pnum < ubi->peb_count);	err = ubi_io_read(ubi, ec_hdr, pnum, 0, UBI_EC_HDR_SIZE);	if (err) {		if (err != UBI_IO_BITFLIPS && err != -EBADMSG)			return err;		/*		 * We read all the data, but either a correctable bit-flip		 * occurred, or MTD reported about some data integrity error,		 * like an ECC error in case of NAND. The former is harmless,		 * the later may mean that the read data is corrupted. But we		 * have a CRC check-sum and we will detect this. If the EC		 * header is still OK, we just report this as there was a		 * bit-flip.		 */		read_err = err;	}	magic = be32_to_cpu(ec_hdr->magic);	if (magic != UBI_EC_HDR_MAGIC) {		/*		 * The magic field is wrong. Let's check if we have read all		 * 0xFF. If yes, this physical eraseblock is assumed to be		 * empty.		 *		 * But if there was a read error, we do not test it for all		 * 0xFFs. Even if it does contain all 0xFFs, this error		 * indicates that something is still wrong with this physical		 * eraseblock and we anyway cannot treat it as empty.		 */		if (read_err != -EBADMSG &&		    check_pattern(ec_hdr, 0xFF, UBI_EC_HDR_SIZE)) {			/* The physical eraseblock is supposedly empty */			if (verbose)				ubi_warn("no EC header found at PEB %d, "					 "only 0xFF bytes", pnum);			else if (UBI_IO_DEBUG)				dbg_msg("no EC header found at PEB %d, "					"only 0xFF bytes", pnum);			return UBI_IO_PEB_EMPTY;		}		/*		 * This is not a valid erase counter header, and these are not		 * 0xFF bytes. Report that the header is corrupted.		 */		if (verbose) {			ubi_warn("bad magic number at PEB %d: %08x instead of "				 "%08x", pnum, magic, UBI_EC_HDR_MAGIC);			ubi_dbg_dump_ec_hdr(ec_hdr);		} else if (UBI_IO_DEBUG)			dbg_msg("bad magic number at PEB %d: %08x instead of "				"%08x", pnum, magic, UBI_EC_HDR_MAGIC);		return UBI_IO_BAD_EC_HDR;	}	crc = crc32(UBI_CRC32_INIT, ec_hdr, UBI_EC_HDR_SIZE_CRC);	hdr_crc = be32_to_cpu(ec_hdr->hdr_crc);	if (hdr_crc != crc) {		if (verbose) {			ubi_warn("bad EC header CRC at PEB %d, calculated "				 "%#08x, read %#08x", pnum, crc, hdr_crc);			ubi_dbg_dump_ec_hdr(ec_hdr);		} else if (UBI_IO_DEBUG)			dbg_msg("bad EC header CRC at PEB %d, calculated "				"%#08x, read %#08x", pnum, crc, hdr_crc);		return UBI_IO_BAD_EC_HDR;	}	/* And of course validate what has just been read from the media */	err = validate_ec_hdr(ubi, ec_hdr);//.........这里部分代码省略.........

/* * Load a logical block of a volume into memory */static int ubi_load_block(struct ubi_scan_info *ubi, uint8_t *laddr,			  struct ubi_vol_info *vi, u32 vol_id, u32 lnum,			  u32 last){	struct ubi_vid_hdr *vh, *vrepl;	u32 pnum, crc, dlen;retry:	/*	 * If this is a fastmap run, we try to rescan full, otherwise	 * we simply give up.	 */	if (!test_bit(lnum, vi->found)) {		ubi_warn("LEB %d of %d is missing", lnum, last);		return -EINVAL;	}	pnum = vi->lebs_to_pebs[lnum];	ubi_dbg("Load vol %u LEB %u PEB %u", vol_id, lnum, pnum);	if (ubi_io_is_bad(ubi, pnum)) {		ubi_warn("Corrupted mapping block %d PB %d/n", lnum, pnum);		return -EINVAL;	}	if (test_bit(pnum, ubi->corrupt))		goto find_other;	/*	 * Lets try to read that block	 */	vh = ubi->blockinfo + pnum;	if (!test_bit(pnum, ubi->scanned)) {		ubi_warn("Vol: %u LEB %u PEB %u not yet scanned", vol_id,			 lnum, pnum);		if (ubi_rescan_fm_vid_hdr(ubi, vh, pnum, vol_id, lnum))			goto find_other;	}	/*	 * Check, if the total number of blocks is correct	 */	if (be32_to_cpu(vh->used_ebs) != last) {		ubi_dbg("Block count missmatch.");		ubi_dbg("vh->used_ebs: %d nrblocks: %d",			be32_to_cpu(vh->used_ebs), last);		generic_set_bit(pnum, ubi->corrupt);		goto find_other;	}	/*	 * Get the data length of this block.	 */	dlen = be32_to_cpu(vh->data_size);	/*	 * Read the data into RAM. We ignore the return value	 * here as the only thing which might go wrong are	 * bitflips. Try nevertheless.	 */	ubi_io_read(ubi, laddr, pnum, ubi->leb_start, dlen);	/* Calculate CRC over the data */	crc = crc32(UBI_CRC32_INIT, laddr, dlen);	if (crc != be32_to_cpu(vh->data_crc)) {		ubi_warn("Vol: %u LEB %u PEB %u data CRC failure", vol_id,			 lnum, pnum);		generic_set_bit(pnum, ubi->corrupt);		goto find_other;	}	/* We are good. Return the data length we read */	return dlen;find_other:	ubi_dbg("Find replacement for LEB %u PEB %u", lnum, pnum);	generic_clear_bit(lnum, vi->found);	vrepl = NULL;	for (pnum = 0; pnum < ubi->peb_count; pnum++) {		struct ubi_vid_hdr *tmp = ubi->blockinfo + pnum;		u32 t_vol_id = be32_to_cpu(tmp->vol_id);		u32 t_lnum = be32_to_cpu(tmp->lnum);		if (test_bit(pnum, ubi->corrupt))			continue;		if (t_vol_id != vol_id || t_lnum != lnum)			continue;		if (!test_bit(pnum, ubi->scanned)) {			ubi_warn("Vol: %u LEB %u PEB %u not yet scanned",				 vol_id, lnum, pnum);			if (ubi_rescan_fm_vid_hdr(ubi, tmp, pnum, vol_id, lnum))//.........这里部分代码省略.........

static int ubi_scan_fastmap(struct ubi_scan_info *ubi,			    struct ubi_attach_info *ai,			    int fm_anchor){	struct ubi_fm_sb *fmsb, *fmsb2;	struct ubi_vid_hdr *vh;	struct ubi_fastmap_layout *fm;	int i, used_blocks, pnum, ret = 0;	size_t fm_size;	__be32 crc, tmp_crc;	unsigned long long sqnum = 0;	fmsb = &ubi->fm_sb;	fm = &ubi->fm_layout;	ret = ubi_io_read(ubi, fmsb, fm_anchor, ubi->leb_start, sizeof(*fmsb));	if (ret && ret != UBI_IO_BITFLIPS)		goto free_fm_sb;	else if (ret == UBI_IO_BITFLIPS)		fm->to_be_tortured[0] = 1;	if (be32_to_cpu(fmsb->magic) != UBI_FM_SB_MAGIC) {		ubi_err("bad super block magic: 0x%x, expected: 0x%x",			be32_to_cpu(fmsb->magic), UBI_FM_SB_MAGIC);		ret = UBI_BAD_FASTMAP;		goto free_fm_sb;	}	if (fmsb->version != UBI_FM_FMT_VERSION) {		ubi_err("bad fastmap version: %i, expected: %i",			fmsb->version, UBI_FM_FMT_VERSION);		ret = UBI_BAD_FASTMAP;		goto free_fm_sb;	}	used_blocks = be32_to_cpu(fmsb->used_blocks);	if (used_blocks > UBI_FM_MAX_BLOCKS || used_blocks < 1) {		ubi_err("number of fastmap blocks is invalid: %i", used_blocks);		ret = UBI_BAD_FASTMAP;		goto free_fm_sb;	}	fm_size = ubi->leb_size * used_blocks;	if (fm_size != ubi->fm_size) {		ubi_err("bad fastmap size: %zi, expected: %zi", fm_size,			ubi->fm_size);		ret = UBI_BAD_FASTMAP;		goto free_fm_sb;	}	vh = &ubi->fm_vh;	for (i = 0; i < used_blocks; i++) {		pnum = be32_to_cpu(fmsb->block_loc[i]);		if (ubi_io_is_bad(ubi, pnum)) {			ret = UBI_BAD_FASTMAP;			goto free_hdr;		}#ifdef LATER		int image_seq;		ret = ubi_io_read_ec_hdr(ubi, pnum, ech, 0);		if (ret && ret != UBI_IO_BITFLIPS) {			ubi_err("unable to read fastmap block# %i EC (PEB: %i)",				i, pnum);			if (ret > 0)				ret = UBI_BAD_FASTMAP;			goto free_hdr;		} else if (ret == UBI_IO_BITFLIPS)			fm->to_be_tortured[i] = 1;		image_seq = be32_to_cpu(ech->image_seq);		if (!ubi->image_seq)			ubi->image_seq = image_seq;		/*		 * Older UBI implementations have image_seq set to zero, so		 * we shouldn't fail if image_seq == 0.		 */		if (image_seq && (image_seq != ubi->image_seq)) {			ubi_err("wrong image seq:%d instead of %d",				be32_to_cpu(ech->image_seq), ubi->image_seq);			ret = UBI_BAD_FASTMAP;			goto free_hdr;		}#endif		ret = ubi_io_read_vid_hdr(ubi, pnum, vh, 0);		if (ret && ret != UBI_IO_BITFLIPS) {			ubi_err("unable to read fastmap block# %i (PEB: %i)",				i, pnum);			goto free_hdr;		}		/*		 * Mainline code rescans the anchor header. We've done		 * that already so we merily copy it over.		 */		if (pnum == fm_anchor)			memcpy(vh, ubi->blockinfo + pnum, sizeof(*fm));//.........这里部分代码省略.........