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

static int do_ubiformat(int argc, char *argv[]){	int err, fd;	struct ubiformat_args args;	char *node = NULL;	struct mtd_info_user mtd_user;	err = parse_opt(argc, argv, &args, &node);	if (err)		return err;	fd = open(node, O_RDWR);	if (fd < 0)		return sys_errmsg("cannot open /"%s/"", node);	err = ioctl(fd, MEMGETINFO, &mtd_user);	if (err) {		sys_errmsg("MEMGETINFO ioctl request failed");		goto out_close;	}	err = ubiformat(mtd_user.mtd, &args);out_close:	close(fd);	return err;}

static int open_file(off_t *sz){	int fd;	if (!strcmp(args.image, "-")) {		if (args.image_sz == 0)			return errmsg("must use '-S' with non-zero value when reading from stdin");		*sz = args.image_sz;		fd  = dup(STDIN_FILENO);		if (fd < 0)			return sys_errmsg("failed to dup stdin");	} else {		struct stat st;		if (stat(args.image, &st))			return sys_errmsg("cannot open /"%s/"", args.image);		*sz = st.st_size;		fd  = open(args.image, O_RDONLY);		if (fd == -1)			return sys_errmsg("cannot open /"%s/"", args.image);	}	return fd;}

int legacy_get_mtd_oobavail(const char *node){	struct stat st;	struct nand_ecclayout_user usrlay;	int fd, ret;	if (stat(node, &st))		return sys_errmsg("cannot open /"%s/"", node);	if (!S_ISCHR(st.st_mode)) {		errno = EINVAL;		return errmsg("/"%s/" is not a character device", node);	}	fd = open(node, O_RDONLY);	if (fd == -1)		return sys_errmsg("cannot open /"%s/"", node);	ret = ioctl(fd, ECCGETLAYOUT, &usrlay);	if (ret < 0) {		if (errno == EOPNOTSUPP)			goto out_close;		sys_errmsg("ECCGETLAYOUT ioctl request failed");		goto out_close;	}	ret = usrlay.oobavail;out_close:	close(fd);	return ret;}

int mtd_read(const struct mtd_dev_info *mtd, int fd, int eb, int offs,	     void *buf, int len){	int ret, rd = 0;	off_t seek;	if (eb < 0 || eb >= mtd->eb_cnt) {		errmsg("bad eraseblock number %d, mtd%d has %d eraseblocks",		       eb, mtd->dev_num, mtd->eb_cnt);		errno = EINVAL;		return -1;	}	if (offs < 0 || offs + len > mtd->eb_size) {		errmsg("bad offset %d or length %d, mtd%d eraseblock size is %d",		       offs, len, mtd->dev_num, mtd->eb_size);		errno = EINVAL;		return -1;	}	/* Seek to the beginning of the eraseblock */	seek = (off_t)eb * mtd->eb_size + offs;	if (lseek(fd, seek, SEEK_SET) != seek)		return sys_errmsg("cannot seek mtd%d to offset %llu",				  mtd->dev_num, (unsigned long long)seek);	while (rd < len) {		ret = read(fd, buf, len);		if (ret < 0)			return sys_errmsg("cannot read %d bytes from mtd%d (eraseblock %d, offset %d)",					  len, mtd->dev_num, eb, offs);		rd += ret;	}	return 0;}

