/*
* 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);
}

You are viewing proxied material from sdf.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.