Return to copy.c CVS log

Up to [Research Unix] / researchv10dc / cmd / oworm / scsi

Annotation of researchv10dc/cmd/oworm/scsi/copy.c, revision 1.1.1.1

1.1       root        1: #include       "scsi.h"
                      2: #include       "worm.h"
                      3: 
                      4: s_copy(sdr, sbase, nblocks, ddr, dbase)
                      5: {
                      6:        struct scsi_o o;
                      7:        char buf[256];
                      8:        int wr, unwr;
                      9:        int n;
                     10:        long nb = nblocks;
                     11:        long t1, t2;
                     12:        long goo;
                     13: #define                TALK            10000
                     14:        extern char *ctime();
                     15: 
                     16:        fprint(1, "copying drive %d[%d-%d] to drive %d[%d-%d]\n", sdr,
                     17:                sbase, sbase+nblocks-1, ddr, dbase, dbase+nblocks-1);
                     18:        time(&t1);
                     19:        goo = sbase/TALK;
                     20:        while(nblocks > 0){
                     21:                if(sbase/TALK != goo){
                     22:                        goo = sbase/TALK;
                     23:                        time(&t2);
                     24:                        print("doing block %ld at %s", goo*TALK, ctime(&t2));
                     25:                }
                     26:                n = min(256, nblocks);
                     27:                wr = s_wsearch(sdr, sbase, n);
                     28:                if(wr < 0)
                     29:                        break;
                     30:                if(wr == n){
                     31:                        sbase += n;
                     32:                        dbase += n;
                     33:                        nblocks -= n;
                     34:                        continue;
                     35:                }
                     36:                sbase += wr;
                     37:                dbase += wr;
                     38:                n -= wr;        /* number of blocks */
                     39:                nblocks -= wr;
                     40:                unwr = s_bsearch(sdr, sbase, n);
                     41:                if(unwr < 0)
                     42:                        break;
                     43:                /*print("writing %d-%d\n", sbase, sbase+unwr-1);/**/
                     44:                if(s_copy1(sdr, sbase, unwr, ddr, dbase))
                     45:                        break;
                     46:                sbase += unwr;
                     47:                dbase += unwr;
                     48:                nblocks -= unwr;
                     49:        }
                     50:        time(&t2);
                     51:        t2 -= t1;
                     52:        if(t2 == 0) t2 = 1;
                     53:        fprint(1, "%ds: ", t2);
                     54:        if(nblocks){
                     55:                fprint(1, "copy buggered up: sbase=%d nblks=%d dbase=%d\n",
                     56:                        sbase, nblocks, dbase);
                     57:                return(1);
                     58:        }
                     59:        fprint(1, "%d blocks at %.1fKB/s\n", nb, nb/(float)t2);
                     60:        return(0);
                     61: }
                     62: 
                     63: s_copy1(sd, sb, n, dd, db)
                     64: {
                     65:        struct scsi_i input;
                     66:        struct scsi_o o;
                     67: 
                     68:        input.bus_id = scsi_id;
                     69:        input.cmd[0] = 0x18;
                     70:        input.cmd[1] = sd<<5;
                     71:        input.cmd[2] = 0;
                     72:        input.cmd[3] = 0;
                     73:        input.cmd[4] = 20;
                     74:        input.cmd[5] = 0;
                     75:        input.data[0] = 0x10;   /* copy */
                     76:        input.data[1] = 0;
                     77:        input.data[2] = 0;
                     78:        input.data[3] = 0;
                     79:        input.data[4] = (scsi_id<<5)|sd;
                     80:        input.data[5] = (scsi_id<<5)|dd;
                     81:        input.data[6] = 0;
                     82:        input.data[7] = 0;
                     83:        input.data[8] = n>>24;
                     84:        input.data[9] = n>>16;
                     85:        input.data[10] = n>>8;
                     86:        input.data[11] = n;
                     87:        input.data[12] = sb>>24;
                     88:        input.data[13] = sb>>16;
                     89:        input.data[14] = sb>>8;
                     90:        input.data[15] = sb;
                     91:        input.data[16] = db>>24;
                     92:        input.data[17] = db>>16;
                     93:        input.data[18] = db>>8;
                     94:        input.data[19] = db;
                     95:        if(scsiio(&input, 20, &o, 0, "media") < 0)
                     96:                return(1);
                     97:        if(CHECK(o)){
                     98:                prcheck(1, &o);
                     99:                s_sense(sd, 1);
                    100:                return(1);
                    101:        }
                    102:        return(0);
                    103: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.