static void print_region_map(const struct mtd_dev_info *mtd, int fd,			     const region_info_t *reginfo){	unsigned long start;	int i, width;	int ret_locked, errno_locked, ret_bad, errno_bad;	printf("Eraseblock map:/n");	/* Figure out the number of spaces to pad w/out libm */	for (i = 1, width = 0; i < reginfo->numblocks; i *= 10, ++width)		continue;	/* If we don't have a fd to query, just show the bare map */	if (fd == -1) {		ret_locked = ret_bad = -1;		errno_locked = errno_bad = ENODEV;	} else		ret_locked = ret_bad = errno_locked = errno_bad = 0;	for (i = 0; i < reginfo->numblocks; ++i) {		start = reginfo->offset + i * reginfo->erasesize;		printf(" %*i: %08lx ", width, i, start);		if (ret_locked != -1) {			ret_locked = mtd_is_locked(mtd, fd, i);			if (ret_locked == 1)				printf("RO ");			else				errno_locked = errno;		}		if (ret_locked != 1)			printf("   ");		if (ret_bad != -1) {			ret_bad = mtd_is_bad(mtd, fd, i);			if (ret_bad == 1)				printf("BAD ");			else				errno_bad = errno;		}		if (ret_bad != 1)			printf("    ");		if (((i + 1) % 4) == 0)			printf("/n");	}	if (i % 4)		printf("/n");	if (ret_locked == -1 && errno_locked != EOPNOTSUPP) {		errno = errno_locked;		sys_errmsg("could not read locked block info");	}	if (mtd->bb_allowed && ret_bad == -1 && errno_bad != EOPNOTSUPP) {		errno = errno_bad;		sys_errmsg("could not read bad block info");	}}

/** * refill_wl_pool - refills all the fastmap pool used by the * WL sub-system and ubi_wl_get_peb. * @ubi: UBI device description object */static void ubi_refill_pools(struct ubigen_info *ui, int fd){        struct ubi_fm_pool *pool = &ui->fm_wl_pool;	int start = ui->used_peb;	off_t seek;	char *outbuf;	outbuf = malloc(ui->peb_size);	memset(outbuf, 0xFF, ui->peb_size);	ubigen_init_ec_hdr(ui, (struct ubi_ec_hdr *)outbuf, ui->ec);        printf("Start PEB %d for wl pool size %d/n", start, pool->max_size);        for (pool->size = 0; pool->size < pool->max_size; pool->size++) {                if (ui->peb_count - start < 5)                        break;		seek = start * ui->peb_size;		if (lseek(fd, seek, SEEK_SET) != seek) {			sys_errmsg("cannot seek output file");			break;		}		if (write(fd, outbuf, ui->peb_size) != ui->peb_size) {			sys_errmsg("cannot write %d bytes to the output file", ui->peb_size);			break;		}                pool->pebs[pool->size] = start;		start++;        }        printf( "End PEB %d for wl pool/n", start-1);        printf( "found %d PEB for wl pool/n", pool->size);        pool->used = 0;        pool = &ui->fm_pool;        printf( "Start PEB %d for user wl pool size %d/n", start, pool->max_size);        for (pool->size = 0; pool->size < pool->max_size; pool->size++) {                if (ui->peb_count - start < 1)                        break;		seek = start * ui->peb_size;		if (lseek(fd, seek, SEEK_SET) != seek) {			sys_errmsg("cannot seek output file");			break;		}		if (write(fd, outbuf, ui->peb_size) != ui->peb_size) {			sys_errmsg("cannot write %d bytes to the output file", ui->peb_size);			break;		}                pool->pebs[pool->size] = start;		start++;        }        printf( "End PEB %d for user wl pool/n", start-1);        printf( "found %d PEB for wl pool/n", pool->size);        pool->used = 0;}

