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

static int ubi_volume_continue_write(char *volume, void *buf, size_t size){	int err = 1;	struct ubi_volume *vol;	vol = ubi_find_volume(volume);	if (vol == NULL)		return ENODEV;	err = ubi_more_update_data(ubi, vol, buf, size);	if (err < 0) {		printf("Couldnt or partially wrote data/n");		return -err;	}	if (err) {		size = err;		err = ubi_check_volume(ubi, vol->vol_id);		if (err < 0)			return -err;		if (err) {			ubi_warn(ubi, "volume %d on UBI device %d is corrupt",				 vol->vol_id, ubi->ubi_num);			vol->corrupted = 1;		}		vol->checked = 1;		ubi_gluebi_updated(vol);	}	return 0;}

/* * Load a volume into RAM */static int ipl_load(struct ubi_scan_info *ubi, const u32 vol_id, uint8_t *laddr){	struct ubi_vol_info *vi;	u32 lnum, last, len;	if (vol_id >= UBI_SPL_VOL_IDS)		return -EINVAL;	len = 0;	vi = ubi->volinfo + vol_id;	last = vi->last_block + 1;	/* Read the blocks to RAM, check CRC */	for (lnum = 0 ; lnum < last; lnum++) {		int res = ubi_load_block(ubi, laddr, vi, vol_id, lnum, last);		if (res < 0) {			ubi_warn("Failed to load volume %u", vol_id);			return res;		}		/* res is the data length of the read block */		laddr += res;		len += res;	}	return len;}

static int ubi_volume_write(char *volume, void *buf, size_t size){	int i = 0, err = -1;	int rsvd_bytes = 0;	int found = 0;	struct ubi_volume *vol;	for (i = 0; i < ubi->vtbl_slots; i++) {		vol = ubi->volumes[i];		if (vol && !strcmp(vol->name, volume)) {			printf("Volume /"%s/" found at volume id %d/n", volume, i);			found = 1;			break;		}	}	if (!found) {		printf("%s volume not found/n", volume);		return 1;	}	rsvd_bytes = vol->reserved_pebs * (ubi->leb_size - vol->data_pad);	if (size < 0 || size > rsvd_bytes) {		printf("rsvd_bytes=%d vol->reserved_pebs=%d ubi->leb_size=%d/n",		     rsvd_bytes, vol->reserved_pebs, ubi->leb_size);		printf("vol->data_pad=%d/n", vol->data_pad);		printf("Size > volume size !!/n");		return 1;	}	err = ubi_start_update(ubi, vol, size);	if (err < 0) {		printf("Cannot start volume update/n");		return err;	}	err = ubi_more_update_data(ubi, vol, buf, size);	if (err < 0) {		printf("Couldnt or partially wrote data /n");		return err;	}	if (err) {		size = err;		err = ubi_check_volume(ubi, vol->vol_id);		if ( err < 0 )			return err;		if (err) {			ubi_warn("volume %d on UBI device %d is corrupted",					vol->vol_id, ubi->ubi_num);			vol->corrupted = 1;		}		vol->checked = 1;		ubi_gluebi_updated(vol);	}	return 0;}

static int ubi_volume_write(char *volume, void *buf, size_t size){	int err = 1;	int rsvd_bytes = 0;	struct ubi_volume *vol;	vol = ubi_find_volume(volume);	if (vol == NULL)		return ENODEV;	rsvd_bytes = vol->reserved_pebs * (ubi->leb_size - vol->data_pad);	if (size < 0 || size > rsvd_bytes) {		printf("size > volume size! Aborting!/n");		return EINVAL;	}	if (!strncmp(vol->name, "Factory", 7) && (!size || size != rsvd_bytes)) {		printf("Partial write to volume %s is inhibited/n", vol->name);		return EROFS;	}	err = ubi_start_update(ubi, vol, size);	if (err < 0) {		printf("Cannot start volume update/n");		return -err;	}	err = ubi_more_update_data(ubi, vol, buf, size);	if (err < 0) {		printf("Couldnt or partially wrote data/n");		return -err;	}	if (err) {		size = err;		err = ubi_check_volume(ubi, vol->vol_id);		if (err < 0)			return -err;		if (err) {			ubi_warn("volume %d on UBI device %d is corrupted",					vol->vol_id, ubi->ubi_num);			vol->corrupted = 1;		}		vol->checked = 1;		ubi_gluebi_updated(vol);	}	printf("/n0x%x bytes written to volume %s/n", size, volume);	return 0;}

