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

/** * in_wl_tree - check if wear-leveling entry is present in a WL RB-tree. * @e: the wear-leveling entry to check * @root: the root of the tree * * This function returns non-zero if @e is in the @root RB-tree and zero if it * is not. */static int in_wl_tree(struct ubi_wl_entry *e, struct rb_root *root){	struct rb_node *p;	p = root->rb_node;	while (p) {		struct ubi_wl_entry *e1;		e1 = rb_entry(p, struct ubi_wl_entry, u.rb);		if (e->pnum == e1->pnum) {			ubi_assert(e == e1);			return 1;		}		if (e->ec < e1->ec)			p = p->rb_left;		else if (e->ec > e1->ec)			p = p->rb_right;		else {			ubi_assert(e->pnum != e1->pnum);			if (e->pnum < e1->pnum)				p = p->rb_left;			else				p = p->rb_right;		}	}	return 0;}

/* Write one page with oob one time */int ubi_io_write_oob(const struct ubi_device *ubi, void *databuf, void *oobbuf,                int pnum, int offset){        int err;        loff_t addr;        struct mtd_oob_ops ops;        dbg_io("read from PEB %d:%d", pnum, offset);        ubi_assert(pnum >= 0 && pnum < ubi->peb_count);        ubi_assert(offset >= 0 && offset + ubi->mtd->writesize <= ubi->peb_size);        addr = (loff_t)pnum * ubi->peb_size + offset;        ops.mode = MTD_OPS_AUTO_OOB;        ops.ooblen = ubi->mtd->oobavail;        ops.oobbuf = oobbuf;        ops.ooboffs = 0;        ops.len = ubi->mtd->writesize;        ops.datbuf = databuf;        ops.retlen = ops.oobretlen = 0;        err = mtd_write_oob(ubi->mtd, addr, &ops);        if (err) {                ubi_err("error %d while writing to addr %lld peb%d:0x%x, written ",                        err, addr, pnum, offset);                dump_stack();        } else                ubi_assert(ops.retlen == ops.len);        return err;}

/** * ubi_remove_volume - remove volume. * @desc: volume descriptor * @no_vtbl: do not change volume table if not zero * * This function removes volume described by @desc. The volume has to be opened * in "exclusive" mode. Returns zero in case of success and a negative error * code in case of failure. The caller has to have the @ubi->device_mutex * locked. */int ubi_remove_volume(struct ubi_volume_desc *desc, int no_vtbl){	struct ubi_volume *vol = desc->vol;	struct ubi_device *ubi = vol->ubi;	int i, err, vol_id = vol->vol_id, reserved_pebs = vol->reserved_pebs;	dbg_gen("remove device %d, volume %d", ubi->ubi_num, vol_id);	ubi_assert(desc->mode == UBI_EXCLUSIVE);	ubi_assert(vol == ubi->volumes[vol_id]);	if (ubi->ro_mode)		return -EROFS;	if (vol->ref_count > 1) {		/*		 * The volume is busy, probably someone is reading one of its		 * sysfs files.		 */		err = -EBUSY;		goto out_unlock;	}	ubi->volumes[vol_id] = NULL;	if (!no_vtbl) {		err = ubi_change_vtbl_record(ubi, vol_id, NULL);		if (err)			goto out_err;	}	for (i = 0; i < vol->reserved_pebs; i++) {		err = ubi_eba_unmap_leb(ubi, vol, i);		if (err)			goto out_err;	}	unregister_device(&vol->dev);	devfs_remove(&vol->cdev);	ubi->rsvd_pebs -= reserved_pebs;	ubi->avail_pebs += reserved_pebs;	ubi_update_reserved(ubi);	ubi->vol_count -= 1;	ubi_volume_notify(ubi, vol, UBI_VOLUME_REMOVED);	if (!no_vtbl)		self_check_volumes(ubi);	return err;out_err:	ubi_err(ubi, "cannot remove volume %d, error %d", vol_id, err);	ubi->volumes[vol_id] = vol;out_unlock:	return err;}

/** * 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 = paranoid_check_not_bad(ubi, pnum);	if (err)		return err > 0 ? -EINVAL : err;	addr = (loff_t)pnum * ubi->peb_size + offset;retry:	err = ubi->mtd->read(ubi->mtd, addr, len, &read, buf);	if (err) {		if (err == -EUCLEAN) {			/*			 * -EUCLEAN is reported if there was a bit-flip which			 * was corrected, so this is harmless.			 */			ubi_msg("fixable bit-flip detected at PEB %d", pnum);			ubi_assert(len == read);			return UBI_IO_BITFLIPS;		}		if (read != len && retries++ < UBI_IO_RETRIES) {			dbg_io("error %d while reading %d bytes from PEB %d:%d, "			       "read only %zd bytes, retry",			       err, len, pnum, offset, read);			yield();			goto retry;		}		ubi_err("error %d while reading %d bytes from PEB %d:%d, "			"read %zd bytes", err, len, pnum, offset, read);		ubi_dbg_dump_stack();	} else {		ubi_assert(len == read);		if (ubi_dbg_is_bitflip()) {			dbg_msg("bit-flip (emulated)");			err = UBI_IO_BITFLIPS;		}	}	return err;}