/** * ubigen_write_volume - write UBI volume. * @ui: libubigen information * @vi: volume information * @ec: erase coutner value to put to EC headers * @bytes: volume size in bytes * @in: input file descriptor (has to be properly seeked) * @out: output file descriptor * * This function reads the contents of the volume from the input file @in and * writes the UBI volume to the output file @out. Returns zero on success and * %-1 on failure. */int ubigen_write_volume(const struct ubigen_info *ui,			const struct ubigen_vol_info *vi, long long ec,			long long bytes, int in, int out){	int len = vi->usable_leb_size, rd, lnum = 0;	char inbuf[ui->leb_size], outbuf[ui->peb_size];	if (vi->id >= ui->max_volumes)		return errmsg("too high volume id %d, max. volumes is %d",			      vi->id, ui->max_volumes);	if (vi->alignment >= ui->leb_size)		return errmsg("too large alignment %d, max is %d (LEB size)",			      vi->alignment, ui->leb_size);	memset(outbuf, 0xFF, ui->data_offs);	ubigen_init_ec_hdr(ui, (struct ubi_ec_hdr *)outbuf, ec);	while (bytes) {		int l;		struct ubi_vid_hdr *vid_hdr;		if (bytes < len)			len = bytes;		bytes -= len;		l = len;		do {			rd = read(in, inbuf + len - l, l);			if (rd != l)				return sys_errmsg("cannot read %d bytes from the input file", l);			l -= rd;		} while (l);		vid_hdr = (struct ubi_vid_hdr *)(&outbuf[ui->vid_hdr_offs]);		init_vid_hdr(ui, vi, vid_hdr, lnum, inbuf, len);		memcpy(outbuf + ui->data_offs, inbuf, len);		memset(outbuf + ui->data_offs + len, 0xFF,		       ui->peb_size - ui->data_offs - len);		if (write(out, outbuf, ui->peb_size) != ui->peb_size)			return sys_errmsg("cannot write %d bytes to the output file", ui->peb_size);		lnum += 1;	}	return 0;}

static int open_file(off_t *sz){	int fd;	struct stat st;	if (stat(args.image, &st))		return sys_errmsg("cannot open /"%s/"", args.image);	*sz = st.st_size;	fd  = open(args.image, O_RDONLY);	if (fd < 0)		return sys_errmsg("cannot open /"%s/"", args.image);	return fd;}

/** * vol_node2nums - find UBI device number and volume ID by volume device node *                 file. * @lib: UBI library descriptor * @node: UBI character device node name * @dev_num: UBI device number is returned here * @vol_id: volume ID is returned hers * * This function returns zero in case of succes and %-1 in case of failure. */static int vol_node2nums(struct libubi *lib, const char *node, int *dev_num,			 int *vol_id){	struct stat st;	struct ubi_info info;	int i, fd, major, minor;	char file[strlen(lib->ubi_vol) + 100];	if (stat(node, &st))		return sys_errmsg("cannot get information about /"%s/"",				  node);	if (!S_ISCHR(st.st_mode)) {		errno = EINVAL;		return errmsg("/"%s/" is not a character device", node);	}	major = major(st.st_rdev);	minor = minor(st.st_rdev);	if (minor == 0) {		errno = EINVAL;		return errmsg("/"%s/" is not a volume character device", node);	}	if (ubi_get_info((libubi_t *)lib, &info))		return -1;	for (i = info.lowest_dev_num; i <= info.highest_dev_num; i++) {		int major1, minor1, ret;		ret = dev_get_major(lib, i, &major1, &minor1);		if (ret) {			if (errno == ENOENT)				continue;			return -1;		}		if (major1 == major)			break;	}	if (i > info.highest_dev_num) {		errno = ENODEV;		return -1;	}	/* Make sure this UBI volume exists */	sprintf(file, lib->ubi_vol, i, minor - 1);	fd = open(file, O_RDONLY);	if (fd == -1) {		errno = ENODEV;		return -1;	}	*dev_num = i;	*vol_id = minor - 1;	errno = 0;	return 0;}

