mtdread.c - toolbox - Rivoreo Source Code Repositories

 #define _LARGEFILE64_SOURCE
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <ctype.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <unistd.h>

 #include "mtd.h"
 //#include <mtd/mtd-user.h>

 #include <sys/ioctl.h>
 #ifdef __sun
 #include <sys/ioccom.h>
 #endif

 #if defined __APPLE__ || defined __FreeBSD__ || defined __INTERIX
 static loff_t lseek64(int fd, loff_t offset, int whence) {
 	if(whence == SEEK_SET || whence == SEEK_END) {
 		if(lseek(fd, 0, whence) < 0) return -1;
 	}
 	while(offset > INT32_MAX) {
 		if(lseek(fd, INT32_MAX, SEEK_CUR) < 0) return -1;
 		//r += INT32_MAX;
 		offset -= INT32_MAX;
 	}
 	return lseek(fd, offset, SEEK_CUR);
 }
 #endif

 static int test_empty(const char *buf, size_t size) {
 	while(size--) {
 		if((unsigned char)*buf++ != 0xff) return 0;
 	}
 	return 1;
 }

 int main(int argc, char **argv) {
 	char *devname = NULL;
 	char *filename = NULL;
 	char *statusfilename = NULL;
 	char *statusext = ".stat";
 	int fd;
 	int outfd = -1;
 	FILE *statusfile = NULL;
 	int ret;
 	int verbose = 0;
 	void *buffer;
 	loff_t pos, opos, end, bpos;
 	loff_t start = 0, len = 0;
 	int i;
 	int empty_pages = 0;
 	int page_count = 0;
 	int bad_block;
 	int rawmode = 0;
 	uint32_t *oob_data;
 	uint8_t *oob_fixed;
 	size_t spare_size = 64;
 	struct mtd_info_user mtdinfo;
 	struct mtd_ecc_stats initial_ecc, last_ecc, ecc;
 	struct mtd_oob_buf oobbuf;
 	//struct nand_ecclayout ecclayout;
 	nand_ecclayout_t ecclayout;

 	while(1) {
 		int c = getopt(argc, argv, "d:f:s:S:L:Rhv");
 		if(c == EOF) break;
 		switch (c) {
 			case 'd':
 				devname = optarg;
 				break;
 			case 'f':
 				filename = optarg;
 				break;
 			case 's':
 				spare_size = atoi(optarg);
 				break;
 			case 'S':
 				start = strtoll(optarg, NULL, 0);
 				break;
 			case 'L':
 				len = strtoll(optarg, NULL, 0);
 				break;
 			case 'R':
 				rawmode = 1;
 				break;
 			case 'v':
 				verbose++;
 				break;
 			case 'h':
 				fprintf(stderr, "%s [-d <dev>] [-f <file>] [-s <sparesize>] [-vh]\n\n"
 						"	-d <dev>   Read from <dev>\n"
 						"	-f <file>  Write to <file>\n"
 						"	-s <size>  Number of spare bytes in file (default 64)\n"
 						"	-R         Raw mode\n"
 						"	-S <start> Start offset (default 0)\n"
 						"	-L <len>   Length (default 0)\n"
 						"	-v         Print info\n"
 						"	-h         Print help\n", argv[0]);
 				return -1;
 			case '?':
 				//fprintf(stderr, "%s: invalid option -%c\n", argv[0], optopt);
 				return 1;
 		}
 	}

 	if(argc < 2) {
 		fprintf(stderr, "%s: missing arguments\n", argv[0]);
 		return 1;
 	}
 	if(optind < argc) {
 		fprintf(stderr, "%s: extra arguments\n", argv[0]);
 		return 1;
 	}
 	if(!devname) {
 		fprintf(stderr, "%s: specify device name\n", argv[0]);
 		return 1;
 	}

 	fd = open(devname, O_RDONLY);
 	if(fd == -1) {
 		fprintf(stderr, "cannot open %s, %s\n", devname, strerror(errno));
 		return 1;
 	}

 	if(filename) {
 		outfd = creat(filename, 0666);
 		if(outfd == -1) {
 			fprintf(stderr, "cannot open %s, %s\n", filename, strerror(errno));
 			return 1;
 		}
 		statusfilename = malloc(strlen(filename) + strlen(statusext) + 1);
 		strcpy(statusfilename, filename);
 		strcat(statusfilename, statusext);
 		statusfile = fopen(statusfilename, "w+");
 		if(!statusfile) {
 			fprintf(stderr, "cannot open %s, %s\n", statusfilename, strerror(errno));
 			return 1;
 		}
 	}

 	ret = ioctl(fd, MEMGETINFO, &mtdinfo);
 	if(ret < 0) {
 		fprintf(stderr, "failed get mtd info for %s, %s\n", devname, strerror(errno));
 		return 1;
 	}

 	if(verbose) {
 		printf("size: %u\n", mtdinfo.size);
 		printf("erase size: %u\n", mtdinfo.erasesize);
 		printf("write size: %u\n", mtdinfo.writesize);
 		printf("oob size: %u\n", mtdinfo.oobsize);
 	}

 	buffer = malloc(mtdinfo.writesize + mtdinfo.oobsize + spare_size);
 	if(!buffer) {
 		fprintf(stderr, "failed allocate readbuffer size %u\n",
 				mtdinfo.writesize + mtdinfo.oobsize);
 		return 1;
 	}

 	oobbuf.length = mtdinfo.oobsize;
 	oob_data = (uint32_t *)((uint8_t *)buffer + mtdinfo.writesize);
 	memset(oob_data, 0xff, mtdinfo.oobsize + spare_size);
 	oobbuf.ptr = (uint8_t *)oob_data + spare_size;

 	ret = ioctl(fd, ECCGETLAYOUT, &ecclayout);
 	if(ret < 0) {
 		fprintf(stderr, "failed get ecc layout for %s, %s\n", devname, strerror(errno));
 		return 1;
 	}
 	if(verbose) {
 		printf("ecc bytes: %u\n", ecclayout.eccbytes);
 		printf("oobavail: %u\n", ecclayout.oobavail);
 	}
 	if(ecclayout.oobavail > spare_size) {
 		printf("oobavail, %d > image spare size, %ld\n", ecclayout.oobavail, (long int)spare_size);
 	}

 	ret = ioctl(fd, ECCGETSTATS, &initial_ecc);
 	if(ret < 0) {
 		fprintf(stderr, "failed get ecc stats for %s, %s\n", devname, strerror(errno));
 		return 1;
 	}
 	last_ecc = initial_ecc;

 	if(verbose) {
 		printf("initial ecc corrected: %u\n", initial_ecc.corrected);
 		printf("initial ecc failed: %u\n", initial_ecc.failed);
 		printf("initial ecc badblocks: %u\n", initial_ecc.badblocks);
 		printf("initial ecc bbtblocks: %u\n", initial_ecc.bbtblocks);
 	}

 	if(rawmode) {
 		rawmode = mtdinfo.oobsize;
 		ret = ioctl(fd, MTDFILEMODE, MTD_MODE_RAW);
 		if(ret < 0) {
 			fprintf(stderr, "failed set raw mode for %s, %s\n", devname, strerror(errno));
 			return 1;
 		}
 	}

 	end = len ? (start + len) : mtdinfo.size;
 	for(pos = start, opos = 0; pos < end; pos += mtdinfo.writesize) {
 		bad_block = 0;
 		if(verbose > 3) printf("reading at %llx\n", (long long int)pos);
 		lseek64(fd, pos, SEEK_SET);
 		ret = read(fd, buffer, mtdinfo.writesize + rawmode);
 		if(ret < (int)mtdinfo.writesize) {
 			fprintf(stderr, "short read at %llx, %d\n", (long long int)pos, ret);
 			bad_block = 2;
 		}
 		if(!rawmode) {
 			oobbuf.start = pos;
 			ret = ioctl(fd, MEMREADOOB, &oobbuf);
 			if(ret < 0) {
 				fprintf(stderr, "failed to read oob data at %llx, %d\n", (long long int)pos, ret);
 				bad_block = 2;
 			}
 		}
 		ret = ioctl(fd, ECCGETSTATS, &ecc);
 		if(ret < 0) {
 			fprintf(stderr, "failed get ecc stats for %s, %s\n", devname, strerror(errno));
 			return 1;
 		}
 		bpos = pos / mtdinfo.erasesize * mtdinfo.erasesize;
 		ret = ioctl(fd, MEMGETBADBLOCK, &bpos);
 		if(ret < 0 && errno != EOPNOTSUPP) {
 			printf("badblock at %llx\n", (long long int)pos);
 			bad_block = 1;
 		}
 		if(ecc.corrected != last_ecc.corrected) {
 			printf("ecc corrected, %u, at %llx\n", ecc.corrected - last_ecc.corrected, (long long int)pos);
 		}
 		if(ecc.failed != last_ecc.failed) {
 			printf("ecc failed, %u, at %llx\n", ecc.failed - last_ecc.failed, (long long int)pos);
 		}
 		if(ecc.badblocks != last_ecc.badblocks) {
 			printf("ecc badblocks, %u, at %llx\n", ecc.badblocks - last_ecc.badblocks, (long long int)pos);
 		}
 		if(ecc.bbtblocks != last_ecc.bbtblocks) {
 			printf("ecc bbtblocks, %u, at %llx\n", ecc.bbtblocks - last_ecc.bbtblocks, (long long int)pos);
 		}

 		if(!rawmode) {
 			oob_fixed = (uint8_t *)oob_data;
 			for(i = 0; i < MTD_MAX_OOBFREE_ENTRIES; i++) {
 				int len = ecclayout.oobfree[i].length;
 				if(oob_fixed + len > oobbuf.ptr) len = oobbuf.ptr - oob_fixed;
 				if(len) {
 					memcpy(oob_fixed, oobbuf.ptr + ecclayout.oobfree[i].offset, len);
 					oob_fixed += len;
 				}
 			}
 		}

 		if(outfd >= 0) {
 			ret = write(outfd, buffer, mtdinfo.writesize + spare_size);
 			if(ret < (int)(mtdinfo.writesize + spare_size)) {
 				fprintf(stderr, "short write at %llx, %d\n", (long long int)pos, ret);
 				close(outfd);
 				outfd = -1;
 			}
 			if(ecc.corrected != last_ecc.corrected) {
 				fprintf(statusfile, "%08llx: ecc corrected\n", (long long int)opos);
 			}
 			if(ecc.failed != last_ecc.failed) {
 				fprintf(statusfile, "%08llx: ecc failed\n", (long long int)opos);
 			}
 			if(bad_block == 1) {
 				fprintf(statusfile, "%08llx: badblock\n", (long long int)opos);
 			} else if (bad_block == 2) {
 				fprintf(statusfile, "%08llx: read error\n", (long long int)opos);
 			}
 			opos += mtdinfo.writesize + spare_size;
 		}

 		last_ecc = ecc;
 		page_count++;
 		if(test_empty(buffer, mtdinfo.writesize + mtdinfo.oobsize + spare_size)) {
 			empty_pages++;
 		} else if(verbose > 2 || (verbose > 1 && !(pos & (mtdinfo.erasesize - 1)))) {
 			printf("page at %llx (%d oobbytes): %08x %08x %08x %08x "
 				"%08x %08x %08x %08x\n", (long long int)pos, oobbuf.start,
 				oob_data[0], oob_data[1], oob_data[2], oob_data[3],
 				oob_data[4], oob_data[5], oob_data[6], oob_data[7]);
 		}
 	}

 	if(outfd >= 0) {
 		fprintf(statusfile, "read %d pages, %d empty\n", page_count, empty_pages);
 		fprintf(statusfile, "total ecc corrected, %u\n", ecc.corrected - initial_ecc.corrected);
 		fprintf(statusfile, "total ecc failed, %u\n", ecc.failed - initial_ecc.failed);
 		fprintf(statusfile, "total ecc badblocks, %u\n", ecc.badblocks - initial_ecc.badblocks);
 		fprintf(statusfile, "total ecc bbtblocks, %u\n", ecc.bbtblocks - initial_ecc.bbtblocks);
 	}
 	if(verbose) {
 		printf("total ecc corrected, %u\n", ecc.corrected - initial_ecc.corrected);
 		printf("total ecc failed, %u\n", ecc.failed - initial_ecc.failed);
 		printf("total ecc badblocks, %u\n", ecc.badblocks - initial_ecc.badblocks);
 		printf("total ecc bbtblocks, %u\n", ecc.bbtblocks - initial_ecc.bbtblocks);
 	}
 	printf("read %d pages, %d empty\n", page_count, empty_pages);

 	return 0;
 }
	#define _LARGEFILE64_SOURCE
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <ctype.h>
	#include <errno.h>
	#include <fcntl.h>
	#include <unistd.h>

	#include "mtd.h"
	//#include <mtd/mtd-user.h>

	#include <sys/ioctl.h>
	#ifdef __sun
	#include <sys/ioccom.h>
	#endif

	#if defined __APPLE__ \|\| defined __FreeBSD__ \|\| defined __INTERIX
	static loff_t lseek64(int fd, loff_t offset, int whence) {
	if(whence == SEEK_SET \|\| whence == SEEK_END) {
	if(lseek(fd, 0, whence) < 0) return -1;
	}
	while(offset > INT32_MAX) {
	if(lseek(fd, INT32_MAX, SEEK_CUR) < 0) return -1;
	//r += INT32_MAX;
	offset -= INT32_MAX;
	}
	return lseek(fd, offset, SEEK_CUR);
	}
	#endif

	static int test_empty(const char *buf, size_t size) {
	while(size--) {
	if((unsigned char)*buf++ != 0xff) return 0;
	}
	return 1;
	}

	int main(int argc, char **argv) {
	char *devname = NULL;
	char *filename = NULL;
	char *statusfilename = NULL;
	char *statusext = ".stat";
	int fd;
	int outfd = -1;
	FILE *statusfile = NULL;
	int ret;
	int verbose = 0;
	void *buffer;
	loff_t pos, opos, end, bpos;
	loff_t start = 0, len = 0;
	int i;
	int empty_pages = 0;
	int page_count = 0;
	int bad_block;
	int rawmode = 0;
	uint32_t *oob_data;
	uint8_t *oob_fixed;
	size_t spare_size = 64;
	struct mtd_info_user mtdinfo;
	struct mtd_ecc_stats initial_ecc, last_ecc, ecc;
	struct mtd_oob_buf oobbuf;
	//struct nand_ecclayout ecclayout;
	nand_ecclayout_t ecclayout;

	while(1) {
	int c = getopt(argc, argv, "d:f:s:S:L:Rhv");
	if(c == EOF) break;
	switch (c) {
	case 'd':
	devname = optarg;
	break;
	case 'f':
	filename = optarg;
	break;
	case 's':
	spare_size = atoi(optarg);
	break;
	case 'S':
	start = strtoll(optarg, NULL, 0);
	break;
	case 'L':
	len = strtoll(optarg, NULL, 0);
	break;
	case 'R':
	rawmode = 1;
	break;
	case 'v':
	verbose++;
	break;
	case 'h':
	fprintf(stderr, "%s [-d <dev>] [-f <file>] [-s <sparesize>] [-vh]\n\n"
	" -d <dev> Read from <dev>\n"
	" -f <file> Write to <file>\n"
	" -s <size> Number of spare bytes in file (default 64)\n"
	" -R Raw mode\n"
	" -S <start> Start offset (default 0)\n"
	" -L <len> Length (default 0)\n"
	" -v Print info\n"
	" -h Print help\n", argv[0]);
	return -1;
	case '?':
	//fprintf(stderr, "%s: invalid option -%c\n", argv[0], optopt);
	return 1;
	}
	}

	if(argc < 2) {
	fprintf(stderr, "%s: missing arguments\n", argv[0]);
	return 1;
	}
	if(optind < argc) {
	fprintf(stderr, "%s: extra arguments\n", argv[0]);
	return 1;
	}
	if(!devname) {
	fprintf(stderr, "%s: specify device name\n", argv[0]);
	return 1;
	}

	fd = open(devname, O_RDONLY);
	if(fd == -1) {
	fprintf(stderr, "cannot open %s, %s\n", devname, strerror(errno));
	return 1;
	}

	if(filename) {
	outfd = creat(filename, 0666);
	if(outfd == -1) {
	fprintf(stderr, "cannot open %s, %s\n", filename, strerror(errno));
	return 1;
	}
	statusfilename = malloc(strlen(filename) + strlen(statusext) + 1);
	strcpy(statusfilename, filename);
	strcat(statusfilename, statusext);
	statusfile = fopen(statusfilename, "w+");
	if(!statusfile) {
	fprintf(stderr, "cannot open %s, %s\n", statusfilename, strerror(errno));
	return 1;
	}
	}

	ret = ioctl(fd, MEMGETINFO, &mtdinfo);
	if(ret < 0) {
	fprintf(stderr, "failed get mtd info for %s, %s\n", devname, strerror(errno));
	return 1;
	}

	if(verbose) {
	printf("size: %u\n", mtdinfo.size);
	printf("erase size: %u\n", mtdinfo.erasesize);
	printf("write size: %u\n", mtdinfo.writesize);
	printf("oob size: %u\n", mtdinfo.oobsize);
	}

	buffer = malloc(mtdinfo.writesize + mtdinfo.oobsize + spare_size);
	if(!buffer) {
	fprintf(stderr, "failed allocate readbuffer size %u\n",
	mtdinfo.writesize + mtdinfo.oobsize);
	return 1;
	}

	oobbuf.length = mtdinfo.oobsize;
	oob_data = (uint32_t )((uint8_t )buffer + mtdinfo.writesize);
	memset(oob_data, 0xff, mtdinfo.oobsize + spare_size);
	oobbuf.ptr = (uint8_t *)oob_data + spare_size;

	ret = ioctl(fd, ECCGETLAYOUT, &ecclayout);
	if(ret < 0) {
	fprintf(stderr, "failed get ecc layout for %s, %s\n", devname, strerror(errno));
	return 1;
	}
	if(verbose) {
	printf("ecc bytes: %u\n", ecclayout.eccbytes);
	printf("oobavail: %u\n", ecclayout.oobavail);
	}
	if(ecclayout.oobavail > spare_size) {
	printf("oobavail, %d > image spare size, %ld\n", ecclayout.oobavail, (long int)spare_size);
	}

	ret = ioctl(fd, ECCGETSTATS, &initial_ecc);
	if(ret < 0) {
	fprintf(stderr, "failed get ecc stats for %s, %s\n", devname, strerror(errno));
	return 1;
	}
	last_ecc = initial_ecc;

	if(verbose) {
	printf("initial ecc corrected: %u\n", initial_ecc.corrected);
	printf("initial ecc failed: %u\n", initial_ecc.failed);
	printf("initial ecc badblocks: %u\n", initial_ecc.badblocks);
	printf("initial ecc bbtblocks: %u\n", initial_ecc.bbtblocks);
	}

	if(rawmode) {
	rawmode = mtdinfo.oobsize;
	ret = ioctl(fd, MTDFILEMODE, MTD_MODE_RAW);
	if(ret < 0) {
	fprintf(stderr, "failed set raw mode for %s, %s\n", devname, strerror(errno));
	return 1;
	}
	}

	end = len ? (start + len) : mtdinfo.size;
	for(pos = start, opos = 0; pos < end; pos += mtdinfo.writesize) {
	bad_block = 0;
	if(verbose > 3) printf("reading at %llx\n", (long long int)pos);
	lseek64(fd, pos, SEEK_SET);
	ret = read(fd, buffer, mtdinfo.writesize + rawmode);
	if(ret < (int)mtdinfo.writesize) {
	fprintf(stderr, "short read at %llx, %d\n", (long long int)pos, ret);
	bad_block = 2;
	}
	if(!rawmode) {
	oobbuf.start = pos;
	ret = ioctl(fd, MEMREADOOB, &oobbuf);
	if(ret < 0) {
	fprintf(stderr, "failed to read oob data at %llx, %d\n", (long long int)pos, ret);
	bad_block = 2;
	}
	}
	ret = ioctl(fd, ECCGETSTATS, &ecc);
	if(ret < 0) {
	fprintf(stderr, "failed get ecc stats for %s, %s\n", devname, strerror(errno));
	return 1;
	}
	bpos = pos / mtdinfo.erasesize * mtdinfo.erasesize;
	ret = ioctl(fd, MEMGETBADBLOCK, &bpos);
	if(ret < 0 && errno != EOPNOTSUPP) {
	printf("badblock at %llx\n", (long long int)pos);
	bad_block = 1;
	}
	if(ecc.corrected != last_ecc.corrected) {
	printf("ecc corrected, %u, at %llx\n", ecc.corrected - last_ecc.corrected, (long long int)pos);
	}
	if(ecc.failed != last_ecc.failed) {
	printf("ecc failed, %u, at %llx\n", ecc.failed - last_ecc.failed, (long long int)pos);
	}
	if(ecc.badblocks != last_ecc.badblocks) {
	printf("ecc badblocks, %u, at %llx\n", ecc.badblocks - last_ecc.badblocks, (long long int)pos);
	}
	if(ecc.bbtblocks != last_ecc.bbtblocks) {
	printf("ecc bbtblocks, %u, at %llx\n", ecc.bbtblocks - last_ecc.bbtblocks, (long long int)pos);
	}

	if(!rawmode) {
	oob_fixed = (uint8_t *)oob_data;
	for(i = 0; i < MTD_MAX_OOBFREE_ENTRIES; i++) {
	int len = ecclayout.oobfree[i].length;
	if(oob_fixed + len > oobbuf.ptr) len = oobbuf.ptr - oob_fixed;
	if(len) {
	memcpy(oob_fixed, oobbuf.ptr + ecclayout.oobfree[i].offset, len);
	oob_fixed += len;
	}
	}
	}

	if(outfd >= 0) {
	ret = write(outfd, buffer, mtdinfo.writesize + spare_size);
	if(ret < (int)(mtdinfo.writesize + spare_size)) {
	fprintf(stderr, "short write at %llx, %d\n", (long long int)pos, ret);
	close(outfd);
	outfd = -1;
	}
	if(ecc.corrected != last_ecc.corrected) {
	fprintf(statusfile, "%08llx: ecc corrected\n", (long long int)opos);
	}
	if(ecc.failed != last_ecc.failed) {
	fprintf(statusfile, "%08llx: ecc failed\n", (long long int)opos);
	}
	if(bad_block == 1) {
	fprintf(statusfile, "%08llx: badblock\n", (long long int)opos);
	} else if (bad_block == 2) {
	fprintf(statusfile, "%08llx: read error\n", (long long int)opos);
	}
	opos += mtdinfo.writesize + spare_size;
	}

	last_ecc = ecc;
	page_count++;
	if(test_empty(buffer, mtdinfo.writesize + mtdinfo.oobsize + spare_size)) {
	empty_pages++;
	} else if(verbose > 2 \|\| (verbose > 1 && !(pos & (mtdinfo.erasesize - 1)))) {
	printf("page at %llx (%d oobbytes): %08x %08x %08x %08x "
	"%08x %08x %08x %08x\n", (long long int)pos, oobbuf.start,
	oob_data[0], oob_data[1], oob_data[2], oob_data[3],
	oob_data[4], oob_data[5], oob_data[6], oob_data[7]);
	}
	}

	if(outfd >= 0) {
	fprintf(statusfile, "read %d pages, %d empty\n", page_count, empty_pages);
	fprintf(statusfile, "total ecc corrected, %u\n", ecc.corrected - initial_ecc.corrected);
	fprintf(statusfile, "total ecc failed, %u\n", ecc.failed - initial_ecc.failed);
	fprintf(statusfile, "total ecc badblocks, %u\n", ecc.badblocks - initial_ecc.badblocks);
	fprintf(statusfile, "total ecc bbtblocks, %u\n", ecc.bbtblocks - initial_ecc.bbtblocks);
	}
	if(verbose) {
	printf("total ecc corrected, %u\n", ecc.corrected - initial_ecc.corrected);
	printf("total ecc failed, %u\n", ecc.failed - initial_ecc.failed);
	printf("total ecc badblocks, %u\n", ecc.badblocks - initial_ecc.badblocks);
	printf("total ecc bbtblocks, %u\n", ecc.bbtblocks - initial_ecc.bbtblocks);
	}
	printf("read %d pages, %d empty\n", page_count, empty_pages);

	return 0;
	}