Return to copy.c CVS log

Up to [Research Unix] / researchv10dc / cmd / worm / oscsi / generic

Annotation of researchv10dc/cmd/worm/oscsi/generic/copy.c, revision 1.1.1.1

1.1       root        1: #include       <stdio.h>
                      2: #include       "../scsi.h"
                      3: #include       "../scsish.h"
                      4: #include       "fns.h"
                      5: 
                      6: #define        PROGRESS        \
                      7:                if(sbase/TALK != goo){\
                      8:                        goo = sbase/TALK;\
                      9:                        time(&t2);\
                     10:                        printf("\tdoing block %ld at %s", goo*TALK, ctime(&t2));\
                     11:                }
                     12: 
                     13: static int copy1(int, int, int, int, int, int, int, char *);
                     14: 
                     15: int
                     16: gen_copy(int niargs, int *iargs, int ncargs, char **cargs, char *err)
                     17: {
                     18:        int n;
                     19:        int sdr = 0;
                     20:        int sbase = iargs[1];
                     21:        int nblocks = iargs[2];
                     22:        int ddr = 0;
                     23:        int dbase = iargs[4];
                     24:        int starget = iargs[0];
                     25:        int dtarget = iargs[3];
                     26:        int block = 256;
                     27:        long nb = nblocks;
                     28:        long t1, t2;
                     29:        long goo;
                     30: 
                     31: #define                TALK            10000
                     32:        extern char *ctime();
                     33: 
                     34: #pragma ref ncargs
                     35: #pragma ref cargs
                     36: 
                     37:        if(niargs == 6)
                     38:                block = iargs[5];
                     39:        printf("copying drive (%d,%d)[%d-%d] to drive (%d,%d)[%d-%d] blk=%dK\n",
                     40:                starget, sdr, sbase, sbase+nblocks-1,
                     41:                dtarget, ddr, dbase, dbase+nblocks-1, block);
                     42:        time(&t1);
                     43:        goo = -1;
                     44:        while(nblocks > 0){
                     45:                n = min(block, nblocks);
                     46:                printf("writing %d-%d\n", sbase, sbase+n-1);/**/
                     47:                if(copy1(starget, sdr, sbase, n, dtarget, ddr, dbase, err))
                     48:                        break;
                     49:                sbase += n;
                     50:                dbase += n;
                     51:                nblocks -= n;
                     52:                PROGRESS
                     53:        }
                     54:        time(&t2);
                     55:        t2 -= t1;
                     56:        if(t2 == 0) t2 = 1;
                     57:        printf("%ds: ", t2);
                     58:        if(nblocks){
                     59:                printf("copy buggered up: sbase=%d nblks=%d dbase=%d\n",
                     60:                        sbase, nblocks, dbase);
                     61:                return(1);
                     62:        }
                     63:        printf("%d blocks at %.1fKB/s\n", nb, nb/(float)t2);
                     64:        return(0);
                     65: }
                     66: 
                     67: static int
                     68: copy1(int st, int sd, int sb, int n, int dt, int dd, int db, char *err)
                     69: {
                     70:        struct scsi_cmd cmd;
                     71:        struct scsi_return ret;
                     72: 
                     73:        set6(cmd, 0x18, sd<<5, 0, 0, 20, 0);
                     74:        cmd.data[0] = 0x10;     /* copy */
                     75:        cmd.data[1] = 0;
                     76:        cmd.data[2] = 0;
                     77:        cmd.data[3] = 0;
                     78:        cmd.data[4] = (st<<5)|sd;
                     79:        cmd.data[5] = (dt<<5)|dd;
                     80:        cmd.data[6] = 0;
                     81:        cmd.data[7] = 0;
                     82:        cmd.data[8] = n>>24;
                     83:        cmd.data[9] = n>>16;
                     84:        cmd.data[10] = n>>8;
                     85:        cmd.data[11] = n;
                     86:        cmd.data[12] = sb>>24;
                     87:        cmd.data[13] = sb>>16;
                     88:        cmd.data[14] = sb>>8;
                     89:        cmd.data[15] = sb;
                     90:        cmd.data[16] = db>>24;
                     91:        cmd.data[17] = db>>16;
                     92:        cmd.data[18] = db>>8;
                     93:        cmd.data[19] = db;
                     94:        return(s_io(0, &cmd, 20, &ret, 0, err));
                     95: }

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