int ubi_rmvol(libubi_t desc, const char *node, int vol_id){	int fd, ret;	desc = desc;	fd = open(node, O_RDONLY);	if (fd == -1)		return sys_errmsg("cannot open /"%s/"", node);	ret = ioctl(fd, UBI_IOCRMVOL, &vol_id);	if (ret == -1) {		close(fd);		return ret;	}	close(fd);#ifdef UDEV_SETTLE_HACK//	if (system("udevsettle") == -1)//		return -1;	usleep(100000);#endif	return 0;}

int ubi_attach_mtd(libubi_t desc, const char *node,		   struct ubi_attach_request *req){	int fd, ret;	struct ubi_attach_req r;	memset(&r, sizeof(struct ubi_attach_req), '/0');	desc = desc;	r.ubi_num = req->dev_num;	r.mtd_num = req->mtd_num;	r.vid_hdr_offset = req->vid_hdr_offset;	fd = open(node, O_RDONLY);	if (fd == -1)		return sys_errmsg("cannot open /"%s/"", node);	ret = ioctl(fd, UBI_IOCATT, &r);	close(fd);	if (ret == -1)		return -1;	req->dev_num = r.ubi_num;#ifdef UDEV_SETTLE_HACK	if (system("udevsettle") == -1)		return -1;#endif	return ret;}

static int proc_parse_start(struct proc_parse_info *pi){	int fd, ret;	fd = open(MTD_PROC_FILE, O_RDONLY);	if (fd == -1)		return -1;	pi->buf = xmalloc(PROC_MTD_MAX_LEN);	ret = read(fd, pi->buf, PROC_MTD_MAX_LEN);	if (ret == -1) {		sys_errmsg("cannot read /"%s/"", MTD_PROC_FILE);		goto out_free;	}	if (ret < PROC_MTD_FIRST_LEN ||	    memcmp(pi->buf, PROC_MTD_FIRST, PROC_MTD_FIRST_LEN)) {		errmsg("/"%s/" does not start with /"%s/"", MTD_PROC_FILE,		       PROC_MTD_FIRST);		goto out_free;	}	pi->data_size = ret;	pi->next = pi->buf + PROC_MTD_FIRST_LEN;	close(fd);	return 0;out_free:	free(pi->buf);	close(fd);	return -1;}

int main(int argc, char * const argv[]){	int err;	libmtd_t libmtd;	struct mtd_info mtd_info;	err = parse_opt(argc, argv);	if (err)		return -1;	libmtd = libmtd_open();	if (libmtd == NULL) {		if (errno == 0)			return errmsg("MTD is not present in the system");		return sys_errmsg("cannot open libmtd");	}	err = mtd_get_info(libmtd, &mtd_info);	if (err) {		if (errno == ENODEV)			return errmsg("MTD is not present");		return sys_errmsg("cannot get MTD information");	}	if (!args.all && args.node) {		int mtdn;		/*		 * A character device was specified, translate this to MTD		 * device number.		 */		mtdn = translate_dev(libmtd, args.node);		if (mtdn < 0)			goto out_libmtd;		err = print_dev_info(libmtd, &mtd_info, mtdn);	} else		err = print_general_info(libmtd, &mtd_info, args.all);	if (err)		goto out_libmtd;	libmtd_close(libmtd);	return 0;out_libmtd:	libmtd_close(libmtd);	return -1;}

int ubi_probe_node(libubi_t desc, const char *node){	struct stat st;	struct ubi_info info;	int i, fd, major, minor;	struct libubi *lib = (struct libubi *)desc;	char file[strlen(lib->ubi_vol) + 100];	if (stat(node, &st))		return sys_errmsg("cannot get information about /"%s/"", node);	if (!S_ISCHR(st.st_mode)) {		errmsg("/"%s/" is not a character device", node);		errno = EINVAL;		return -1;	}	major = major(st.st_rdev);	minor = minor(st.st_rdev);	if (ubi_get_info((libubi_t *)lib, &info))		return -1;	for (i = info.lowest_dev_num; i <= info.highest_dev_num; i++) {		int major1, minor1, ret;		ret = dev_get_major(lib, i, &major1, &minor1);		if (ret) {			if (errno == ENOENT)				continue;			if (!errno)				goto out_not_ubi;			return -1;		}		if (major1 == major)			break;	}	if (i > info.highest_dev_num)		goto out_not_ubi;	if (minor == 0)		return 1;	/* This is supposdely an UBI volume device node */	sprintf(file, lib->ubi_vol, i, minor - 1);	fd = open(file, O_RDONLY);	if (fd == -1)		goto out_not_ubi;	return 2;out_not_ubi:	errmsg("/"%s/" has major:minor %d:%d, but this does not correspond to "	       "any existing UBI device or volume", node, major, minor);	errno = ENODEV;	return -1;}

/** * read_data - read data from a file. * @file: the file to read from * @buf: the buffer to read to * @buf_len: buffer length * * This function returns number of read bytes in case of success and %-1 in * case of failure. Note, if the file contains more then @buf_len bytes of * date, this function fails with %EINVAL error code. */static int read_data(const char *file, void *buf, int buf_len){	int fd, rd, tmp, tmp1;	fd = open(file, O_RDONLY);	if (fd == -1)		return -1;	rd = read(fd, buf, buf_len);	if (rd == -1) {		sys_errmsg("cannot read /"%s/"", file);		goto out_error;	}	if (rd == buf_len) {		errmsg("contents of /"%s/" is too long", file);		errno = EINVAL;		goto out_error;	}	((char *)buf)[rd] = '/0';	/* Make sure all data is read */	tmp1 = read(fd, &tmp, 1);	if (tmp1 == 1) {		sys_errmsg("cannot read /"%s/"", file);		goto out_error;	}	if (tmp1) {		errmsg("file /"%s/" contains too much data (> %d bytes)",		       file, buf_len);		errno = EINVAL;		goto out_error;	}	if (close(fd)) {		sys_errmsg("close failed on /"%s/"", file);		return -1;	}	return rd;out_error:	close(fd);	return -1;}

int mtd_write(const struct mtd_dev_info *mtd, int fd, int eb, int offs,	      void *buf, int len){	int ret;	off_t seek;	if (eb < 0 || eb >= mtd->eb_cnt) {		errmsg("bad eraseblock number %d, mtd%d has %d eraseblocks",		       eb, mtd->dev_num, mtd->eb_cnt);		errno = EINVAL;		return -1;	}	if (offs < 0 || offs + len > mtd->eb_size) {		errmsg("bad offset %d or length %d, mtd%d eraseblock size is %d",		       offs, len, mtd->dev_num, mtd->eb_size);		errno = EINVAL;		return -1;	}	if (offs % mtd->subpage_size) {		errmsg("write offset %d is not aligned to mtd%d min. I/O size %d",		       offs, mtd->dev_num, mtd->subpage_size);		errno = EINVAL;		return -1;	}	if (len % mtd->subpage_size) {		errmsg("write length %d is not aligned to mtd%d min. I/O size %d",		       len, mtd->dev_num, mtd->subpage_size);		errno = EINVAL;		return -1;	}	/* Seek to the beginning of the eraseblock */	seek = (off_t)eb * mtd->eb_size + offs;	if (lseek(fd, seek, SEEK_SET) != seek)		return sys_errmsg("cannot seek mtd%d to offset %llu",				  mtd->dev_num, (unsigned long long)seek);	ret = write(fd, buf, len);	if (ret != len)		return sys_errmsg("cannot write %d bytes to mtd%d (eraseblock %d, offset %d)",				  len, mtd->dev_num, eb, offs);	return 0;}

/** * read_hex_ll - read a hex 'long long' value from a file. * @file: the file to read from * @value: the result is stored here * * This function reads file @file and interprets its contents as hexadecimal * 'long long' integer. If this is not true, it fails with %EINVAL error code. * Returns %0 in case of success and %-1 in case of failure. */static int read_hex_ll(const char *file, long long *value){	int fd, rd;	char buf[50];	fd = open(file, O_RDONLY);	if (fd == -1)		return -1;	rd = read(fd, buf, sizeof(buf));	if (rd == -1) {		sys_errmsg("cannot read /"%s/"", file);		goto out_error;	}	if (rd == sizeof(buf)) {		errmsg("contents of /"%s/" is too long", file);		errno = EINVAL;		goto out_error;	}	buf[rd] = '/0';	if (sscanf(buf, "%llx/n", value) != 1) {		errmsg("cannot read integer from /"%s/"/n", file);		errno = EINVAL;		goto out_error;	}	if (*value < 0) {		errmsg("negative value %lld in /"%s/"", *value, file);		errno = EINVAL;		goto out_error;	}	if (close(fd))		return sys_errmsg("close failed on /"%s/"", file);	return 0;out_error:	close(fd);	return -1;}

/** * read_positive_ll - read a positive 'long long' value from a file. * @file: the file to read from * @value: the result is stored here * * This function reads file @file and interprets its contents as a positive * 'long long' integer. If this is not true, it fails with %EINVAL error code. * Returns %0 in case of success and %-1 in case of failure. */static int read_positive_ll(const char *file, long long *value){	int fd, rd;	char buf[50];	fd = open(file, O_RDONLY);	if (fd == -1)		return -1;	rd = read(fd, buf, 50);	if (rd == -1) {		sys_errmsg("cannot read /"%s/"", file);		goto out_error;	}	if (rd == 50) {		errmsg("contents of /"%s/" is too long", file);		errno = EINVAL;		goto out_error;	}	if (sscanf(buf, "%lld/n", value) != 1) {		/* This must be a UBI bug */		errmsg("cannot read integer from /"%s/"/n", file);		errno = EINVAL;		goto out_error;	}	if (*value < 0) {		errmsg("negative value %lld in /"%s/"", *value, file);		errno = EINVAL;		goto out_error;	}	if (close(fd))		return sys_errmsg("close failed on /"%s/"", file);	return 0;out_error:	close(fd);	return -1;}

static int print_dev_info(libmtd_t libmtd, const struct mtd_info *mtd_info, int mtdn){	int err;	struct mtd_dev_info mtd;	err = mtd_get_dev_info1(libmtd, mtdn, &mtd);	if (err) {		if (errno == ENODEV)			return errmsg("mtd%d does not correspond to any "				      "existing MTD device", mtdn);		return sys_errmsg("cannot get information about MTD device %d",				  mtdn);	}	printf("mtd%d/n", mtd.mtd_num);	printf("Name:                           %s/n", mtd.name);	printf("Type:                           %s/n", mtd.type_str);	printf("Eraseblock size:                ");	ubiutils_print_bytes(mtd.eb_size, 0);	printf("/n");	printf("Amount of eraseblocks:          %d (", mtd.eb_cnt);	ubiutils_print_bytes(mtd.size, 0);	printf(")/n");	printf("Minimum input/output unit size: %d %s/n",	       mtd.min_io_size, mtd.min_io_size > 1 ? "bytes" : "byte");	if (mtd_info->sysfs_supported)		printf("Sub-page size:                  %d %s/n",		       mtd.subpage_size,		       mtd.subpage_size > 1 ? "bytes" : "byte");	else if (mtd.type == MTD_NANDFLASH || mtd.type == MTD_MLCNANDFLASH)		printf("Sub-page size:                  unknown/n");	if (mtd.oob_size > 0)		printf("OOB size:                       %d bytes/n",		       mtd.oob_size);	if (mtd.region_cnt > 0)		printf("Additional erase regions:       %d/n", mtd.oob_size);	if (mtd_info->sysfs_supported)		printf("Character device major/minor:   %d:%d/n",		       mtd.major, mtd.minor);	printf("Bad blocks are allowed:         %s/n",	       mtd.bb_allowed ? "true" : "false");	printf("Device is writable:             %s/n",	      mtd.writable ? "true" : "false");	if (args.ubinfo)		print_ubi_info(mtd_info, &mtd);	print_region_info(&mtd);	printf("/n");	return 0;}

/** * legacy_procfs_is_supported - legacy version of 'sysfs_is_supported()'. * * Check if we can access the procfs files for the MTD subsystem. */int legacy_procfs_is_supported(void){	if (access(MTD_PROC_FILE, R_OK) != 0) {		if (errno == ENOENT) {			errno = 0;		} else {			sys_errmsg("cannot read /"%s/"", MTD_PROC_FILE);		}		return 0;	}	return 1;}

/** * dev_node2num - find UBI device number by its character device node. * @lib: UBI library descriptor * @node: UBI character device node name * * This function returns positive UBI device number in case of success and %-1 * in case of failure. */static int dev_node2num(struct libubi *lib, const char *node, int *dev_num){	struct stat st;	struct ubi_info info;	int i, major, minor;	if (stat(node, &st))		return sys_errmsg("cannot get information about /"%s/"",				  node);	if (!S_ISCHR(st.st_mode)) {		errno = EINVAL;		return errmsg("/"%s/" is not a character device", node);	}	major = major(st.st_rdev);	minor = minor(st.st_rdev);	if (minor != 0) {		errno = EINVAL;		return errmsg("/"%s/" is not an UBI character device", node);	}	if (ubi_get_info((libubi_t *)lib, &info))		return -1;	for (i = info.lowest_dev_num; i <= info.highest_dev_num; i++) {		int major1, minor1, ret;		ret = dev_get_major(lib, i, &major1, &minor1);		if (ret) {			if (errno == ENOENT)				continue;			return -1;		}		if (major1 == major) {			if (minor1 != 0) {				errmsg("UBI character device minor number is "				       "%d, but must be 0", minor1);				errno = EINVAL;				return -1;			}			errno = 0;			*dev_num = i;			return 0;		}	}	errno = ENODEV;	return -1;}

int main(int argc, char * const argv[]){	int err = 0;	uint32_t crc = UBI_CRC32_INIT;	char buf[BUFSIZE];	FILE *fp;	if (argc > 1) {		fp = fopen(argv[1], "r");		if (!fp)			return sys_errmsg("cannot open /"%s/"", argv[1]);	} else		fp = stdin;	err = parse_opt(argc, argv);	if (err)		return err;	while (!feof(fp)) {		size_t read;		read = fread(buf, 1, BUFSIZE, fp);		if (ferror(fp)) {			sys_errmsg("cannot read input file");			err = -1;			goto out_close;		}		crc = crc32(crc, buf, read);	}	printf("0x%08x/n", crc);out_close:	if (fp != stdin)		fclose(fp);	return err;}

/** * mtd_node_to_num - converts device node to MTD number. * @mtd_dev_node: path to device node to convert * * This function converts given @mtd_dev_node to MTD device number. * @mtd_dev_node should contain path to the MTD device node. Returns MTD device * number in case of success and %-1 in case of failure (errno is set). */static int mtd_node_to_num(const char *mtd_dev_node){	int major_dev, minor_dev;	struct stat sb;	if (stat(mtd_dev_node, &sb) < 0)		return sys_errmsg("cannot stat /"%s/"", mtd_dev_node);	if (!S_ISCHR(sb.st_mode)) {		errno = EINVAL;		return sys_errmsg("/"%s/" is not a character device",				  mtd_dev_node);	}	major_dev = major(sb.st_rdev);	minor_dev = minor(sb.st_rdev);	if (major != MTD_CHAR_MAJOR) {		errno = EINVAL;		return sys_errmsg("/"%s/" is not an MTD device", mtd_dev_node);	}	return minor_dev / 2;}

static int answer_is_yes(void){	char buf[4];	while (1) {		if (scanf("%3s", buf) == EOF) {			sys_errmsg("scanf returned unexpected EOF, assume /"no/"");			return 0;		}		if (!strncmp(buf, "yes", 3) || !strncmp(buf, "y", 1))			return 1;		if (!strncmp(buf, "no", 2) || !strncmp(buf, "n", 1))			return 0;	}}

static int translate_dev(libmtd_t libmtd, const char *node){	int err;	struct mtd_dev_info mtd;	err = mtd_get_dev_info(libmtd, node, &mtd);	if (err) {		if (errno == ENODEV)			return errmsg("/"%s/" does not correspond to any "				      "existing MTD device", node);		return sys_errmsg("cannot get information about MTD "				  "device /"%s/"", node);	}	return mtd.mtd_num;}

static int want_exit(void){	char buf[4];	while (1) {		normsg_cont("continue? (yes/no)  ");		if (scanf("%3s", buf) == EOF) {			sys_errmsg("scanf returned unexpected EOF, assume /"yes/"");			return 1;		}		if (!strncmp(buf, "yes", 3) || !strncmp(buf, "y", 1))			return 0;		if (!strncmp(buf, "no", 2) || !strncmp(buf, "n", 1))			return 1;	}}

static int print_general_info(libmtd_t libmtd, const struct mtd_info *mtd_info,			      int all){	int i, err, first = 1;	struct mtd_dev_info mtd;	printf("Count of MTD devices:           %d/n", mtd_info->mtd_dev_cnt);	if (mtd_info->mtd_dev_cnt == 0)		return 0;	for (i = mtd_info->lowest_mtd_num;	     i <= mtd_info->highest_mtd_num; i++) {		err = mtd_get_dev_info1(libmtd, i, &mtd);		if (err == -1) {			if (errno == ENODEV)				continue;			return sys_errmsg("libmtd failed to get MTD device %d "					  "information", i);		}		if (!first)			printf(", mtd%d", i);		else {			printf("Present MTD devices:            mtd%d", i);			first = 0;		}	}	printf("/n");	printf("Sysfs interface supported:      %s/n",	       mtd_info->sysfs_supported ? "yes" : "no");	if (!all)		return 0;	printf("/n");	for (i = mtd_info->lowest_mtd_num;	     i <= mtd_info->highest_mtd_num; i++) {		if (!mtd_dev_present(libmtd, i))			continue;		err = print_dev_info(libmtd, mtd_info, i);		if (err)			return err;	}	return 0;}

static void print_region_info(const struct mtd_dev_info *mtd){	region_info_t reginfo;	int r, fd;	/*	 * If we don't have any region info, just return	 *	 * FIXME: We can't get region_info (via ioctl) without having the MTD	 *        node path. This is a problem for `mtdinfo -a', for example,	 *        since it doesn't provide any filepath information.	 */	if (!args.node || (!args.map && mtd->region_cnt == 0))		return;	/* First open the device so we can query it */	fd = open(args.node, O_RDONLY | O_CLOEXEC);	if (fd == -1) {		sys_errmsg("couldn't open MTD dev: %s", args.node);		if (mtd->region_cnt)			return;	}	/* Walk all the regions and show the map for them */	if (mtd->region_cnt) {		for (r = 0; r < mtd->region_cnt; ++r) {			printf("Eraseblock region %i: ", r);			if (mtd_regioninfo(fd, r, &reginfo) == 0) {				printf(" offset: %#x size: %#x numblocks: %#x/n",					reginfo.offset, reginfo.erasesize,					reginfo.numblocks);				if (args.map)					print_region_map(mtd, fd, &reginfo);			} else				printf(" info is unavailable/n");		}	} else {		reginfo.offset = 0;		reginfo.erasesize = mtd->eb_size;		reginfo.numblocks = mtd->eb_cnt;		reginfo.regionindex = 0;		print_region_map(mtd, fd, &reginfo);	}	if (fd != -1)		close(fd);}

int ubi_rsvol(libubi_t desc, const char *node, int vol_id, long long bytes){	int fd, ret;	struct ubi_rsvol_req req;	desc = desc;	fd = open(node, O_RDONLY);	if (fd == -1)		return sys_errmsg("cannot open /"%s/"", node);	req.bytes = bytes;	req.vol_id = vol_id;	ret = ioctl(fd, UBI_IOCRSVOL, &req);	close(fd);	return ret;}

static int read_all(int fd, void *buf, size_t len){	while (len > 0) {		ssize_t l = read(fd, buf, len);		if (l == 0)			return errmsg("eof reached; %zu bytes remaining", len);		else if (l > 0) {			buf += l;			len -= l;		} else if (errno == EINTR || errno == EAGAIN)			continue;		else			return sys_errmsg("reading failed; %zu bytes remaining", len);	}	return 0;}