Import sources from 2011-03-30 iso image

1 files changed, 617 insertions, 0 deletions

diff --git a/sys/src/cmd/ecp.c b/sys/src/cmd/ecp.c
new file mode 100755
index 000000000..e89e87c5a
--- /dev/null
+++ b/sys/src/cmd/ecp.c
@@ -0,0 +1,617 @@
+/*
+ * ecp - copy a file fast (in big blocks), cope with errors, optionally verify.
+ *
+ * Transfers a block at a time.  On error, retries one sector at a time,
+ * and reports all errors on the retry.
+ * Unlike dd, ecp ignores EOF, since it is sometimes reported on error.
+ * Also unlike `dd conv=noerror,sync', ecp doesn't get stuck nor give up.
+ *
+ * Written by Geoff Collyer, originally to run on RSX-11M(!) in 1979.
+ * Later simplified for UNIX and ultimately Plan 9.
+ */
+#include <u.h>
+#include <libc.h>
+#include <ctype.h>
+
+/* fundamental constants */
+enum {
+	No = 0,
+	Yes,
+
+	Noseek = 0,		/* need not seek, may seek on seekable files */
+	Mustseek,
+
+	Enone = 0,
+	Eio,
+};
+
+/* tunable parameters */
+enum {
+	Defsectsz = 512,	/* default sector size */
+	/* 10K is a good size for HP WORM drives */
+	Defblksz = 16*1024,	/* default block (big-transfer) size */
+	Mingoodblks = 3,	/* after this many, go back to fast mode */
+};
+
+#define TTY "/dev/cons"			/* plan 9 */
+
+#define badsect(errno) ((errno) != Enone)  /* was last transfer in error? */
+
+/* disk address (in bytes or sectors), also type of 2nd arg. to seek */
+typedef uvlong Daddr;
+typedef vlong Sdaddr;				/* signed disk address */
+typedef long Rdwrfn(int, void *, long);		/* plan 9 read or write */
+
+typedef struct {
+	char	*name;
+	int	fd;
+	Daddr	startsect;
+	int	fast;
+	int	seekable;
+
+	ulong	maxconerrs;		/* maximum consecutive errors */
+	ulong	conerrs;		/* current consecutive errors */
+	Daddr	congoodblks;
+
+	Daddr	harderrs;
+	Daddr	lasterr;		/* sector #s */
+	Daddr	lastgood;
+} File;
+
+/* exports */
+char *argv0;
+
+/* privates */
+static int reblock = No, progress = No, swizzle = No;
+static int reverse = No;
+static ulong sectsz = Defsectsz;
+static ulong blocksize = Defblksz;
+
+static char *buf, *vfybuf;
+static int blksects;
+
+/*
+ * warning - print best error message possible and clear errno
+ */
+void
+warning(char *s1, char *s2)
+{
+	char err[100], msg[256];
+	char *np, *ep = msg + sizeof msg - 1;
+
+	errstr(err, sizeof err);		/* save error string */
+	np = seprint(msg, ep, "%s: ", argv0);
+	np = seprint(np, ep, s1, s2);
+	errstr(err, sizeof err);		/* restore error string */
+	seprint(np, ep, ": %r\n");
+
+	fprint(2, "%s", msg);
+}
+
+int
+eopen(char *file, int mode)
+{
+	int fd = open(file, mode);
+
+	if (fd < 0)
+		sysfatal("can't open %s: %r", file);
+	return fd;
+}
+
+static int					/* boolean */
+confirm(File *src, File *dest)
+{
+	int absent, n, tty = eopen(TTY, 2);
+	char c, junk;
+	Dir *stp;
+
+	if ((stp = dirstat(src->name)) == nil)
+		sysfatal("no input file %s: %r", src->name);
+	free(stp);
+	stp = dirstat(dest->name);
+	absent = (stp == nil);
+	free(stp);
+	fprint(2, "%s: copy %s to %s%s? ", argv0, src->name, dest->name,
+		(absent? " (missing)": ""));
+	n = read(tty, &c, 1);
+	junk = c;
+	if (n < 1)
+		c = 'n';
+	while (n > 0 && junk != '\n')
+		n = read(tty, &junk, 1);
+	close(tty);
+	if (isascii(c) && isupper(c))
+		c = tolower(c);
+	return c == 'y';
+}
+
+static char *
+sectid(File *fp, Daddr sect)
+{
+	static char sectname[256];
+
+	if (fp->startsect == 0)
+		snprint(sectname, sizeof sectname, "%s sector %llud",
+			fp->name, sect);
+	else
+		snprint(sectname, sizeof sectname,
+			"%s sector %llud (relative %llud)",
+			fp->name, sect + fp->startsect, sect);
+	return sectname;
+}
+
+static void
+io_expl(File *fp, char *rw, Daddr sect)		/* explain an i/o error */
+{
+	/* print only first 2 bad sectors in a range, if going forward */
+	if (reverse || fp->conerrs == 0) {
+		char msg[128];
+
+		snprint(msg, sizeof msg, "%s %s", rw, sectid(fp, sect));
+		warning("%s", msg);
+	} else if (fp->conerrs == 1)
+		fprint(2, "%s: ...\n", argv0);
+}
+
+static void
+repos(File *fp, Daddr sect)
+{
+	if (!fp->seekable)
+		sysfatal("%s: trying to seek on unseekable file", fp->name);
+	if (seek(fp->fd, (sect+fp->startsect)*sectsz, 0) == -1)
+		sysfatal("can't seek on %s: %r", fp->name);
+}
+
+static void
+rewind(File *fp)
+{
+	repos(fp, 0);
+}
+
+/*
+ * transfer (many) sectors.  reblock input as needed.
+ * returns Enone if no failures, others on failure with errstr set.
+ */
+static int
+bio(File *fp, Rdwrfn *rdwr, char *buff, Daddr stsect, int sects, int mustseek)
+{
+	int xfered;
+	ulong toread, bytes = sects * sectsz;
+	static int reblocked = 0;
+
+	if (mustseek) {
+		if (!fp->seekable)
+			sysfatal("%s: need to seek on unseekable file",
+				fp->name);
+		repos(fp, stsect);
+	}
+	if ((long)blocksize != blocksize || (long)bytes != bytes)
+		sysfatal("i/o count too big: %lud", bytes);
+
+	werrstr("");
+	xfered = (*rdwr)(fp->fd, buff, bytes);
+	if (xfered == bytes)
+		return Enone;			/* did as we asked */
+	if (xfered < 0)
+		return Eio;			/* out-and-out i/o error */
+	/*
+	 * Kernel transferred less than asked.  Shouldn't happen;
+	 * probably indicates disk driver error or trying to
+	 * transfer past the end of a disk partition.  Treat as an
+	 * I/O error that reads zeros past the point of error,
+	 * unless reblocking input and this is a read.
+	 */
+	if (rdwr == write)
+		return Eio;
+	if (!reblock) {
+		memset(buff+xfered, '\0', bytes-xfered);
+		return Eio;			/* short read */
+	}
+
+	/* for pipes that return less than asked */
+	if (progress && !reblocked) {
+		fprint(2, "%s: reblocking input\n", argv0);
+		reblocked++;
+	}
+	for (toread = bytes - xfered; toread != 0; toread -= xfered) {
+		xfered = (*rdwr)(fp->fd, buff+bytes-toread, toread);
+		if (xfered <= 0)
+			break;
+	}
+	if (xfered < 0)
+		return Eio;			/* out-and-out i/o error */
+	if (toread != 0)			/* early EOF? */
+		memset(buff+bytes-toread, '\0', toread);
+	return Enone;
+}
+
+/* called only after a single-sector transfer */
+static int
+toomanyerrs(File *fp, Daddr sect)
+{
+	if (sect == fp->lasterr+1)
+		fp->conerrs++;
+	else
+		fp->conerrs = 0;
+	fp->lasterr = sect;
+	return fp->maxconerrs != 0 && fp->conerrs >= fp->maxconerrs &&
+		fp->lastgood == -1;
+}
+
+static void
+ckendrange(File *fp)
+{
+	if (!reverse && fp->conerrs > 0)
+		fprint(2, "%s: %lld: ... last bad sector in range\n",
+			argv0, fp->lasterr);
+}
+
+static int
+transfer(File *fp, Rdwrfn *rdwr, char *buff, Daddr stsect, int sects,
+	int mustseek)
+{
+	int res = bio(fp, rdwr, buff, stsect, sects, mustseek);
+
+	if (badsect(res)) {
+		fp->fast = 0;		/* read single sectors for a while */
+		fp->congoodblks = 0;
+	} else
+		fp->lastgood = stsect + sects - 1;
+	return res;
+}
+
+/*
+ * Read or write many sectors at once.
+ * If it fails, retry the individual sectors and report errors.
+ */
+static void
+bigxfer(File *fp, Rdwrfn *rdwr, char *buff, Daddr stsect, int sects,
+	int mustseek)
+{
+	int i, badsects = 0, wasfast = fp->fast;
+	char *rw = (rdwr == read? "read": "write");
+
+	if (fp->fast) {
+		if (!badsect(transfer(fp, rdwr, buff, stsect, sects, mustseek)))
+			return;
+		if (progress)
+			fprint(2, "%s: breaking up big transfer on %s error "
+				"`%r' on %s\n", argv0, rw, sectid(fp, stsect));
+	}
+
+	for (i = 0; i < sects; i++)
+		if (badsect(transfer(fp, rdwr, buff+i*sectsz, stsect+i, 1,
+		    Mustseek))) {
+			io_expl(fp, rw, stsect+i);
+			badsects++;
+			fp->harderrs++;
+			if (toomanyerrs(fp, stsect+i))
+				sysfatal("more than %lud consecutive I/O errors",
+					fp->maxconerrs);
+		} else {
+			ckendrange(fp);
+			fp->conerrs = 0;
+		}
+	if (badsects == 0) {
+		ckendrange(fp);
+		fp->conerrs = 0;
+		if (wasfast)
+			fprint(2, "%s: %s error on big transfer at %s but none "
+				"on retries!\n", argv0, rw, sectid(fp, stsect));
+		++fp->congoodblks;
+		if (fp->congoodblks >= Mingoodblks) {
+			fprint(2, "%s: %s: back to big transfers\n", argv0,
+				fp->name);
+			fp->fast = 1;
+		}
+	} else
+		/*
+		 * the last sector could have been in error, so the seek pointer
+		 * may need to be corrected.
+		 */
+		repos(fp, stsect + sects);
+}
+
+static void
+vrfyfailed(File *src, File *dest, Daddr stsect)
+{
+	char *srcsect = strdup(sectid(src, stsect));
+
+	fprint(2, "%s: verify failed at %s (%s)\n", argv0, srcsect,
+		sectid(dest, stsect));
+	free(srcsect);
+}
+
+/*
+ * I've seen SCSI read errors that the kernel printed but then didn't
+ * report to the program doing the read, so if a big verify fails,
+ * break it up and verify each sector separately to isolate the bad sector(s).
+ */
+int						/* error count */
+verify(File *src, File *dest, char *buff, char *buft, Daddr stsect,
+	int sectors)
+{
+	int i, errors = 0;
+
+	for (i = 0; i < sectors; i++)
+		if (memcmp(buff + i*sectsz, buft + i*sectsz, sectsz) != 0)
+			errors++;
+	if (errors == 0)
+		return errors;			/* normal case */
+
+	if (sectors == 1) {
+		vrfyfailed(src, dest, stsect);
+		return errors;
+	}
+
+	/* re-read and verify each sector individually */
+	errors = 0;
+	for (i = 0; i < sectors; i++) {
+		int thissect = stsect + i;
+
+		if (badsect(bio(src,  read, buff, thissect, 1, Mustseek)))
+			io_expl(src,  "read",  thissect);
+		if (badsect(bio(dest, read, buft, thissect, 1, Mustseek)))
+			io_expl(dest, "write", thissect);
+		if (memcmp(buff, buft, sectsz) != 0) {
+			vrfyfailed(src, dest, thissect);
+			++errors;
+		}
+	}
+	if (errors == 0) {
+		char *srcsect = strdup(sectid(src, stsect));
+
+		fprint(2, "%s: verification failed on big read at %s (%s) "
+			"but not on retries!\n", argv0, srcsect,
+			sectid(dest, stsect));
+		free(srcsect);
+	}
+	/*
+	 * the last sector of each could have been in error, so the seek
+	 * pointers may need to be corrected.
+	 */
+	repos(src,  stsect + sectors);
+	repos(dest, stsect + sectors);
+	return errors;
+}
+
+/*
+ * start is starting sector of proposed transfer;
+ * nsects is the total number of sectors being copied;
+ * maxxfr is the block size in sectors.
+ */
+int
+sectsleft(Daddr start, Daddr nsects, int maxxfr)
+{
+	/* nsects-start is sectors to the end */
+	if (start + maxxfr <= nsects - 1)
+		return maxxfr;
+	else
+		return nsects - start;
+}
+
+enum {
+	Rotbits = 3,
+};
+
+void
+swizzlebits(char *buff, int sects)
+{
+	uchar *bp, *endbp;
+
+	endbp = (uchar *)(buff+sects*sectsz);
+	for (bp = (uchar *)buff; bp < endbp; bp++)
+		*bp = ~(*bp>>Rotbits | *bp<<(8-Rotbits));
+}
+
+/*
+ * copy at most blksects sectors, with error retries.
+ * stsect is relative to the start of the copy; 0 is the first sector.
+ * to get actual sector numbers, add e.g. dest->startsect.
+ */
+static int
+copysects(File *src, File *dest, Daddr stsect, Daddr nsects, int mustseek)
+{
+	int xfrsects = sectsleft(stsect, nsects, blksects);
+
+	if (xfrsects > blksects) {
+		fprint(2, "%s: block size of %d is too big.\n", argv0, xfrsects);
+		exits("block size too big");
+	}
+	bigxfer(src,  read,  buf, stsect, xfrsects, mustseek);
+	if (swizzle)
+		swizzlebits(buf, xfrsects);
+	bigxfer(dest, write, buf, stsect, xfrsects, mustseek);
+	/* give a few reassurances at the start, then every 10MB */
+	if (progress &&
+	    (stsect < blksects*10 || stsect%(10*1024*1024/sectsz) == 0))
+		fprint(2, "%s: copied%s to relative sector %llud\n", argv0,
+			(swizzle? " swizzled": ""), stsect + xfrsects - 1);
+	return 0;
+}
+
+/*
+ * verify at most blksects sectors, with error retries.
+ * return error count.
+ */
+static int
+vrfysects(File *src, File *dest, Daddr stsect, Daddr nsects, int mustseek)
+{
+	int xfrsects = sectsleft(stsect, nsects, blksects);
+
+	if (xfrsects > blksects) {
+		fprint(2, "%s: block size of %d is too big.\n", argv0, xfrsects);
+		exits("block size too big");
+	}
+	bigxfer(src,  read, buf,    stsect, xfrsects, mustseek);
+	bigxfer(dest, read, vfybuf, stsect, xfrsects, mustseek);
+	return verify(src, dest, buf, vfybuf, stsect, xfrsects);
+}
+
+static void
+setupfile(File *fp, int mode)
+{
+	fp->fd = open(fp->name, mode);
+	if (fp->fd < 0)
+		sysfatal("can't open %s: %r", fp->name);
+	fp->seekable = (seek(fp->fd, 0, 1) >= 0);
+	if (fp->startsect != 0)
+		rewind(fp);
+}
+
+static Daddr
+copyfile(File *src, File *dest, Daddr nsects, int plsverify)
+{
+	Sdaddr stsect, vererrs = 0;
+	Dir *stp;
+
+	setupfile(src, OREAD);
+	if ((stp = dirstat(dest->name)) == nil) {
+		int fd = create(dest->name, ORDWR, 0666);
+
+		if (fd >= 0)
+			close(fd);
+	}
+	free(stp);
+	setupfile(dest, ORDWR);
+
+	if (progress)
+		fprint(2, "%s: copying first sectors\n", argv0);
+	if (reverse)
+		for (stsect = (nsects/blksects)*blksects; stsect >= 0;
+		     stsect -= blksects)
+			vererrs += copysects(src, dest, stsect, nsects, Mustseek);
+	else {
+		for (stsect = 0; stsect < nsects; stsect += blksects)
+			vererrs += copysects(src, dest, stsect, nsects, Noseek);
+		ckendrange(src);
+		ckendrange(dest);
+	}
+
+	/*
+	 * verification is done as a separate pass rather than immediately after
+	 * writing, in part to defeat caching in clever disk controllers.
+	 * we really want to see the bits that hit the disk.
+	 */
+	if (plsverify) {
+		fprint(2, "%s: copy done; verifying...\n", argv0);
+		rewind(src);
+		rewind(dest);
+		for (stsect = 0; stsect < nsects; stsect += blksects) /* forward */
+			vererrs += vrfysects(src, dest, stsect, nsects, Noseek);
+		if (vererrs <= 0)
+			fprint(2, "%s: no", argv0);
+		else
+			fprint(2, "%s: %llud", argv0, vererrs);
+		fprint(2, " error%s during verification\n",
+			(vererrs != 1? "s": ""));
+	}
+	close(src->fd);
+	close(dest->fd);
+	return vererrs;
+}
+
+static void
+usage(void)
+{
+	fprint(2, "usage: %s [-bcprvZ][-B blocksz][-e errs][-s sectsz]"
+		"[-i issect][-o ossect] sectors from to\n", argv0);
+	exits("usage");
+}
+
+void
+initfile(File *fp)
+{
+	memset(fp, 0, sizeof *fp);
+	fp->fast = 1;
+	fp->lasterr = -1;
+	fp->lastgood = -1;
+}
+
+void
+main(int argc, char **argv)
+{
+	int errflg = 0, plsconfirm = No, plsverify = No;
+	long lval;
+	File src, dest;
+	Sdaddr sect;
+
+	initfile(&src);
+	initfile(&dest);
+	ARGBEGIN {
+	case 'b':
+		reblock = Yes;
+		break;
+	case 'B':
+		lval = atol(EARGF(usage()));
+		if (lval < 0)
+			usage();
+		blocksize = lval;
+		break;
+	case 'c':
+		plsconfirm = Yes;
+		break;
+	case 'e':
+		lval = atol(EARGF(usage()));
+		if (lval < 0)
+			usage();
+		src.maxconerrs = lval;
+		dest.maxconerrs = lval;
+		break;
+	case 'i':
+		sect = atoll(EARGF(usage()));
+		if (sect < 0)
+			usage();
+		src.startsect = sect;
+		break;
+	case 'o':
+		sect = atoll(EARGF(usage()));
+		if (sect < 0)
+			usage();
+		dest.startsect = sect;
+		break;
+	case 'p':
+		progress = Yes;
+		break;
+	case 'r':
+		reverse = Yes;
+		break;
+	case 's':
+		sectsz = atol(EARGF(usage()));
+		if (sectsz <= 0 || sectsz % 512 != 0)
+			usage();
+		break;
+	case 'v':
+		plsverify = Yes;
+		break;
+	case 'Z':
+		swizzle = Yes;
+		break;
+	default:
+		errflg++;
+		break;
+	} ARGEND
+	if (errflg || argc != 3)
+		usage();
+	if (blocksize <= 0 || blocksize % sectsz != 0)
+		sysfatal("block size not a multiple of sector size");
+
+	if (!isascii(argv[0][0]) || !isdigit(argv[0][0])) {
+		fprint(2, "%s: %s is not numeric\n", argv0, argv[0]);
+		exits("non-numeric sector count");
+	}
+	src.name =  argv[1];
+	dest.name = argv[2];
+
+	blksects = blocksize / sectsz;
+	if (blksects < 1)
+		blksects = 1;
+	buf = malloc(blocksize);
+	vfybuf = malloc(blocksize);
+	if (buf == nil || vfybuf == nil)
+		sysfatal("out of memory: %r");
+
+	if (plsconfirm? confirm(&src, &dest): Yes)
+		copyfile(&src, &dest, atoll(argv[0]), plsverify);
+	exits(src.harderrs || dest.harderrs? "hard errors": 0);
+}