mtdread_u.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 <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;
 		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 mtdread_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;
     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 [<options>]\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 '?':
             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 < 0) {
         fprintf(stderr, "cannot open %s, %s\n", devname, strerror(errno));
         return 1;
     }

     if(filename) {
         outfd = creat(filename, 0666);
         if(outfd < 0) {
             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) {
         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) {
         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) {
         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) {
             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) {
                 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) {
             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 && 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);
             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 <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;
	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 mtdread_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;
	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 [<options>]\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 '?':
	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 < 0) {
	fprintf(stderr, "cannot open %s, %s\n", devname, strerror(errno));
	return 1;
	}

	if(filename) {
	outfd = creat(filename, 0666);
	if(outfd < 0) {
	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) {
	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) {
	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) {
	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) {
	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) {
	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) {
	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 && 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);
	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;
	}