static int ubi_volume_cdev_close(struct cdev *cdev){	struct ubi_volume_cdev_priv *priv = cdev->priv;	struct ubi_volume *vol = priv->vol;	struct ubi_device *ubi = priv->ubi;	int err;	if (priv->written) {		int remaining = vol->usable_leb_size -				(priv->written % vol->usable_leb_size);		if (remaining && vol->vol_type == UBI_DYNAMIC_VOLUME) {			void *buf = kmalloc(remaining, GFP_KERNEL);			if (!buf)				return -ENOMEM;			memset(buf, 0xff, remaining);			err = ubi_more_update_data(ubi, vol, buf, remaining);			kfree(buf);			if (err < 0) {				ubi_err(ubi, "Couldnt or partially wrote data");				return err;			}		}		if (vol->vol_type == UBI_STATIC_VOLUME)			cdev->size = priv->written;		err = ubi_finish_update(ubi, vol);		if (err)			return err;		err = ubi_check_volume(ubi, vol->vol_id);		if (err < 0) {			ubi_err(ubi, "ubi volume check failed: %s", strerror(err));			return err;		}		if (err) {			ubi_warn(ubi, "volume %d on UBI device %d is corrupted",					vol->vol_id, ubi->ubi_num);			vol->corrupted = 1;		}		vol->checked = 1;		ubi_volume_notify(ubi, vol, UBI_VOLUME_UPDATED);	}	return 0;}

int ubispl_load_volumes(struct ubispl_info *info, struct ubispl_load *lvols,			int nrvols){	struct ubi_scan_info *ubi = info->ubi;	int res, i, fastmap = info->fastmap;	u32 fsize;retry:	/*	 * We do a partial initializiation of @ubi. Cleaning fm_buf is	 * not necessary.	 */	memset(ubi, 0, offsetof(struct ubi_scan_info, fm_buf));	ubi->read = info->read;	/* Precalculate the offsets */	ubi->vid_offset = info->vid_offset;	ubi->leb_start = info->leb_start;	ubi->leb_size = info->peb_size - ubi->leb_start;	ubi->peb_count = info->peb_count;	ubi->peb_offset = info->peb_offset;	fsize = info->peb_size * info->peb_count;	ubi->fsize_mb = fsize >> 20;	/* Fastmap init */	ubi->fm_size = ubi_calc_fm_size(ubi);	ubi->fm_enabled = fastmap;	for (i = 0; i < nrvols; i++) {		struct ubispl_load *lv = lvols + i;		generic_set_bit(lv->vol_id, ubi->toload);	}	ipl_scan(ubi);	for (i = 0; i < nrvols; i++) {		struct ubispl_load *lv = lvols + i;		ubi_msg("Loading VolId #%d", lv->vol_id);		res = ipl_load(ubi, lv->vol_id, lv->load_addr);		if (res < 0) {			if (fastmap) {				fastmap = 0;				goto retry;			}			ubi_warn("Failed");			return res;		}	}	return 0;}

static ssize_t vol_cdev_write(struct file *file, const char __user *buf,			      size_t count, loff_t *offp){	int err = 0;	struct ubi_volume_desc *desc = file->private_data;	struct ubi_volume *vol = desc->vol;	struct ubi_device *ubi = vol->ubi;	if (!vol->updating && !vol->changing_leb)		return vol_cdev_direct_write(file, buf, count, offp);	if (vol->updating)		err = ubi_more_update_data(ubi, vol, buf, count);	else		err = ubi_more_leb_change_data(ubi, vol, buf, count);	if (err < 0) {		ubi_err("cannot accept more %zd bytes of data, error %d",			count, err);		return err;	}	if (err) {		/*		 * The operation is finished, @err contains number of actually		 * written bytes.		 */		count = err;		if (vol->changing_leb) {			revoke_exclusive(desc, UBI_READWRITE);			return count;		}		err = ubi_check_volume(ubi, vol->vol_id);		if (err < 0)			return err;		if (err) {			ubi_warn("volume %d on UBI device %d is corrupted",				 vol->vol_id, ubi->ubi_num);			vol->corrupted = 1;		}		vol->checked = 1;		ubi_gluebi_updated(vol);		revoke_exclusive(desc, UBI_READWRITE);	}	return count;}

static int vol_cdev_release(struct inode *inode, struct file *file){	struct ubi_volume_desc *desc = file->private_data;	struct ubi_volume *vol = desc->vol;	dbg_msg("release volume %d, mode %d", vol->vol_id, desc->mode);	if (vol->updating) {		ubi_warn("update of volume %d not finished, volume is damaged",			 vol->vol_id);		vol->updating = 0;		kfree(vol->upd_buf);	}	ubi_close_volume(desc);	return 0;}

