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

/** * validate_ec_hdr - validate an erase counter header. * @ubi: UBI device description object * @ec_hdr: the erase counter header to check * * This function returns zero if the erase counter header is OK, and %1 if * not. */static int validate_ec_hdr(const struct ubi_device *ubi,			   const struct ubi_ec_hdr *ec_hdr){	long long ec;	int vid_hdr_offset, leb_start;	ec = be64_to_cpu(ec_hdr->ec);	vid_hdr_offset = be32_to_cpu(ec_hdr->vid_hdr_offset);	leb_start = be32_to_cpu(ec_hdr->data_offset);	if (ec_hdr->version != UBI_VERSION) {		ubi_err("node with incompatible UBI version found: "			"this UBI version is %d, image version is %d",			UBI_VERSION, (int)ec_hdr->version);		goto bad;	}	if (vid_hdr_offset != ubi->vid_hdr_offset) {		ubi_err("bad VID header offset %d, expected %d",			vid_hdr_offset, ubi->vid_hdr_offset);		goto bad;	}	if (leb_start != ubi->leb_start) {		ubi_err("bad data offset %d, expected %d",			leb_start, ubi->leb_start);		goto bad;	}	if (ec < 0 || ec > UBI_MAX_ERASECOUNTER) {		ubi_err("bad erase counter %lld", ec);		goto bad;	}	return 0;bad:	ubi_err("bad EC header");	ubi_dbg_dump_ec_hdr(ec_hdr);	ubi_dbg_dump_stack();	return 1;}

intsysfs_read_data(const char *file, void *buf, int len){	int fd;	ssize_t rd;	fd = open(file, O_RDONLY);	if (fd == -1) {		ubi_err("cannot open file %s", file);		return -1;	}	rd = read(fd, buf, len);	if (rd == -1)		ubi_err("cannot read file %s", file);	close(fd);	return rd;}

