![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to copy.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / cmd / worm / oscsi / sony|
Return to copy.c CVS log | Up to [Research Unix] / researchv10dc / cmd / worm / oscsi / sony |
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 char good[256]; /* by default, all BAD */
14: typedef enum { BAD = 0, GOOD } Searchtype;
15: static int copy1(int, int, int, int, int, int, int, char *);
16: static int search(int, int, int, int, Searchtype, char *);
17:
18: int
19: sony_copy(int niargs, int *iargs, int ncargs, char **cargs, char *err)
20: {
21: int n;
22: int sdr = iargs[0];
23: int sbase = iargs[1];
24: int nblocks = iargs[2];
25: int ddr = iargs[3];
26: int dbase = iargs[4];
27: int starget = s_id;
28: int dtarget = s_id;
29: int wr, unwr;
30: long nb = nblocks;
31: long t1, t2;
32: long goo;
33: int lower;
34: struct scsi_return ret;
35: #define TALK 10000
36: extern char *ctime();
37:
38: #pragma ref niargs
39: #pragma ref ncargs
40: #pragma ref cargs
41:
42: printf("copying drive (%d,%d)[%d-%d] to drive (%d,%d)[%d-%d]\n",
43: starget, sdr, sbase, sbase+nblocks-1,
44: dtarget, ddr, dbase, dbase+nblocks-1);
45: if(sony_istatus(&ret, err))
46: return(1);
47: if((ret.data[100]&0x80) && (sdr == (ret.data[100]&7)))
48: lower = 0;
49: else if((ret.data[101]&0x80) && (sdr == (ret.data[101]&7)))
50: lower = 1;
51: else {
52: sprintf(err, "drive %d not occupied\n", sdr);
53: return(1);
54: }
55: good[0] = good[0x81] = good[0x82] = good[0x83] = GOOD;
56: time(&t1);
57: goo = -1;
58: while(nblocks > 0){
59: /* search for a block to copy */
60: while(n = min(256, nblocks)){
61: wr = search(sdr, lower, sbase, n, GOOD, err);
62: if(wr < 0)
63: break;
64: sbase += wr;
65: dbase += wr;
66: nblocks -= wr;
67: if(wr < n)
68: break;
69: PROGRESS
70: }
71: /* now copy until the first bad block */
72: while(n = min(256, nblocks)){
73: unwr = search(sdr, lower, sbase, n, BAD, err);
74: if(unwr < 0)
75: break;
76: /*printf("writing %d-%d\n", sbase, sbase+unwr-1);/**/
77: if(copy1(starget, sdr, sbase, unwr, dtarget, ddr, dbase, err))
78: break;
79: sbase += unwr;
80: dbase += unwr;
81: nblocks -= unwr;
82: PROGRESS
83: }
84: }
85: time(&t2);
86: t2 -= t1;
87: if(t2 == 0) t2 = 1;
88: printf("%ds: ", t2);
89: if(nblocks){
90: printf("copy buggered up: sbase=%d nblks=%d dbase=%d\n",
91: sbase, nblocks, dbase);
92: return(1);
93: }
94: printf("%d blocks at %.1fKB/s\n", nb, nb/(float)t2);
95: return(0);
96: }
97:
98: static int
99: copy1(int st, int sd, int sb, int n, int dt, int dd, int db, char *err)
100: {
101: struct scsi_cmd cmd;
102: struct scsi_return ret;
103:
104: set6(cmd, 0x18, sd<<5, 0, 0, 20, 0);
105: cmd.data[0] = 0x10; /* copy */
106: cmd.data[1] = 0;
107: cmd.data[2] = 0;
108: cmd.data[3] = 0;
109: cmd.data[4] = (st<<5)|sd;
110: cmd.data[5] = (dt<<5)|dd;
111: cmd.data[6] = 0;
112: cmd.data[7] = 0;
113: cmd.data[8] = n>>24;
114: cmd.data[9] = n>>16;
115: cmd.data[10] = n>>8;
116: cmd.data[11] = n;
117: cmd.data[12] = sb>>24;
118: cmd.data[13] = sb>>16;
119: cmd.data[14] = sb>>8;
120: cmd.data[15] = sb;
121: cmd.data[16] = db>>24;
122: cmd.data[17] = db>>16;
123: cmd.data[18] = db>>8;
124: cmd.data[19] = db;
125: return(s_io(0, &cmd, 20, &ret, 0, err));
126: }
127:
128: static int
129: search(int dr, int lower, int sbase, int n, Searchtype s, char *err)
130: {
131: uchar *cp;
132: struct scsi_return ret;
133:
134: if(n <= 0)
135: return(0);
136: if(n > 256)
137: n = 256;
138: if(sony_media1(dr, sbase, lower, &ret, err))
139: return(-1);
140: for(cp = ret.data; n-- > 0; cp++)
141: if(good[*cp] != s)
142: break;
143: return(cp-ret.data);
144: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.