/** * autoresize - re-size the volume which has the "auto-resize" flag set. * @ubi: UBI device description object * @vol_id: ID of the volume to re-size * * This function re-sizes the volume marked by the %UBI_VTBL_AUTORESIZE_FLG in * the volume table to the largest possible size. See comments in ubi-header.h * for more description of the flag. Returns zero in case of success and a * negative error code in case of failure. */static int autoresize(struct ubi_device *ubi, int vol_id){	struct ubi_volume_desc desc;	struct ubi_volume *vol = ubi->volumes[vol_id];	int err, old_reserved_pebs = vol->reserved_pebs;	if (ubi->ro_mode) {		ubi_warn("skip auto-resize because of R/O mode");		return 0;	}	/*	 * Clear the auto-resize flag in the volume in-memory copy of the	 * volume table, and 'ubi_resize_volume()' will propagate this change	 * to the flash.	 */	ubi->vtbl[vol_id].flags &= ~UBI_VTBL_AUTORESIZE_FLG;	if (ubi->avail_pebs == 0) {		struct ubi_vtbl_record vtbl_rec;		/*		 * No available PEBs to re-size the volume, clear the flag on		 * flash and exit.		 */		vtbl_rec = ubi->vtbl[vol_id];		err = ubi_change_vtbl_record(ubi, vol_id, &vtbl_rec);		if (err)			ubi_err("cannot clean auto-resize flag for volume %d",				vol_id);	} else {		desc.vol = vol;		err = ubi_resize_volume(&desc,					old_reserved_pebs + ubi->avail_pebs);		if (err)			ubi_err("cannot auto-resize volume %d", vol_id);	}	if (err)		return err;	ubi_msg("volume %d (/"%s/") re-sized from %d to %d LEBs", vol_id,		vol->name, old_reserved_pebs, vol->reserved_pebs);	return 0;}

static ssize_t vol_cdev_write(struct file *file, const char __user *buf,			      size_t count, loff_t *offp){	int err = 0;	struct ubi_volume_desc *desc = file->private_data;	struct ubi_volume *vol = desc->vol;	struct ubi_device *ubi = vol->ubi;	if (!vol->updating)		return vol_cdev_direct_write(file, buf, count, offp);	err = ubi_more_update_data(ubi, vol->vol_id, buf, count);	if (err < 0) {		ubi_err("cannot write %zd bytes of update data", count);		return err;	}	if (err) {		/*		 * Update is finished, @err contains number of actually written		 * bytes now.		 */		count = err;		err = ubi_check_volume(ubi, vol->vol_id);		if (err < 0)			return err;		if (err) {			ubi_warn("volume %d on UBI device %d is corrupted",				 vol->vol_id, ubi->ubi_num);			vol->corrupted = 1;		}		vol->checked = 1;		ubi_gluebi_updated(vol);		revoke_exclusive(desc, UBI_READWRITE);	}	*offp += count;	return count;}

/** * ubi_leb_read - read data. * @desc: volume descriptor * @lnum: logical eraseblock number to read from * @buf: buffer where to store the read data * @offset: offset within the logical eraseblock to read from * @len: how many bytes to read * @check: whether UBI has to check the read data's CRC or not. * * This function reads data from offset @offset of logical eraseblock @lnum and * stores the data at @buf. When reading from static volumes, @check specifies * whether the data has to be checked or not. If yes, the whole logical * eraseblock will be read and its CRC checksum will be checked (i.e., the CRC * checksum is per-eraseblock). So checking may substantially slow down the * read speed. The @check argument is ignored for dynamic volumes. * * In case of success, this function returns zero. In case of failure, this * function returns a negative error code. * * %-EBADMSG error code is returned: * o for both static and dynamic volumes if MTD driver has detected a data *   integrity problem (unrecoverable ECC checksum mismatch in case of NAND); * o for static volumes in case of data CRC mismatch. * * If the volume is damaged because of an interrupted update this function just * returns immediately with %-EBADF error code. */int ubi_leb_read(struct ubi_volume_desc *desc, int lnum, char *buf, int offset,		 int len, int check){	struct ubi_volume *vol = desc->vol;	struct ubi_device *ubi = vol->ubi;	int err, vol_id = vol->vol_id;	dbg_gen("read %d bytes from LEB %d:%d:%d", len, vol_id, lnum, offset);	if (vol_id < 0 || vol_id >= ubi->vtbl_slots || lnum < 0 ||	    lnum >= vol->used_ebs || offset < 0 || len < 0 ||	    offset + len > vol->usable_leb_size)		return -EINVAL;	if (vol->vol_type == UBI_STATIC_VOLUME) {		if (vol->used_ebs == 0)			/* Empty static UBI volume */			return 0;		if (lnum == vol->used_ebs - 1 &&		    offset + len > vol->last_eb_bytes)			return -EINVAL;	}	if (vol->upd_marker)		return -EBADF;	if (len == 0)		return 0;	err = ubi_eba_read_leb(ubi, vol, lnum, buf, offset, len, check);	if (err && err == -EBADMSG && vol->vol_type == UBI_STATIC_VOLUME) {		ubi_warn("mark volume %d as corrupted", vol_id);		vol->corrupted = 1;	}	return err;}

