Return to copy.c CVS log

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

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

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