ref: 07d3d9bf0c69d4beb4555c9054f455f7181c34c5
dir: /sys/src/cmd/ecp.c/
/*
* 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);
}