static int vol_cdev_release(struct inode *inode, struct file *file){	struct ubi_volume_desc *desc = file->private_data;	struct ubi_volume *vol = desc->vol;	dbg_msg("release volume %d, mode %d", vol->vol_id, desc->mode);	if (vol->updating) {		ubi_warn("update of volume %d not finished, volume is damaged",			 vol->vol_id);		ubi_assert(!vol->changing_leb);		vol->updating = 0;		vfree(vol->upd_buf);	} else if (vol->changing_leb) {		dbg_msg("only %lld of %lld bytes received for atomic LEB change"			" for volume %d:%d, cancel", vol->upd_received,			vol->upd_bytes, vol->ubi->ubi_num, vol->vol_id);		vol->changing_leb = 0;		vfree(vol->upd_buf);	}	ubi_close_volume(desc);	return 0;}

/** * ubi_leb_read_sg - read data into a scatter gather list. * @desc: volume descriptor * @lnum: logical eraseblock number to read from * @buf: buffer where to store the read data * @offset: offset within the logical eraseblock to read from * @len: how many bytes to read * @check: whether UBI has to check the read data's CRC or not. * * This function works exactly like ubi_leb_read_sg(). But instead of * storing the read data into a buffer it writes to an UBI scatter gather * list. */int ubi_leb_read_sg(struct ubi_volume_desc *desc, int lnum, struct ubi_sgl *sgl,		    int offset, int len, int check){	struct ubi_volume *vol = desc->vol;	struct ubi_device *ubi = vol->ubi;	int err, vol_id = vol->vol_id;	dbg_gen("read %d bytes from LEB %d:%d:%d", len, vol_id, lnum, offset);	err = leb_read_sanity_check(desc, lnum, offset, len);	if (err < 0)		return err;	if (len == 0)		return 0;	err = ubi_eba_read_leb_sg(ubi, vol, sgl, lnum, offset, len, check);	if (err && mtd_is_eccerr(err) && vol->vol_type == UBI_STATIC_VOLUME) {		ubi_warn(ubi, "mark volume %d as corrupted", vol_id);		vol->corrupted = 1;	}	return err;}