/* Read one page with oob one time */int ubi_io_read_oob(const struct ubi_device *ubi, void *databuf, void *oobbuf,                int pnum, int offset){        int err;        loff_t addr;        struct mtd_oob_ops ops;        dbg_io("read from PEB %d:%d", pnum, offset);        ubi_assert(pnum >= 0 && pnum < ubi->peb_count);        ubi_assert(offset >= 0 && offset + ubi->mtd->writesize <= ubi->peb_size);        addr = (loff_t)pnum * ubi->peb_size + offset;        ops.mode = MTD_OPS_AUTO_OOB;        ops.ooblen = ubi->mtd->oobavail;        ops.oobbuf = oobbuf;        ops.ooboffs = 0;        ops.len = ubi->mtd->writesize;        ops.datbuf = databuf;        ops.retlen = ops.oobretlen = 0;        err = mtd_read_oob(ubi->mtd, addr, &ops);        if (err) {                if (err == -EUCLEAN) {                        /*                         * -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("fixable bit-flip detected at addr %lld", addr);                        if(oobbuf)                                ubi_assert(ops.oobretlen == ops.ooblen);                        return UBI_IO_BITFLIPS;                }                if (ops.retlen != ops.len && err == -EBADMSG) {                        ubi_err("err(%d), retlen(%zu), len(%zu)", err, ops.retlen, ops.len);			dump_stack();                        err = -EIO;                }		ubi_msg("mtd_read_oob err %d/n", err);        }        return err;}

/** * ltree_add_entry - add new entry to the lock tree. * @ubi: UBI device description object * @vol_id: volume ID * @lnum: logical eraseblock number * * This function adds new entry for logical eraseblock (@vol_id, @lnum) to the * lock tree. If such entry is already there, its usage counter is increased. * Returns pointer to the lock tree entry or %-ENOMEM if memory allocation * failed. */static struct ubi_ltree_entry *ltree_add_entry(struct ubi_device *ubi,					       int vol_id, int lnum){	struct ubi_ltree_entry *le, *le1, *le_free;	le = kmalloc(sizeof(struct ubi_ltree_entry), GFP_NOFS);	if (!le)		return ERR_PTR(-ENOMEM);	le->users = 0;	init_rwsem(&le->mutex);	le->vol_id = vol_id;	le->lnum = lnum;	spin_lock(&ubi->ltree_lock);	le1 = ltree_lookup(ubi, vol_id, lnum);	if (le1) {		/*		 * This logical eraseblock is already locked. The newly		 * allocated lock entry is not needed.		 */		le_free = le;		le = le1;	} else {		struct rb_node **p, *parent = NULL;		/*		 * No lock entry, add the newly allocated one to the		 * @ubi->ltree RB-tree.		 */		le_free = NULL;		p = &ubi->ltree.rb_node;		while (*p) {			parent = *p;			le1 = rb_entry(parent, struct ubi_ltree_entry, rb);			if (vol_id < le1->vol_id)				p = &(*p)->rb_left;			else if (vol_id > le1->vol_id)				p = &(*p)->rb_right;			else {				ubi_assert(lnum != le1->lnum);				if (lnum < le1->lnum)					p = &(*p)->rb_left;				else					p = &(*p)->rb_right;			}		}		rb_link_node(&le->rb, parent, p);		rb_insert_color(&le->rb, &ubi->ltree);	}	le->users += 1;	spin_unlock(&ubi->ltree_lock);	kfree(le_free);	return le;}

/** * ubi_io_write_ec_hdr - write an erase counter header. * @ubi: UBI device description object * @pnum: physical eraseblock to write to * @ec_hdr: the erase counter header to write * * This function writes erase counter header described by @ec_hdr to physical * eraseblock @pnum. It also fills most fields of @ec_hdr before writing, so * the caller do not have to fill them. Callers must only fill the @ec_hdr->ec * field. * * This function 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. */int ubi_io_write_ec_hdr(struct ubi_device *ubi, int pnum,			struct ubi_ec_hdr *ec_hdr){	int err;	uint32_t crc;	dbg_io("write EC header to PEB %d", pnum);	ubi_assert(pnum >= 0 &&  pnum < ubi->peb_count);	ec_hdr->magic = cpu_to_be32(UBI_EC_HDR_MAGIC);	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);	err = self_check_ec_hdr(ubi, pnum, ec_hdr);	if (err)		return err;	if (ubi_dbg_power_cut(ubi, POWER_CUT_EC_WRITE))		return -EROFS;	err = ubi_io_write(ubi, ec_hdr, pnum, 0, ubi->ec_hdr_alsize);	return err;}

/** * wl_tree_add - add a wear-leveling entry to a WL RB-tree. * @e: the wear-leveling entry to add * @root: the root of the tree * * Note, we use (erase counter, physical eraseblock number) pairs as keys in * the @ubi->used and @ubi->free RB-trees. */static void wl_tree_add(struct ubi_wl_entry *e, struct rb_root *root){	struct rb_node **p, *parent = NULL;	p = &root->rb_node;	while (*p) {		struct ubi_wl_entry *e1;		parent = *p;		e1 = rb_entry(parent, struct ubi_wl_entry, u.rb);		if (e->ec < e1->ec)			p = &(*p)->rb_left;		else if (e->ec > e1->ec)			p = &(*p)->rb_right;		else {			ubi_assert(e->pnum != e1->pnum);			if (e->pnum < e1->pnum)				p = &(*p)->rb_left;			else				p = &(*p)->rb_right;		}	}	rb_link_node(&e->u.rb, parent, p);	rb_insert_color(&e->u.rb, root);}

/** * ubi_io_write_ec_hdr - write an erase counter header. * @ubi: UBI device description object * @pnum: physical eraseblock to write to * @ec_hdr: the erase counter header to write * * This function writes erase counter header described by @ec_hdr to physical * eraseblock @pnum. It also fills most fields of @ec_hdr before writing, so * the caller do not have to fill them. Callers must only fill the @ec_hdr->ec * field. * * This function 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. */int ubi_io_write_ec_hdr(struct ubi_device *ubi, int pnum,			struct ubi_ec_hdr *ec_hdr){	int err;	uint32_t crc;	dbg_io("write EC header to PEB %d", pnum);	ubi_assert(pnum >= 0 &&  pnum < ubi->peb_count);	ec_hdr->magic = cpu_to_be32(UBI_EC_HDR_MAGIC);	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);	err = self_check_ec_hdr(ubi, pnum, ec_hdr);	if (err)		return err;#ifdef CONFIG_PWR_LOSS_MTK_SPOH    PL_RESET_ON_CASE("NAND", "WRITE_EC_Header");#endif	err = ubi_io_write(ubi, ec_hdr, pnum, 0, ubi->ec_hdr_alsize);	return err;}

/** * ubi_io_sync_erase - synchronously erase a physical eraseblock. * @ubi: UBI device description object * @pnum: physical eraseblock number to erase * @torture: if this physical eraseblock has to be tortured * * This function synchronously erases physical eraseblock @pnum. If @torture * flag is not zero, the physical eraseblock is checked by means of writing * different patterns to it and reading them back. If the torturing is enabled, * the physical eraseblock is erased more than once. * * This function returns the number of erasures made in case of success, %-EIO * if the erasure failed or the torturing test failed, and other negative error * codes in case of other errors. Note, %-EIO means that the physical * eraseblock is bad. */int ubi_io_sync_erase(struct ubi_device *ubi, int pnum, int torture){	int err, ret = 0;	ubi_assert(pnum >= 0 && pnum < ubi->peb_count);	err = self_check_not_bad(ubi, pnum);	if (err != 0)		return err;	if (ubi->ro_mode) {		ubi_err(ubi, "read-only mode");		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)			return ret;	}	err = do_sync_erase(ubi, pnum);	if (err)		return err;	return ret + 1;}

/** * ubi_io_write_vid_hdr - write a volume identifier header. * @ubi: UBI device description object * @pnum: the physical eraseblock number to write to * @vid_hdr: the volume identifier header to write * * This function writes the volume identifier header described by @vid_hdr to * physical eraseblock @pnum. This function automatically fills the * @vid_hdr->magic and the @vid_hdr->version fields, as well as calculates * header CRC checksum and stores it at vid_hdr->hdr_crc. * * This function returns zero in case of success and a negative error code in * case of failure. If %-EIO is returned, the physical eraseblock probably went * bad. */int ubi_io_write_vid_hdr(struct ubi_device *ubi, int pnum,			 struct ubi_vid_hdr *vid_hdr){	int err;	uint32_t crc;	void *p;	dbg_io("write VID header to PEB %d", pnum);	ubi_assert(pnum >= 0 &&  pnum < ubi->peb_count);	err = self_check_peb_ec_hdr(ubi, pnum);	if (err)		return err;	vid_hdr->magic = cpu_to_be32(UBI_VID_HDR_MAGIC);	vid_hdr->version = UBI_VERSION;	crc = crc32(UBI_CRC32_INIT, vid_hdr, UBI_VID_HDR_SIZE_CRC);	vid_hdr->hdr_crc = cpu_to_be32(crc);	err = self_check_vid_hdr(ubi, pnum, vid_hdr);	if (err)		return err;	p = (char *)vid_hdr - ubi->vid_hdr_shift;	err = ubi_io_write(ubi, p, pnum, ubi->vid_hdr_aloffset,			   ubi->vid_hdr_alsize);	return err;}

/** * ubi_io_write_vid_hdr - write a volume identifier header. * @ubi: UBI device description object * @pnum: the physical eraseblock number to write to * @vidb: the volume identifier buffer to write * * This function writes the volume identifier header described by @vid_hdr to * physical eraseblock @pnum. This function automatically fills the * @vidb->hdr->magic and the @vidb->hdr->version fields, as well as calculates * header CRC checksum and stores it at vidb->hdr->hdr_crc. * * This function returns zero in case of success and a negative error code in * case of failure. If %-EIO is returned, the physical eraseblock probably went * bad. */int ubi_io_write_vid_hdr(struct ubi_device *ubi, int pnum,			 struct ubi_vid_io_buf *vidb){	struct ubi_vid_hdr *vid_hdr = ubi_get_vid_hdr(vidb);	int err;	uint32_t crc;	void *p = vidb->buffer;	dbg_io("write VID header to PEB %d", pnum);	ubi_assert(pnum >= 0 &&  pnum < ubi->peb_count);	err = self_check_peb_ec_hdr(ubi, pnum);	if (err)		return err;	vid_hdr->magic = cpu_to_be32(UBI_VID_HDR_MAGIC);	vid_hdr->version = UBI_VERSION;	crc = crc32(UBI_CRC32_INIT, vid_hdr, UBI_VID_HDR_SIZE_CRC);	vid_hdr->hdr_crc = cpu_to_be32(crc);	err = self_check_vid_hdr(ubi, pnum, vid_hdr);	if (err)		return err;	if (ubi_dbg_power_cut(ubi, POWER_CUT_VID_WRITE))		return -EROFS;	err = ubi_io_write(ubi, p, pnum, ubi->vid_hdr_aloffset,			   ubi->vid_hdr_alsize);	return err;}

/** * clear_update_marker - clear update marker. * @ubi: UBI device description object * @vol: volume description object * @bytes: new data size in bytes * * This function clears the update marker for volume @vol, sets new volume * data size and clears the "corrupted" flag (static volumes only). Returns * zero in case of success and a negative error code in case of failure. */static int clear_update_marker(struct ubi_device *ubi, struct ubi_volume *vol,                   long long bytes){    int err;    uint64_t tmp;    struct ubi_vtbl_record vtbl_rec;    dbg_msg("clear update marker for volume %d", vol->vol_id);    memcpy(&vtbl_rec, &ubi->vtbl[vol->vol_id],           sizeof(struct ubi_vtbl_record));    ubi_assert(vol->upd_marker && vtbl_rec.upd_marker);    vtbl_rec.upd_marker = 0;    if (vol->vol_type == UBI_STATIC_VOLUME) {        vol->corrupted = 0;        vol->used_bytes = tmp = bytes;        vol->last_eb_bytes = do_div(tmp, vol->usable_leb_size);        vol->used_ebs = tmp;        if (vol->last_eb_bytes)            vol->used_ebs += 1;        else            vol->last_eb_bytes = vol->usable_leb_size;    }    mutex_lock(&ubi->volumes_mutex);    err = ubi_change_vtbl_record(ubi, vol->vol_id, &vtbl_rec);    mutex_unlock(&ubi->volumes_mutex);    vol->upd_marker = 0;    return err;}

/** * ubi_io_sync_erase - synchronously erase a physical eraseblock. * @ubi: UBI device description object * @pnum: physical eraseblock number to erase * @torture: if this physical eraseblock has to be tortured * * This function synchronously erases physical eraseblock @pnum. If @torture * flag is not zero, the physical eraseblock is checked by means of writing * different patterns to it and reading them back. If the torturing is enabled, * the physical eraseblock is erased more then once. * * This function returns the number of erasures made in case of success, %-EIO * if the erasure failed or the torturing test failed, and other negative error * codes in case of other errors. Note, %-EIO means that the physical * eraseblock is bad. */int ubi_io_sync_erase(struct ubi_device *ubi, int pnum, int torture){	int err, ret = 0;	ubi_assert(pnum >= 0 && pnum < ubi->peb_count);	err = paranoid_check_not_bad(ubi, pnum);	if (err != 0)		return err > 0 ? -EINVAL : err;	if (ubi->ro_mode) {		ubi_err("read-only mode");		return -EROFS;	}	if (torture) {		ret = torture_peb(ubi, pnum);		if (ret < 0)			return ret;	}	err = do_sync_erase(ubi, pnum);	if (err)		return err;	return ret + 1;}

/** * ubi_change_vtbl_record - change volume table record. * @ubi: UBI device description object * @idx: table index to change * @vtbl_rec: new volume table record * * This function changes volume table record @idx. If @vtbl_rec is %NULL, empty * volume table record is written. The caller does not have to calculate CRC of * the record as it is done by this function. Returns zero in case of success * and a negative error code in case of failure. */int ubi_change_vtbl_record(struct ubi_device *ubi, int idx,			   struct ubi_vtbl_record *vtbl_rec){	int i, err;	uint32_t crc;	struct ubi_volume *layout_vol;	ubi_assert(idx >= 0 && idx < ubi->vtbl_slots);	layout_vol = ubi->volumes[vol_id2idx(ubi, UBI_LAYOUT_VOLUME_ID)];	if (!vtbl_rec)		vtbl_rec = &empty_vtbl_record;	else {		crc = crc32(UBI_CRC32_INIT, vtbl_rec, UBI_VTBL_RECORD_SIZE_CRC);		vtbl_rec->crc = cpu_to_be32(crc);	}	memcpy(&ubi->vtbl[idx], vtbl_rec, sizeof(struct ubi_vtbl_record));	for (i = 0; i < UBI_LAYOUT_VOLUME_EBS; i++) {		err = ubi_eba_unmap_leb(ubi, layout_vol, i);		if (err)			return err;		err = ubi_eba_write_leb(ubi, layout_vol, i, ubi->vtbl, 0,					ubi->vtbl_size);		if (err)			return err;	}	self_vtbl_check(ubi);	return 0;}

/** * clear_update_marker - clear update marker. * @ubi: UBI device description object * @vol: volume description object * @bytes: new data size in bytes * * This function clears the update marker for volume @vol, sets new volume * data size and clears the "corrupted" flag (static volumes only). Returns * zero in case of success and a negative error code in case of failure. */static int clear_update_marker(struct ubi_device *ubi, struct ubi_volume *vol,			       long long bytes){	int err;	struct ubi_vtbl_record vtbl_rec;	dbg_gen("clear update marker for volume %d", vol->vol_id);	vtbl_rec = ubi->vtbl[vol->vol_id];	ubi_assert(vol->upd_marker && vtbl_rec.upd_marker);	vtbl_rec.upd_marker = 0;	if (vol->vol_type == UBI_STATIC_VOLUME) {		vol->corrupted = 0;		vol->used_bytes = bytes;		vol->used_ebs = div_u64_rem(bytes, vol->usable_leb_size,					    &vol->last_eb_bytes);		if (vol->last_eb_bytes)			vol->used_ebs += 1;		else			vol->last_eb_bytes = vol->usable_leb_size;	}	mutex_lock(&ubi->device_mutex);	err = ubi_change_vtbl_record(ubi, vol->vol_id, &vtbl_rec);	vol->upd_marker = 0;	mutex_unlock(&ubi->device_mutex);	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;	struct ubi_ec_hdr ec_hdr;	struct ubi_vid_io_buf vidb;	/*	 * Note, we cannot generally define VID header buffers on stack,	 * because of the way we deal with these buffers (see the header	 * comment in this file). But we know this is a NOR-specific piece of	 * code, so we can do this. But yes, this is error-prone and we should	 * (pre-)allocate VID header buffer instead.	 */	struct ubi_vid_hdr vid_hdr;	/*	 * If VID or EC is valid, we have to corrupt them before erasing.	 * It is important to first invalidate the EC header, and then the VID	 * header. Otherwise a power cut may lead to valid EC header and	 * invalid VID header, in which case UBI will treat this PEB as	 * corrupted and will try to preserve it, and print scary warnings.	 */	addr = (loff_t)pnum * ubi->peb_size;	err = ubi_io_read_ec_hdr(ubi, pnum, &ec_hdr, 0);	if (err != UBI_IO_BAD_HDR_EBADMSG && err != UBI_IO_BAD_HDR &&	    err != UBI_IO_FF){		err = mtd_write(ubi->mtd, addr, 4, &written, (void *)&data);		if(err)			goto error;	}	ubi_init_vid_buf(ubi, &vidb, &vid_hdr);	ubi_assert(&vid_hdr == ubi_get_vid_hdr(&vidb));	err = ubi_io_read_vid_hdr(ubi, pnum, &vidb, 0);	if (err != UBI_IO_BAD_HDR_EBADMSG && err != UBI_IO_BAD_HDR &&	    err != UBI_IO_FF){		addr += ubi->vid_hdr_aloffset;		err = mtd_write(ubi->mtd, addr, 4, &written, (void *)&data);		if (err)			goto error;	}	return 0;error:	/*	 * The PEB contains a valid VID or EC header, but we cannot invalidate	 * it. Supposedly the flash media or the driver is screwed up, so	 * return an error.	 */	ubi_err(ubi, "cannot invalidate PEB %d, write returned %d", pnum, err);	ubi_dump_flash(ubi, pnum, 0, ubi->peb_size);	return -EIO;}

/** * revoke_exclusive - revoke exclusive mode. * @desc: volume descriptor * @mode: new mode to switch to */static void revoke_exclusive(struct ubi_volume_desc *desc, int mode){	struct ubi_volume *vol = desc->vol;	spin_lock(&vol->ubi->volumes_lock);	ubi_assert(vol->readers == 0 && vol->writers == 0);	ubi_assert(vol->exclusive == 1 && desc->mode == UBI_EXCLUSIVE);	vol->exclusive = 0;	if (mode == UBI_READONLY)		vol->readers = 1;	else if (mode == UBI_READWRITE)		vol->writers = 1;	else		vol->exclusive = 1;	spin_unlock(&vol->ubi->volumes_lock);	desc->mode = mode;}

/** * prot_queue_add - add physical eraseblock to the protection queue. * @ubi: UBI device description object * @e: the physical eraseblock to add * * This function adds @e to the tail of the protection queue @ubi->pq, where * @e will stay for %UBI_PROT_QUEUE_LEN erase operations and will be * temporarily protected from the wear-leveling worker. Note, @wl->lock has to * be locked. */static void prot_queue_add(struct ubi_device *ubi, struct ubi_wl_entry *e){	int pq_tail = ubi->pq_head - 1;	if (pq_tail < 0)		pq_tail = UBI_PROT_QUEUE_LEN - 1;	ubi_assert(pq_tail >= 0 && pq_tail < UBI_PROT_QUEUE_LEN);	list_add_tail(&e->u.list, &ubi->pq[pq_tail]);	dbg_wl("added PEB %d EC %d to the protection queue", e->pnum, e->ec);}

/** * gluebi_put_device - put MTD device reference. * @mtd: the MTD device description object * * This function is called every time the MTD device is being put. Returns * zero in case of success and a negative error code in case of failure. */static void gluebi_put_device(struct mtd_info *mtd){	struct ubi_volume *vol;	vol = container_of(mtd, struct ubi_volume, gluebi_mtd);	vol->gluebi_refcount -= 1;	ubi_assert(vol->gluebi_refcount >= 0);	if (vol->gluebi_refcount == 0)		ubi_close_volume(vol->gluebi_desc);}

int ubi_calc_data_len(const struct ubi_device *ubi, const void *buf,		      int length){	int i;	ubi_assert(!(length & (ubi->min_io_size - 1)));	for (i = length - 1; i >= 0; i--)		if (((const uint8_t *)buf)[i] != 0xFF)			break;	/* The resulting length must be aligned to the minimum flash I/O size */	length = ALIGN(i + 1, ubi->min_io_size);	return length;}

/** * leb_write_unlock - unlock logical eraseblock. * @ubi: UBI device description object * @vol_id: volume ID * @lnum: logical eraseblock number */static void leb_write_unlock(struct ubi_device *ubi, int vol_id, int lnum){	struct ubi_ltree_entry *le;	spin_lock(&ubi->ltree_lock);	le = ltree_lookup(ubi, vol_id, lnum);	le->users -= 1;	ubi_assert(le->users >= 0);	up_write(&le->mutex);	if (le->users == 0) {		rb_erase(&le->rb, &ubi->ltree);		kfree(le);	}	spin_unlock(&ubi->ltree_lock);}

/** * add_volume - add volume to the scanning information. * @si: scanning information * @vol_id: ID of the volume to add * @pnum: physical eraseblock number * @vid_hdr: volume identifier header * * If the volume corresponding to the @vid_hdr logical eraseblock is already * present in the scanning information, this function does nothing. Otherwise * it adds corresponding volume to the scanning information. Returns a pointer * to the scanning volume object in case of success and a negative error code * in case of failure. */static struct ubi_scan_volume *add_volume(struct ubi_scan_info *si, int vol_id,					  int pnum,					  const struct ubi_vid_hdr *vid_hdr){	struct ubi_scan_volume *sv;	struct rb_node **p = &si->volumes.rb_node, *parent = NULL;	ubi_assert(vol_id == be32_to_cpu(vid_hdr->vol_id));	/* Walk the volume RB-tree to look if this volume is already present */	while (*p) {		parent = *p;		sv = rb_entry(parent, struct ubi_scan_volume, rb);		if (vol_id == sv->vol_id)			return sv;		if (vol_id > sv->vol_id)			p = &(*p)->rb_left;		else			p = &(*p)->rb_right;	}	/* The volume is absent - add it */	sv = kmalloc(sizeof(struct ubi_scan_volume), GFP_KERNEL);	if (!sv)		return ERR_PTR(-ENOMEM);	sv->highest_lnum = sv->leb_count = 0;	sv->vol_id = vol_id;	sv->root = RB_ROOT;	sv->used_ebs = be32_to_cpu(vid_hdr->used_ebs);	sv->data_pad = be32_to_cpu(vid_hdr->data_pad);	sv->compat = vid_hdr->compat;	sv->vol_type = vid_hdr->vol_type == UBI_VID_DYNAMIC ? UBI_DYNAMIC_VOLUME							    : UBI_STATIC_VOLUME;	if (vol_id > si->highest_vol_id)		si->highest_vol_id = vol_id;	rb_link_node(&sv->rb, parent, p);	rb_insert_color(&sv->rb, &si->volumes);	si->vols_found += 1;	dbg_bld("added volume %d", vol_id);	return sv;}

/** * ubi_start_update - start volume update. * @ubi: UBI device description object * @vol: volume description object * @bytes: update bytes * * This function starts volume update operation. If @bytes is zero, the volume * is just wiped out. Returns zero in case of success and a negative error code * in case of failure. */int ubi_start_update(struct ubi_device *ubi, struct ubi_volume *vol,		     long long bytes){	int i, err;	dbg_gen("start update of volume %d, %llu bytes", vol->vol_id, bytes);	ubi_assert(!vol->updating && !vol->changing_leb);	vol->updating = 1;	vol->upd_buf = vmalloc(ubi->leb_size);	if (!vol->upd_buf)		return -ENOMEM;	err = set_update_marker(ubi, vol);	if (err)		return err;	/* Before updating - wipe out the volume */	for (i = 0; i < vol->reserved_pebs; i++) {		err = ubi_eba_unmap_leb(ubi, vol, i);		if (err)			return err;	}	if (bytes == 0) {		err = ubi_wl_flush(ubi, UBI_ALL, UBI_ALL);		if (err)			return err;		err = clear_update_marker(ubi, vol, 0);		if (err)			return err;		vfree(vol->upd_buf);		vol->updating = 0;		return 0;	}	vol->upd_ebs = div_u64(bytes + vol->usable_leb_size - 1,			       vol->usable_leb_size);	vol->upd_bytes = bytes;	vol->upd_received = 0;	return 0;}

/** * ubi_change_vtbl_record - change volume table record. * @ubi: UBI device description object * @idx: table index to change * @vtbl_rec: new volume table record * * This function changes volume table record @idx. If @vtbl_rec is %NULL, empty * volume table record is written. The caller does not have to calculate CRC of * the record as it is done by this function. Returns zero in case of success * and a negative error code in case of failure. */int ubi_change_vtbl_record(struct ubi_device *ubi, int idx,			   struct ubi_vtbl_record *vtbl_rec){	int i, err;	uint32_t crc;	struct ubi_volume *layout_vol;	ubi_assert(idx >= 0 && idx < ubi->vtbl_slots);	layout_vol = ubi->volumes[vol_id2idx(ubi, UBI_LAYOUT_VOLUME_ID)];	if (!vtbl_rec)		vtbl_rec = &empty_vtbl_record;	else {		crc = crc32(UBI_CRC32_INIT, vtbl_rec, UBI_VTBL_RECORD_SIZE_CRC);		vtbl_rec->crc = cpu_to_be32(crc);	}	memcpy(&ubi->vtbl[idx], vtbl_rec, sizeof(struct ubi_vtbl_record));	for (i = 0; i < UBI_LAYOUT_VOLUME_EBS; i++) {		err = ubi_eba_unmap_leb(ubi, layout_vol, i);		if (err)			return err;#ifdef CONFIG_PWR_LOSS_MTK_SPOH        if(i==0)        {            PL_RESET_ON_CASE("NAND", "CreateVol_1");        }        else if(i==1)        {            PL_RESET_ON_CASE("NAND", "CreateVol_2");        }#endif		err = ubi_eba_write_leb(ubi, layout_vol, i, ubi->vtbl, 0,					ubi->vtbl_size);		if (err)			return err;	}	paranoid_vtbl_check(ubi);	return 0;}

/** * set_update_marker - set update marker. * @ubi: UBI device description object * @vol: volume description object * * This function sets the update marker flag for volume @vol. Returns zero * in case of success and a negative error code in case of failure. */static int set_update_marker(struct ubi_device *ubi, struct ubi_volume *vol){	int err;	struct ubi_vtbl_record vtbl_rec;	dbg_gen("set update marker for volume %d", vol->vol_id);	if (vol->upd_marker) {		ubi_assert(ubi->vtbl[vol->vol_id].upd_marker);		dbg_gen("already set");		return 0;	}	vtbl_rec = ubi->vtbl[vol->vol_id];	vtbl_rec.upd_marker = 1;	err = ubi_change_vtbl_record(ubi, vol->vol_id, &vtbl_rec);	vol->upd_marker = 1;	return err;}

/** * ubi_io_mark_bad - mark a physical eraseblock as bad. * @ubi: UBI device description object * @pnum: the physical eraseblock number to mark * * This function returns zero in case of success and a negative error code in * case of failure. */int ubi_io_mark_bad(const struct ubi_device *ubi, int pnum){	int err;	struct mtd_info *mtd = ubi->mtd;	ubi_assert(pnum >= 0 && pnum < ubi->peb_count);	if (ubi->ro_mode) {		ubi_err(ubi, "read-only mode");		return -EROFS;	}	if (!ubi->bad_allowed)		return 0;	err = mtd_block_markbad(mtd, (loff_t)pnum * ubi->peb_size);	if (err)		ubi_err(ubi, "cannot mark PEB %d bad, error %d", pnum, err);	return err;}

/** * ubi_io_is_bad - check if a physical eraseblock is bad. * @ubi: UBI device description object * @pnum: the physical eraseblock number to check * * This function returns a positive number if the physical eraseblock is bad, * zero if not, and a negative error code if an error occurred. */int ubi_io_is_bad(const struct ubi_device *ubi, int pnum){	struct mtd_info *mtd = ubi->mtd;	ubi_assert(pnum >= 0 && pnum < ubi->peb_count);	if (ubi->bad_allowed) {		int ret;		ret = mtd_block_isbad(mtd, (loff_t)pnum * ubi->peb_size);		if (ret < 0)			ubi_err(ubi, "error %d while checking if PEB %d is bad",				ret, pnum);		else if (ret)			dbg_io("PEB %d is bad", pnum);		return ret;	}	return 0;}

/** * ubi_more_leb_change_data - accept more data for atomic LEB change. * @ubi: UBI device description object * @vol: volume description object * @buf: write data (user-space memory buffer) * @count: how much bytes to write * * This function accepts more data to the volume which is being under the * "atomic LEB change" operation. It may be called arbitrary number of times * until all data arrives. This function returns %0 in case of success, number * of bytes written during the last call if the whole "atomic LEB change" * operation has been successfully finished, and a negative error code in case * of failure. */int ubi_more_leb_change_data(struct ubi_device *ubi, struct ubi_volume *vol,			     const void __user *buf, int count){	int err;	dbg_gen("write %d of %lld bytes, %lld already passed",		count, vol->upd_bytes, vol->upd_received);	if (ubi->ro_mode)		return -EROFS;	if (vol->upd_received + count > vol->upd_bytes)		count = vol->upd_bytes - vol->upd_received;	err = copy_from_user(vol->upd_buf + vol->upd_received, buf, count);	if (err)		return -EFAULT;	vol->upd_received += count;	if (vol->upd_received == vol->upd_bytes) {		int len = ALIGN((int)vol->upd_bytes, ubi->min_io_size);		memset(vol->upd_buf + vol->upd_bytes, 0xFF,		       len - vol->upd_bytes);		len = ubi_calc_data_len(ubi, vol->upd_buf, len);		err = ubi_eba_atomic_leb_change(ubi, vol, vol->ch_lnum,						vol->upd_buf, len);		if (err)			return err;	}	ubi_assert(vol->upd_received <= vol->upd_bytes);	if (vol->upd_received == vol->upd_bytes) {		vol->changing_leb = 0;		err = count;		vfree(vol->upd_buf);	}	return err;}