/** * 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_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;	}	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("cannot remove volume %d, error %d", vol_id, err);	ubi->volumes[vol_id] = vol;out_unlock:	return err;}

/** * uif_init - initialize user interfaces for an UBI device. * @ubi: UBI device description object * @ref: set to %1 on exit in case of failure if a reference to @ubi->dev was *       taken, otherwise set to %0 * * This function initializes various user interfaces for an UBI device. If the * initialization fails at an early stage, this function frees all the * resources it allocated, returns an error, and @ref is set to %0. However, * if the initialization fails after the UBI device was registered in the * driver core subsystem, this function takes a reference to @ubi->dev, because * otherwise the release function ('dev_release()') would free whole @ubi * object. The @ref argument is set to %1 in this case. The caller has to put * this reference. * * This function returns zero in case of success and a negative error code in * case of failure. */static int uif_init(struct ubi_device *ubi, int *ref){	int i, err;	*ref = 0;	sprintf(ubi->ubi_name, UBI_NAME_STR "%d", ubi->ubi_num);	sprintf(ubi->dev.name, "ubi");	ubi->dev.id = DEVICE_ID_DYNAMIC;	ubi->dev.parent = &ubi->mtd->class_dev;	err = register_device(&ubi->dev);	if (err)		goto out_unreg;	err = ubi_cdev_add(ubi);	if (err) {		ubi_err("cannot add character device");		goto out_dev;	}	for (i = 0; i < ubi->vtbl_slots; i++)		if (ubi->volumes[i]) {			err = ubi_add_volume(ubi, ubi->volumes[i]);			if (err) {				ubi_err("cannot add volume %d", i);				goto out_volumes;			}		}	return 0;out_volumes:	kill_volumes(ubi);	devfs_remove(&ubi->cdev);out_dev:	unregister_device(&ubi->dev);out_unreg:	ubi_err("cannot initialize UBI %s, error %d", ubi->ubi_name, err);	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;	/*	 * 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;	}	err = ubi_io_read_vid_hdr(ubi, pnum, &vid_hdr, 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;}

/** * 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;}

/** * paranoid_check_not_bad - ensure that a physical eraseblock is not bad. * @ubi: UBI device description object * @pnum: physical eraseblock number to check * * This function returns zero if the physical eraseblock is good, %-EINVAL if * it is bad and a negative error code if an error occurred. */static int paranoid_check_not_bad(const struct ubi_device *ubi, int pnum){	int err;	err = ubi_io_is_bad(ubi, pnum);	if (!err)		return err;	ubi_err("paranoid check failed for PEB %d", pnum);	ubi_dbg_dump_stack();	return err > 0 ? -EINVAL : err;}

static int ubi_remove_vol(char *volume){	int err, reserved_pebs, i;	struct ubi_volume *vol;	vol = ubi_find_volume(volume);	if (vol == NULL)		return ENODEV;	printf("Remove UBI volume %s (id %d)/n", vol->name, vol->vol_id);	if (ubi->ro_mode) {		printf("It's read-only mode/n");		err = EROFS;		goto out_err;	}	err = ubi_change_vtbl_record(ubi, vol->vol_id, NULL);	if (err) {		printf("Error changing Vol tabel record err=%x/n", err);		goto out_err;	}	reserved_pebs = vol->reserved_pebs;	for (i = 0; i < vol->reserved_pebs; i++) {		err = ubi_eba_unmap_leb(ubi, vol, i);		if (err)			goto out_err;	}	kfree(vol->eba_tbl);	ubi->volumes[vol->vol_id]->eba_tbl = NULL;	ubi->volumes[vol->vol_id] = NULL;	ubi->rsvd_pebs -= reserved_pebs;	ubi->avail_pebs += reserved_pebs;	i = ubi->beb_rsvd_level - ubi->beb_rsvd_pebs;	if (i > 0) {		i = ubi->avail_pebs >= i ? i : ubi->avail_pebs;		ubi->avail_pebs -= i;		ubi->rsvd_pebs += i;		ubi->beb_rsvd_pebs += i;		if (i > 0)			ubi_msg("reserve more %d PEBs", i);	}	ubi->vol_count -= 1;	return 0;out_err:	ubi_err(ubi, "cannot remove volume %s, error %d", volume, err);	if (err < 0)		err = -err;	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_debugfs_init - create UBI debugfs directory. * * Create UBI debugfs directory. Returns zero in case of success and a negative * error code in case of failure. */int ubi_debugfs_init(void){	dfs_rootdir = debugfs_create_dir("ubi", NULL);	if (IS_ERR_OR_NULL(dfs_rootdir)) {		int err = dfs_rootdir ? -ENODEV : PTR_ERR(dfs_rootdir);		ubi_err("cannot create /"ubi/" debugfs directory, error %d/n",			err);		return err;	}	return 0;}

/** * validate_vid_hdr - check volume identifier header. * @vid_hdr: the volume identifier header to check * @sv: information about the volume this logical eraseblock belongs to * @pnum: physical eraseblock number the VID header came from * * This function checks that data stored in @vid_hdr is consistent. Returns * non-zero if an inconsistency was found and zero if not. * * Note, UBI does sanity check of everything it reads from the flash media. * Most of the checks are done in the I/O sub-system. Here we check that the * information in the VID header is consistent to the information in other VID * headers of the same volume. */static int validate_vid_hdr(const struct ubi_vid_hdr *vid_hdr,			    const struct ubi_scan_volume *sv, int pnum){	int vol_type = vid_hdr->vol_type;	int vol_id = be32_to_cpu(vid_hdr->vol_id);	int used_ebs = be32_to_cpu(vid_hdr->used_ebs);	int data_pad = be32_to_cpu(vid_hdr->data_pad);	if (sv->leb_count != 0) {		int sv_vol_type;		/*		 * This is not the first logical eraseblock belonging to this		 * volume. Ensure that the data in its VID header is consistent		 * to the data in previous logical eraseblock headers.		 */		if (vol_id != sv->vol_id) {			dbg_err("inconsistent vol_id");			goto bad;		}		if (sv->vol_type == UBI_STATIC_VOLUME)			sv_vol_type = UBI_VID_STATIC;		else			sv_vol_type = UBI_VID_DYNAMIC;		if (vol_type != sv_vol_type) {			dbg_err("inconsistent vol_type");			goto bad;		}		if (used_ebs != sv->used_ebs) {			dbg_err("inconsistent used_ebs");			goto bad;		}		if (data_pad != sv->data_pad) {			dbg_err("inconsistent data_pad");			goto bad;		}	}	return 0;bad:	ubi_err("inconsistent VID header at PEB %d", pnum);	ubi_dbg_dump_vid_hdr(vid_hdr);	ubi_dbg_dump_sv(sv);	return -EINVAL;}

/** * 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;	if (!ubi->dbg->chk_io)		return 0;	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 && !mtd_is_eccerr(err))		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 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;}

/** * self_check_not_bad - ensure that a physical eraseblock is not bad. * @ubi: UBI device description object * @pnum: physical eraseblock number to check * * This function returns zero if the physical eraseblock is good, %-EINVAL if * it is bad and a negative error code if an error occurred. */static int self_check_not_bad(const struct ubi_device *ubi, int pnum){	int err;	if (!ubi_dbg_chk_io(ubi))		return 0;	err = ubi_io_is_bad(ubi, pnum);	if (!err)		return err;	ubi_err(ubi, "self-check failed for PEB %d", pnum);	dump_stack();	return err > 0 ? -EINVAL : err;}

/** * paranoid_check_all_ff - check that a region of flash is empty. * @ubi: UBI device description object * @pnum: the physical eraseblock number to check * @offset: the starting offset within the physical eraseblock to check * @len: the length of the region to check * * This function returns zero if only 0xFF bytes are present at offset * @offset of the physical eraseblock @pnum, %1 if not, and a negative error * code if an error occurred. */static int paranoid_check_all_ff(struct ubi_device *ubi, int pnum, int offset,				 int len){	size_t read;	int err;	loff_t addr = (loff_t)pnum * ubi->peb_size + offset;	mutex_lock(&ubi->dbg_buf_mutex);	err = ubi->mtd->read(ubi->mtd, addr, len, &read, ubi->dbg_peb_buf);	if (err && err != -EUCLEAN) {		ubi_err("error %d while reading %d bytes from PEB %d:%d, "			"read %zd bytes", err, len, pnum, offset, read);		goto error;	}	err = check_pattern(ubi->dbg_peb_buf, 0xFF, len);	if (err == 0) {		ubi_err("flash region at PEB %d:%d, length %d does not "			"contain all 0xFF bytes", pnum, offset, len);		goto fail;	}	mutex_unlock(&ubi->dbg_buf_mutex);	return 0;fail:	ubi_err("paranoid check failed for PEB %d", pnum);	dbg_msg("hex dump of the %d-%d region", offset, offset + len);	print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1,		       ubi->dbg_peb_buf, len, 1);	err = 1;error:	ubi_dbg_dump_stack();	mutex_unlock(&ubi->dbg_buf_mutex);	return err;}

/* 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;}

/** * ubi_debugfs_init - create UBI debugfs directory. * * Create UBI debugfs directory. Returns zero in case of success and a negative * error code in case of failure. */int ubi_debugfs_init(void){	if (!IS_ENABLED(CONFIG_DEBUG_FS))		return 0;	dfs_rootdir = debugfs_create_dir("ubi", NULL);	if (IS_ERR_OR_NULL(dfs_rootdir)) {		int err = dfs_rootdir ? -ENODEV : PTR_ERR(dfs_rootdir);		ubi_err(UBI_MAX_DEVICES, "cannot create /"ubi/" debugfs directory, error %d/n",			err);		return err;	}	return 0;}

/** * ubi_volume_notify - send a volume change notification. * @ubi: UBI device description object * @vol: volume description object of the changed volume * @ntype: notification type to send (%UBI_VOLUME_ADDED, etc) * * This is a helper function which notifies all subscribers about a volume * change event (creation, removal, re-sizing, re-naming, updating). Returns * zero in case of success and a negative error code in case of failure. */int ubi_volume_notify(struct ubi_device *ubi, struct ubi_volume *vol, int ntype){#ifdef CONFIG_MTD_UBI_FASTMAP	switch (ntype) {	case UBI_VOLUME_ADDED:	case UBI_VOLUME_REMOVED:	case UBI_VOLUME_RESIZED:	case UBI_VOLUME_RENAMED:		if (ubi_update_fastmap(ubi)) {			ubi_err("Unable to update fastmap!");			ubi_ro_mode(ubi);		}	}#endif	return 0;}

/** * ubi_add_volume - add volume. * @ubi: UBI device description object * @vol: volume description object * * This function adds an existing volume and initializes all its data * structures. Returns zero in case of success and a negative error code in * case of failure. */int ubi_add_volume(struct ubi_device *ubi, struct ubi_volume *vol){	int err = 0;	dbg_gen("add volume");	/* Register character device for the volume */	err = ubi_volume_cdev_add(ubi, vol);	if (err) {		ubi_err("cannot add character device for volume, error %d",			err);		return err;	}	self_check_volumes(ubi);	return err;	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, err1;	size_t written;	loff_t addr;	uint32_t data = 0;	struct ubi_vid_hdr vid_hdr;	addr = (loff_t)pnum * ubi->peb_size + ubi->vid_hdr_aloffset;	err = ubi->mtd->write(ubi->mtd, addr, 4, &written, (void *)&data);	if (!err) {		addr -= ubi->vid_hdr_aloffset;		err = ubi->mtd->write(ubi->mtd, addr, 4, &written,				      (void *)&data);		if (!err)			return 0;	}	/*	 * We failed to write to the media. This was observed with Spansion	 * S29GL512N NOR flash. Most probably the eraseblock erasure was	 * interrupted at a very inappropriate moment, so it became unwritable.	 * In this case we probably anyway have garbage in this PEB.	 */	err1 = ubi_io_read_vid_hdr(ubi, pnum, &vid_hdr, 0);	if (err1 == UBI_IO_BAD_VID_HDR)		/*		 * The VID header is corrupted, so we can safely erase this		 * PEB and not afraid that it will be treated as a valid PEB in		 * case of an unclean reboot.		 */		return 0;	/*	 * The PEB contains a valid VID header, but we cannot invalidate it.	 * Supposedly the flash media or the driver is screwed up, so return an	 * error.	 */	ubi_err("cannot invalidate PEB %d, write returned %d read returned %d",		pnum, err, err1);	ubi_dbg_dump_flash(ubi, pnum, 0, ubi->peb_size);	return -EIO;}

static ssize_t ubi_volume_cdev_read(struct cdev *cdev, void *buf, size_t size,		loff_t offset, unsigned long flags){	struct ubi_volume_cdev_priv *priv = cdev->priv;	struct ubi_volume *vol = priv->vol;	struct ubi_device *ubi = priv->ubi;	int err, lnum, off, len;	size_t count_save = size;	unsigned long long tmp;	loff_t offp = offset;	int usable_leb_size = vol->usable_leb_size;	ubi_debug("%s: %zd @ 0x%08llx", __func__, size, offset);	len = size > usable_leb_size ? usable_leb_size : size;	tmp = offp;	off = do_div(tmp, usable_leb_size);	lnum = tmp;	do {		if (off + len >= usable_leb_size)			len = usable_leb_size - off;		err = ubi_eba_read_leb(ubi, vol, lnum, buf, off, len, 0);		if (err) {			ubi_err(ubi, "read error: %s", strerror(-err));			break;		}		off += len;		if (off == usable_leb_size) {			lnum += 1;			off -= usable_leb_size;		}		size -= len;		offp += len;		buf += len;		len = size > usable_leb_size ? usable_leb_size : size;	} while (size);	return count_save;}

/** * 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;}

/** * 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;}

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_create_gluebi - initialize gluebi for an UBI volume. * @ubi: UBI device description object * @vol: volume description object * * This function is called when an UBI volume is created in order to create * corresponding fake MTD device. Returns zero in case of success and a * negative error code in case of failure. */int ubi_create_gluebi(struct ubi_device *ubi, struct ubi_volume *vol){	struct mtd_info *mtd = &vol->gluebi_mtd;	mtd->name = kmemdup(vol->name, vol->name_len + 1, GFP_KERNEL);	if (!mtd->name)		return -ENOMEM;	mtd->type = MTD_UBIVOLUME;	if (!ubi->ro_mode)		mtd->flags = MTD_WRITEABLE;	mtd->writesize  = ubi->min_io_size;	mtd->owner      = THIS_MODULE;	mtd->erasesize  = vol->usable_leb_size;	mtd->read       = gluebi_read;	mtd->write      = gluebi_write;	mtd->erase      = gluebi_erase;	mtd->get_device = gluebi_get_device;	mtd->put_device = gluebi_put_device;	/*	 * In case of dynamic volume, MTD device size is just volume size. In	 * case of a static volume the size is equivalent to the amount of data	 * bytes.	 */	if (vol->vol_type == UBI_DYNAMIC_VOLUME)		mtd->size = (long long)vol->usable_leb_size * vol->reserved_pebs;	else		mtd->size = vol->used_bytes;	if (add_mtd_device(mtd)) {		ubi_err("cannot not add MTD device");		kfree(mtd->name);		return -ENFILE;	}	dbg_gen("added mtd%d (/"%s/"), size %llu, EB size %u",		mtd->index, mtd->name, (unsigned long long)mtd->size, mtd->erasesize);	return 0;}

/** * do_work - do one pending work. * @ubi: UBI device description object * * This function returns zero in case of success and a negative error code in * case of failure. */static int do_work(struct ubi_device *ubi){	int err;	struct ubi_work *wrk;	cond_resched();	/*	 * @ubi->work_sem is used to synchronize with the workers. Workers take	 * it in read mode, so many of them may be doing works at a time. But	 * the queue flush code has to be sure the whole queue of works is	 * done, and it takes the mutex in write mode.	 */	down_read(&ubi->work_sem);	spin_lock(&ubi->wl_lock);	if (list_empty(&ubi->works)) {		spin_unlock(&ubi->wl_lock);		up_read(&ubi->work_sem);		return 0;	}	wrk = list_entry(ubi->works.next, struct ubi_work, list);	list_del(&wrk->list);	ubi->works_count -= 1;	ubi_assert(ubi->works_count >= 0);	spin_unlock(&ubi->wl_lock);	/*	 * Call the worker function. Do not touch the work structure	 * after this call as it will have been freed or reused by that	 * time by the worker function.	 */	err = wrk->func(ubi, wrk, 0);	if (err)		ubi_err(ubi, "work failed with error code %d", err);	up_read(&ubi->work_sem);	return err;}

/** * ubi_dbg_dump_flash - dump a region of flash. * @ubi: UBI device description object * @pnum: the physical eraseblock number to dump * @offset: the starting offset within the physical eraseblock to dump * @len: the length of the region to dump */void ubi_dbg_dump_flash(struct ubi_device *ubi, int pnum, int offset, int len){	int err;	size_t read;	void *buf;	loff_t addr = (loff_t)pnum * ubi->peb_size + offset;	buf = vmalloc(len);	if (!buf)		return;	err = ubi->mtd->read(ubi->mtd, addr, len, &read, buf);	if (err && err != -EUCLEAN) {		ubi_err("error %d while reading %d bytes from PEB %d:%d, "			"read %zd bytes", err, len, pnum, offset, read);		goto out;	}	dbg_msg("dumping %d bytes of data from PEB %d, offset %d",		len, pnum, offset);	print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1, buf, len, 1);out:	vfree(buf);	return;}

/** * ubi_scan_add_used - add physical eraseblock to the scanning information. * @ubi: UBI device description object * @si: scanning information * @pnum: the physical eraseblock number * @ec: erase counter * @vid_hdr: the volume identifier header * @bitflips: if bit-flips were detected when this physical eraseblock was read * * This function adds information about a used physical eraseblock to the * 'used' tree of the corresponding volume. The function is rather complex * because it has to handle cases when this is not the first physical * eraseblock belonging to the same logical eraseblock, and the newer one has * to be picked, while the older one has to be dropped. This function returns * zero in case of success and a negative error code in case of failure. */int ubi_scan_add_used(struct ubi_device *ubi, struct ubi_scan_info *si,		      int pnum, int ec, const struct ubi_vid_hdr *vid_hdr,		      int bitflips){	int err, vol_id, lnum;	unsigned long long sqnum;	struct ubi_scan_volume *sv;	struct ubi_scan_leb *seb;	struct rb_node **p, *parent = NULL;	vol_id = be32_to_cpu(vid_hdr->vol_id);	lnum = be32_to_cpu(vid_hdr->lnum);	sqnum = be64_to_cpu(vid_hdr->sqnum);	dbg_bld("PEB %d, LEB %d:%d, EC %d, sqnum %llu, bitflips %d",		pnum, vol_id, lnum, ec, sqnum, bitflips);	sv = add_volume(si, vol_id, pnum, vid_hdr);	if (IS_ERR(sv))		return PTR_ERR(sv);	if (si->max_sqnum < sqnum)		si->max_sqnum = sqnum;	/*	 * Walk the RB-tree of logical eraseblocks of volume @vol_id to look	 * if this is the first instance of this logical eraseblock or not.	 */	p = &sv->root.rb_node;	while (*p) {		int cmp_res;		parent = *p;		seb = rb_entry(parent, struct ubi_scan_leb, u.rb);		if (lnum != seb->lnum) {			if (lnum < seb->lnum)				p = &(*p)->rb_left;			else				p = &(*p)->rb_right;			continue;		}		/*		 * There is already a physical eraseblock describing the same		 * logical eraseblock present.		 */		dbg_bld("this LEB already exists: PEB %d, sqnum %llu, "			"EC %d", seb->pnum, seb->sqnum, seb->ec);		/*		 * Make sure that the logical eraseblocks have different		 * sequence numbers. Otherwise the image is bad.		 *		 * However, if the sequence number is zero, we assume it must		 * be an ancient UBI image from the era when UBI did not have		 * sequence numbers. We still can attach these images, unless		 * there is a need to distinguish between old and new		 * eraseblocks, in which case we'll refuse the image in		 * 'compare_lebs()'. In other words, we attach old clean		 * images, but refuse attaching old images with duplicated		 * logical eraseblocks because there was an unclean reboot.		 */		if (seb->sqnum == sqnum && sqnum != 0) {			ubi_err("two LEBs with same sequence number %llu",				sqnum);			ubi_dbg_dump_seb(seb, 0);			ubi_dbg_dump_vid_hdr(vid_hdr);			return -EINVAL;		}		/*		 * Now we have to drop the older one and preserve the newer		 * one.		 */		cmp_res = compare_lebs(ubi, seb, pnum, vid_hdr);		if (cmp_res < 0)			return cmp_res;		if (cmp_res & 1) {			/*			 * This logical eraseblock is newer than the one			 * found earlier.			 *///.........这里部分代码省略.........

/** * compare_lebs - find out which logical eraseblock is newer. * @ubi: UBI device description object * @seb: first logical eraseblock to compare * @pnum: physical eraseblock number of the second logical eraseblock to * compare * @vid_hdr: volume identifier header of the second logical eraseblock * * This function compares 2 copies of a LEB and informs which one is newer. In * case of success this function returns a positive value, in case of failure, a * negative error code is returned. The success return codes use the following * bits: *     o bit 0 is cleared: the first PEB (described by @seb) is newer than the *       second PEB (described by @pnum and @vid_hdr); *     o bit 0 is set: the second PEB is newer; *     o bit 1 is cleared: no bit-flips were detected in the newer LEB; *     o bit 1 is set: bit-flips were detected in the newer LEB; *     o bit 2 is cleared: the older LEB is not corrupted; *     o bit 2 is set: the older LEB is corrupted. */static int compare_lebs(struct ubi_device *ubi, const struct ubi_scan_leb *seb,			int pnum, const struct ubi_vid_hdr *vid_hdr){	void *buf;	int len, err, second_is_newer, bitflips = 0, corrupted = 0;	uint32_t data_crc, crc;	struct ubi_vid_hdr *vh = NULL;	unsigned long long sqnum2 = be64_to_cpu(vid_hdr->sqnum);	if (sqnum2 == seb->sqnum) {		/*		 * This must be a really ancient UBI image which has been		 * created before sequence numbers support has been added. At		 * that times we used 32-bit LEB versions stored in logical		 * eraseblocks. That was before UBI got into mainline. We do not		 * support these images anymore. Well, those images still work,		 * but only if no unclean reboots happened.		 */		ubi_err("unsupported on-flash UBI format/n");		return -EINVAL;	}	/* Obviously the LEB with lower sequence counter is older */	second_is_newer = !!(sqnum2 > seb->sqnum);	/*	 * Now we know which copy is newer. If the copy flag of the PEB with	 * newer version is not set, then we just return, otherwise we have to	 * check data CRC. For the second PEB we already have the VID header,	 * for the first one - we'll need to re-read it from flash.	 *	 * Note: this may be optimized so that we wouldn't read twice.	 */	if (second_is_newer) {		if (!vid_hdr->copy_flag) {			/* It is not a copy, so it is newer */			dbg_bld("second PEB %d is newer, copy_flag is unset",				pnum);			return 1;		}	} else {		if (!seb->copy_flag) {			/* It is not a copy, so it is newer */			dbg_bld("first PEB %d is newer, copy_flag is unset",				pnum);			return bitflips << 1;		}		vh = ubi_zalloc_vid_hdr(ubi, GFP_KERNEL);		if (!vh)			return -ENOMEM;		pnum = seb->pnum;		err = ubi_io_read_vid_hdr(ubi, pnum, vh, 0);		if (err) {			if (err == UBI_IO_BITFLIPS)				bitflips = 1;			else {				dbg_err("VID of PEB %d header is bad, but it "					"was OK earlier, err %d", pnum, err);				if (err > 0)					err = -EIO;				goto out_free_vidh;			}		}		vid_hdr = vh;	}	/* Read the data of the copy and check the CRC */	len = be32_to_cpu(vid_hdr->data_size);	buf = vmalloc(len);	if (!buf) {		err = -ENOMEM;		goto out_free_vidh;	}//.........这里部分代码省略.........