/** * ubi_eba_read_leb - read data. * @ubi: UBI device description object * @vol: volume description object * @lnum: logical eraseblock number * @buf: buffer to store the read data * @offset: offset from where to read * @len: how many bytes to read * @check: data CRC check flag * * If the logical eraseblock @lnum is unmapped, @buf is filled with 0xFF * bytes. The @check flag only makes sense for static volumes and forces * eraseblock data CRC checking. * * In case of success this function returns zero. In case of a static volume, * if data CRC mismatches - %-EBADMSG is returned. %-EBADMSG may also be * returned for any volume type if an ECC error was detected by the MTD device * driver. Other negative error cored may be returned in case of other errors. */int ubi_eba_read_leb(struct ubi_device *ubi, struct ubi_volume *vol, int lnum,		     void *buf, int offset, int len, int check){	int err, pnum, scrub = 0, vol_id = vol->vol_id;	struct ubi_vid_hdr *vid_hdr;	uint32_t uninitialized_var(crc);	err = leb_read_lock(ubi, vol_id, lnum);	if (err)		return err;	pnum = vol->eba_tbl[lnum];	if (pnum < 0) {		/*		 * The logical eraseblock is not mapped, fill the whole buffer		 * with 0xFF bytes. The exception is static volumes for which		 * it is an error to read unmapped logical eraseblocks.		 */		dbg_eba("read %d bytes from offset %d of LEB %d:%d (unmapped)",			len, offset, vol_id, lnum);		leb_read_unlock(ubi, vol_id, lnum);		ubi_assert(vol->vol_type != UBI_STATIC_VOLUME);		memset(buf, 0xFF, len);		return 0;	}	dbg_eba("read %d bytes from offset %d of LEB %d:%d, PEB %d",		len, offset, vol_id, lnum, pnum);	if (vol->vol_type == UBI_DYNAMIC_VOLUME)		check = 0;retry:	if (check) {		vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS);		if (!vid_hdr) {			err = -ENOMEM;			goto out_unlock;		}		err = ubi_io_read_vid_hdr(ubi, pnum, vid_hdr, 1);		if (err && err != UBI_IO_BITFLIPS) {			if (err > 0) {				/*				 * The header is either absent or corrupted.				 * The former case means there is a bug -				 * switch to read-only mode just in case.				 * The latter case means a real corruption - we				 * may try to recover data. FIXME: but this is				 * not implemented.				 */<<<<<<< HEAD				if (err == UBI_IO_BAD_HDR_EBADMSG ||				    err == UBI_IO_BAD_HDR) {=======				if (err == UBI_IO_BAD_VID_HDR) {>>>>>>> 296c66da8a02d52243f45b80521febece5ed498a					ubi_warn("corrupted VID header at PEB "						 "%d, LEB %d:%d", pnum, vol_id,						 lnum);					err = -EBADMSG;				} else					ubi_ro_mode(ubi);			}

/** * ubi_open_volume - open UBI volume. * @ubi_num: UBI device number * @vol_id: volume ID * @mode: open mode * * The @mode parameter specifies if the volume should be opened in read-only * mode, read-write mode, or exclusive mode. The exclusive mode guarantees that * nobody else will be able to open this volume. UBI allows to have many volume * readers and one writer at a time. * * If a static volume is being opened for the first time since boot, it will be * checked by this function, which means it will be fully read and the CRC * checksum of each logical eraseblock will be checked. * * This function returns volume descriptor in case of success and a negative * error code in case of failure. */struct ubi_volume_desc *ubi_open_volume(int ubi_num, int vol_id, int mode){	int err;	struct ubi_volume_desc *desc;	struct ubi_device *ubi;	struct ubi_volume *vol;	dbg_gen("open device %d, volume %d, mode %d", ubi_num, vol_id, mode);	if (ubi_num < 0 || ubi_num >= UBI_MAX_DEVICES)		return ERR_PTR(-EINVAL);	if (mode != UBI_READONLY && mode != UBI_READWRITE &&	    mode != UBI_EXCLUSIVE)		return ERR_PTR(-EINVAL);	/*	 * First of all, we have to get the UBI device to prevent its removal.	 */	ubi = ubi_get_device(ubi_num);	if (!ubi)		return ERR_PTR(-ENODEV);	if (vol_id < 0 || vol_id >= ubi->vtbl_slots) {		err = -EINVAL;		goto out_put_ubi;	}	desc = kmalloc(sizeof(struct ubi_volume_desc), GFP_KERNEL);	if (!desc) {		err = -ENOMEM;		goto out_put_ubi;	}	err = -ENODEV;	if (!try_module_get(THIS_MODULE))		goto out_free;	spin_lock(&ubi->volumes_lock);	vol = ubi->volumes[vol_id];	if (!vol)		goto out_unlock;	err = -EBUSY;	switch (mode) {	case UBI_READONLY:		if (vol->exclusive)			goto out_unlock;		vol->readers += 1;		break;	case UBI_READWRITE:		if (vol->exclusive || vol->writers > 0)			goto out_unlock;		vol->writers += 1;		break;	case UBI_EXCLUSIVE:		if (vol->exclusive || vol->writers || vol->readers)			goto out_unlock;		vol->exclusive = 1;		break;	}	get_device(&vol->dev);	vol->ref_count += 1;	spin_unlock(&ubi->volumes_lock);	desc->vol = vol;	desc->mode = mode;	mutex_lock(&ubi->ckvol_mutex);	if (!vol->checked) {		/* This is the first open - check the volume */		err = ubi_check_volume(ubi, vol_id);		if (err < 0) {			mutex_unlock(&ubi->ckvol_mutex);			ubi_close_volume(desc);			return ERR_PTR(err);		}		if (err == 1) {			ubi_warn("volume %d on UBI device %d is corrupted",				 vol_id, ubi->ubi_num);//.........这里部分代码省略.........

/** * ubi_open_volume - open UBI volume. * @ubi_num: UBI device number * @vol_id: volume ID * @mode: open mode * * The @mode parameter specifies if the volume should be opened in read-only * mode, read-write mode, or exclusive mode. The exclusive mode guarantees that * nobody else will be able to open this volume. UBI allows to have many volume * readers and one writer at a time. * * If a static volume is being opened for the first time since boot, it will be * checked by this function, which means it will be fully read and the CRC * checksum of each logical eraseblock will be checked. * * This function returns volume descriptor in case of success and a negative * error code in case of failure. */struct ubi_volume_desc *ubi_open_volume(int ubi_num, int vol_id, int mode){	int err;	struct ubi_volume_desc *desc;	struct ubi_device *ubi = ubi_devices[ubi_num];	struct ubi_volume *vol;	dbg_msg("open device %d volume %d, mode %d", ubi_num, vol_id, mode);	err = -ENODEV;	if (!try_module_get(THIS_MODULE))		return ERR_PTR(err);	if (ubi_num < 0 || ubi_num >= UBI_MAX_DEVICES || !ubi)		goto out_put;	err = -EINVAL;	if (vol_id < 0 || vol_id >= ubi->vtbl_slots)		goto out_put;	if (mode != UBI_READONLY && mode != UBI_READWRITE &&	    mode != UBI_EXCLUSIVE)		goto out_put;	desc = kmalloc(sizeof(struct ubi_volume_desc), GFP_KERNEL);	if (!desc) {		err = -ENOMEM;		goto out_put;	}	spin_lock(&ubi->volumes_lock);	vol = ubi->volumes[vol_id];	if (!vol) {		err = -ENODEV;		goto out_unlock;	}	err = -EBUSY;	switch (mode) {	case UBI_READONLY:		if (vol->exclusive)			goto out_unlock;		vol->readers += 1;		break;	case UBI_READWRITE:		if (vol->exclusive || vol->writers > 0)			goto out_unlock;		vol->writers += 1;		break;	case UBI_EXCLUSIVE:		if (vol->exclusive || vol->writers || vol->readers)			goto out_unlock;		vol->exclusive = 1;		break;	}	spin_unlock(&ubi->volumes_lock);	desc->vol = vol;	desc->mode = mode;	/*	 * To prevent simultaneous checks of the same volume we use @vtbl_mutex,	 * although it is not the purpose it was introduced for.	 */	mutex_lock(&ubi->vtbl_mutex);	if (!vol->checked) {		/* This is the first open - check the volume */		err = ubi_check_volume(ubi, vol_id);		if (err < 0) {			mutex_unlock(&ubi->vtbl_mutex);			ubi_close_volume(desc);			return ERR_PTR(err);		}		if (err == 1) {			ubi_warn("volume %d on UBI device %d is corrupted",				 vol_id, ubi->ubi_num);			vol->corrupted = 1;		}		vol->checked = 1;	}	mutex_unlock(&ubi->vtbl_mutex);//.........这里部分代码省略.........

/** * 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;//.........这里部分代码省略.........

/** * do_sync_erase - synchronously erase a physical eraseblock. * @ubi: UBI device description object * @pnum: the physical eraseblock number to erase * * This function synchronously erases physical eraseblock @pnum and returns * zero in case of success and a negative error code in case of failure. If * %-EIO is returned, the physical eraseblock most probably went bad. */static int do_sync_erase(struct ubi_device *ubi, int pnum){	int err, retries = 0;	struct erase_info ei;	wait_queue_head_t wq;	dbg_io("erase PEB %d", pnum);	ubi_assert(pnum >= 0 && pnum < ubi->peb_count);	if (ubi->ro_mode) {		ubi_err(ubi, "read-only mode");		return -EROFS;	}retry:	init_waitqueue_head(&wq);	memset(&ei, 0, sizeof(struct erase_info));	ei.mtd      = ubi->mtd;	ei.addr     = (loff_t)pnum * ubi->peb_size;	ei.len      = ubi->peb_size;	ei.callback = erase_callback;	ei.priv     = (unsigned long)&wq;	err = mtd_erase(ubi->mtd, &ei);	if (err) {		if (retries++ < UBI_IO_RETRIES) {			ubi_warn(ubi, "error %d while erasing PEB %d, retry",				 err, pnum);			yield();			goto retry;		}		ubi_err(ubi, "cannot erase PEB %d, error %d", pnum, err);		dump_stack();		return err;	}	err = wait_event_interruptible(wq, ei.state == MTD_ERASE_DONE ||					   ei.state == MTD_ERASE_FAILED);	if (err) {		ubi_err(ubi, "interrupted PEB %d erasure", pnum);		return -EINTR;	}	if (ei.state == MTD_ERASE_FAILED) {		if (retries++ < UBI_IO_RETRIES) {			ubi_warn(ubi, "error while erasing PEB %d, retry",				 pnum);			yield();			goto retry;		}		ubi_err(ubi, "cannot erase PEB %d", pnum);		dump_stack();		return -EIO;	}	err = ubi_self_check_all_ff(ubi, pnum, 0, ubi->peb_size);	if (err)		return err;	if (ubi_dbg_is_erase_failure(ubi)) {		ubi_err(ubi, "cannot erase PEB %d (emulated)", pnum);		return -EIO;	}	return 0;}

/** * ubi_io_read - read data from a physical eraseblock. * @ubi: UBI device description object * @buf: buffer where to store the read data * @pnum: physical eraseblock number to read from * @offset: offset within the physical eraseblock from where to read * @len: how many bytes to read * * This function reads data from offset @offset of physical eraseblock @pnum * and stores the read data in the @buf buffer. The following return codes are * possible: * * o %0 if all the requested data were successfully read; * o %UBI_IO_BITFLIPS if all the requested data were successfully read, but *   correctable bit-flips were detected; this is harmless but may indicate *   that this eraseblock may become bad soon (but do not have to); * o %-EBADMSG if the MTD subsystem reported about data integrity problems, for *   example it can be an ECC error in case of NAND; this most probably means *   that the data is corrupted; * o %-EIO if some I/O error occurred; * o other negative error codes in case of other errors. */int ubi_io_read(const struct ubi_device *ubi, void *buf, int pnum, int offset,		int len){	int err, retries = 0;	size_t read;	loff_t addr;	dbg_io("read %d bytes from PEB %d:%d", len, pnum, offset);	ubi_assert(pnum >= 0 && pnum < ubi->peb_count);	ubi_assert(offset >= 0 && offset + len <= ubi->peb_size);	ubi_assert(len > 0);	err = self_check_not_bad(ubi, pnum);	if (err)		return err;	/*	 * Deliberately corrupt the buffer to improve robustness. Indeed, if we	 * do not do this, the following may happen:	 * 1. The buffer contains data from previous operation, e.g., read from	 *    another PEB previously. The data looks like expected, e.g., if we	 *    just do not read anything and return - the caller would not	 *    notice this. E.g., if we are reading a VID header, the buffer may	 *    contain a valid VID header from another PEB.	 * 2. The driver is buggy and returns us success or -EBADMSG or	 *    -EUCLEAN, but it does not actually put any data to the buffer.	 *	 * This may confuse UBI or upper layers - they may think the buffer	 * contains valid data while in fact it is just old data. This is	 * especially possible because UBI (and UBIFS) relies on CRC, and	 * treats data as correct even in case of ECC errors if the CRC is	 * correct.	 *	 * Try to prevent this situation by changing the first byte of the	 * buffer.	 */	*((uint8_t *)buf) ^= 0xFF;	addr = (loff_t)pnum * ubi->peb_size + offset;retry:	err = mtd_read(ubi->mtd, addr, len, &read, buf);	if (err) {		const char *errstr = mtd_is_eccerr(err) ? " (ECC error)" : "";		if (mtd_is_bitflip(err)) {			/*			 * -EUCLEAN is reported if there was a bit-flip which			 * was corrected, so this is harmless.			 *			 * We do not report about it here unless debugging is			 * enabled. A corresponding message will be printed			 * later, when it is has been scrubbed.			 */			ubi_msg(ubi, "fixable bit-flip detected at PEB %d",				pnum);			ubi_assert(len == read);			return UBI_IO_BITFLIPS;		}		if (retries++ < UBI_IO_RETRIES) {			ubi_warn(ubi, "error %d%s while reading %d bytes from PEB %d:%d, read only %zd bytes, retry",				 err, errstr, len, pnum, offset, read);			yield();			goto retry;		}		ubi_err(ubi, "error %d%s while reading %d bytes from PEB %d:%d, read %zd bytes",			err, errstr, len, pnum, offset, read);		dump_stack();		/*		 * The driver should never return -EBADMSG if it failed to read		 * all the requested data. But some buggy drivers might do		 * this, so we change it to -EIO.		 */		if (read != len && mtd_is_eccerr(err)) {			ubi_assert(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 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_assert(ubi->hdrs_min_io_size <= ubi->min_io_size);	ubi_assert(ubi->min_io_size % ubi->hdrs_min_io_size == 0);	ubi->max_write_size = ubi->mtd->writesize; /* FIXME: writebufsize */	/*	 * Maximum write size has to be greater or equivalent to min. I/O	 * size, and be multiple of min. I/O size.	 */	if (ubi->max_write_size < ubi->min_io_size ||	    ubi->max_write_size % ubi->min_io_size ||	    !is_power_of_2(ubi->max_write_size)) {		ubi_err("bad write buffer size %d for %d min. I/O unit",			ubi->max_write_size, ubi->min_io_size);		return -EINVAL;	}	/* Calculate default aligned sizes of EC and VID headers */	ubi->ec_hdr_alsize = ALIGN(UBI_EC_HDR_SIZE, ubi->hdrs_min_io_size);	ubi->vid_hdr_alsize = ALIGN(UBI_VID_HDR_SIZE, ubi->hdrs_min_io_size);	dbg_gen("min_io_size      %d", ubi->min_io_size);	dbg_gen("max_write_size   %d", ubi->max_write_size);	dbg_gen("hdrs_min_io_size %d", ubi->hdrs_min_io_size);	dbg_gen("ec_hdr_alsize    %d", ubi->ec_hdr_alsize);	dbg_gen("vid_hdr_alsize   %d", ubi->vid_hdr_alsize);	if (ubi->vid_hdr_offset == 0)		/* Default offset */		ubi->vid_hdr_offset = ubi->vid_hdr_aloffset =				      ubi->ec_hdr_alsize;	else {		ubi->vid_hdr_aloffset = ubi->vid_hdr_offset &						~(ubi->hdrs_min_io_size - 1);		ubi->vid_hdr_shift = ubi->vid_hdr_offset -						ubi->vid_hdr_aloffset;	}	/* Similar for the data offset */	ubi->leb_start = ubi->vid_hdr_offset + UBI_VID_HDR_SIZE;	ubi->leb_start = ALIGN(ubi->leb_start, ubi->min_io_size);	dbg_gen("vid_hdr_offset   %d", ubi->vid_hdr_offset);	dbg_gen("vid_hdr_aloffset %d", ubi->vid_hdr_aloffset);	dbg_gen("vid_hdr_shift    %d", ubi->vid_hdr_shift);	dbg_gen("leb_start        %d", ubi->leb_start);	/* The shift must be aligned to 32-bit boundary */	if (ubi->vid_hdr_shift % 4) {		ubi_err("unaligned VID header shift %d",			ubi->vid_hdr_shift);		return -EINVAL;	}	/* Check sanity */	if (ubi->vid_hdr_offset < UBI_EC_HDR_SIZE ||	    ubi->leb_start < ubi->vid_hdr_offset + UBI_VID_HDR_SIZE ||	    ubi->leb_start > ubi->peb_size - UBI_VID_HDR_SIZE ||	    ubi->leb_start & (ubi->min_io_size - 1)) {		ubi_err("bad VID header (%d) or data offsets (%d)",			ubi->vid_hdr_offset, ubi->leb_start);		return -EINVAL;	}	/*	 * Set maximum amount of physical erroneous eraseblocks to be 10%.	 * Erroneous PEB are those which have read errors.	 */	ubi->max_erroneous = ubi->peb_count / 10;	if (ubi->max_erroneous < 16)		ubi->max_erroneous = 16;	dbg_gen("max_erroneous    %d", ubi->max_erroneous);	/*	 * It may happen that EC and VID headers are situated in one minimal	 * I/O unit. In this case we can only accept this UBI image in	 * read-only mode.	 */	if (ubi->vid_hdr_offset + UBI_VID_HDR_SIZE <= ubi->hdrs_min_io_size) {		ubi_warn("EC and VID headers are in the same minimal I/O unit, switch to read-only mode");		ubi->ro_mode = 1;	}	ubi->leb_size = ubi->peb_size - ubi->leb_start;	if (!(ubi->mtd->flags & MTD_WRITEABLE)) {		ubi_msg("MTD device %d is write-protected, attach in read-only mode",			ubi->mtd->index);		ubi->ro_mode = 1;	}	/*	 * Note, ideally, we have to initialize @ubi->bad_peb_count here. But	 * unfortunately, MTD does not provide this information. We should loop	 * over all physical eraseblocks and invoke mtd->block_is_bad() for	 * each physical eraseblock. So, we leave @ubi->bad_peb_count	 * uninitialized so far.	 */	return 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);//.........这里部分代码省略.........

/* Insert the logic block into the volume info */static int ubi_add_peb_to_vol(struct ubi_scan_info *ubi,			      struct ubi_vid_hdr *vh, u32 vol_id,			      u32 pnum, u32 lnum){	struct ubi_vol_info *vi = ubi->volinfo + vol_id;	u32 *ltp;	/*	 * If the volume is larger than expected, yell and give up :(	 */	if (lnum >= UBI_MAX_VOL_LEBS) {		ubi_warn("Vol: %u LEB %d > %d", vol_id, lnum, UBI_MAX_VOL_LEBS);		return -EINVAL;	}	ubi_dbg("SC: Add PEB %u to Vol %u as LEB %u fnd %d sc %d",		pnum, vol_id, lnum, !!test_bit(lnum, vi->found),		!!test_bit(pnum, ubi->scanned));	/* Points to the translation entry */	ltp = vi->lebs_to_pebs + lnum;	/* If the block is already assigned, check sqnum */	if (__test_and_set_bit(lnum, vi->found)) {		u32 cur_pnum = *ltp;		struct ubi_vid_hdr *cur = ubi->blockinfo + cur_pnum;		/*		 * If the current block hase not yet been scanned, we		 * need to do that. The other block might be stale or		 * the current block corrupted and the FM not yet		 * updated.		 */		if (!test_bit(cur_pnum, ubi->scanned)) {			/*			 * If the scan fails, we use the valid block			 */			if (ubi_rescan_fm_vid_hdr(ubi, cur, cur_pnum, vol_id,						  lnum)) {				*ltp = pnum;				return 0;			}		}		/*		 * Should not happen ....		 */		if (test_bit(cur_pnum, ubi->corrupt)) {			*ltp = pnum;			return 0;		}		ubi_dbg("Vol %u LEB %u PEB %u->sqnum %llu NPEB %u->sqnum %llu",			vol_id, lnum, cur_pnum, be64_to_cpu(cur->sqnum), pnum,			be64_to_cpu(vh->sqnum));		/*		 * Compare sqnum and take the newer one		 */		if (be64_to_cpu(cur->sqnum) < be64_to_cpu(vh->sqnum))			*ltp = pnum;	} else {		*ltp = pnum;		if (lnum > vi->last_block)			vi->last_block = lnum;	}	return 0;}

/* * 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))//.........这里部分代码省略.........