![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to owcopy.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / worm|
Return to owcopy.c CVS log | Up to [Research Unix] / researchv10no / cmd / worm |
1.1 root 1: #include <libc.h>
2: #include "worm.h"
3: #include "sym.h"
4: #include <sys/types.h>
5: #include <sys/stat.h>
6: #include <pwd.h>
7: #include <grp.h>
8:
9: char *timenow();
10: long minfree = 40000;
11: int verbose = 0;
12: static char *copy();
13:
14: main(argc, argv)
15: char **argv;
16: {
17: char *e;
18: char *dev = "/dev/worm0";
19: char *dest = 0;
20: Superblock in, out;
21: long start = 1;
22: long count = 1000000L;
23: int c;
24: extern char *optarg;
25: extern int optind;
26: void pr();
27:
28: while((c = getopt(argc, argv, "vc:m:s:f:")) != -1)
29: switch(c)
30: {
31: case 'c': count = atol(optarg); break;
32: case 'f': dev = optarg; break;
33: case 'm': minfree = atol(optarg); break;
34: case 's': start = atol(optarg); break;
35: case 'v': verbose = 1; break;
36: case '?': usage();
37: }
38: dev = mapdev(dev);
39: if((in.fd = open(dev, 0)) < 0){
40: perror(dev);
41: exit(1);
42: }
43: if(optind+3 != argc)
44: usage();
45:
46: if(e = openinode(&in, SPIN_DOWN)){
47: fprint(2, "worm copy: %s: %s\n", dev, e);
48: exit(1);
49: }
50: if(strcmp(argv[optind], in.vol_id)){
51: fprint(2, "src vol_id mismatch: expected %s, got %s\n",
52: argv[optind], in.vol_id);
53: exit(1);
54: }
55: dest = mapdev(argv[optind+1]);
56: if((out.fd = open(dest, 2)) < 0){
57: perror(dest);
58: exit(1);
59: }
60: if(e = openinode(&out, SPIN_DOWN)){
61: fprint(2, "worm copy: %s: %s\n", dest, e);
62: exit(1);
63: }
64: if(strcmp(argv[optind+2], out.vol_id)){
65: fprint(2, "destination vol_id mismatch: expected %s, got %s\n",
66: argv[optind+2], out.vol_id);
67: exit(1);
68: }
69: if(e = copy(&in, start, count, &out)){
70: fprint(2, "worm copy: %s: %s\n", dest, e);
71: exit(1);
72: }
73: exit(0);
74: }
75:
76: usage()
77: {
78: fprint(2, "Usage: worm copy [-v] [-fdevice] [-s startblk] [-c count] [-m minfree] srcvolid destdev destvolid\n");
79: exit(2);
80: }
81:
82: static char *
83: copy(in, blk, count, out)
84: register Superblock *in, *out;
85: long blk, count;
86: {
87: register Inode *i;
88: short fd = in->fd;
89: char *b, *err;
90: long nb, ndata;
91: char *nameb;
92: Inode *inodes = 0;
93: Inode *iend;
94: long delta;
95: static char buf[64];
96: extern char *lkwri();
97:
98: in->blocksize = 1024;
99: if((b = malloc(in->blocksize)) == 0){
100: sprint(buf, "couldn't malloc buffer (%d bytes)", in->blocksize);
101: return(buf);
102: }
103: Seek(in, blk);
104: if(Read(in, b, 1)){
105: fprint(2, "worm copy: unexpected read error\n");
106: exit(1);
107: }
108: *in = *((Superblock *)b);
109: in->fd = fd;
110: while(count-- > 0){
111: if(in->magic != SMAGIC){
112: fprint(2, "bad Superblock at %ld\n", blk);
113: exit(1);
114: }
115: if(in->ninodes){
116: if(verbose)
117: fprint(2, "%s reading chunk %s:%ld (%.1f%%)\n",
118: timenow(), in->vol_id, in->myblock,
119: in->myblock*100./(float)in->nblocks);
120: if(out->nfree < minfree){
121: fprint(2, "worm copy: disk %s has < %d free at input %d\n",
122: out->vol_id, minfree, in->myblock);
123: exit(1);
124: }
125: nb = (in->ninodes+(in->blocksize/sizeof(Inode))-1)/(in->blocksize/sizeof(Inode));
126: inodes = (Inode *)malloc((unsigned)(in->blocksize*nb));
127: if(inodes == 0){
128: sprint(buf, "inode malloc(%d) fail, sbrk=%d\n",
129: (in->blocksize*nb), sbrk(0));
130: return(buf);
131: }
132: Seek(in, in->binodes);
133: if(Read(in, (char *)inodes, nb))
134: goto skip;
135: delta = out->nextffree - inodes->block;
136: print("%d inodes; delta=%d\n", in->ninodes, delta);
137: for(i = inodes, iend = inodes+in->ninodes; i < iend; i++)
138: if(i->block > 0)
139: i->block += delta;
140: nb = (in->ninochars+in->blocksize-1)/in->blocksize;
141: nameb = malloc((unsigned)(in->blocksize*nb));
142: if(nameb == 0){
143: sprint(buf, "name buffer malloc(%d) fail, sbrk=%d\n",
144: (in->blocksize*nb), sbrk(0));
145: return(buf);
146: }
147: if(Read(in, nameb, nb))
148: goto skip;
149: ndata = in->binodes - in->myblock - 1;
150: if(err = lkwri(out, inodes, in->ninodes, nameb, in->ninochars, ndata)){
151: fprint(2, "wcopy: lkwri: %s at input %d\n", err, in->myblock);
152: exit(1);
153: }
154: dcopy(in, out, ndata);
155: }
156: skip:
157: blk = in->nextsb;
158: Seek(in, blk);
159: if(Read(in, b, 1L))
160: break;
161: *in = *((Superblock *)b);
162: in->fd = fd;
163: if(in->myblock == 0)
164: in->myblock = blk;
165: }
166: free(b);
167: if(verbose)
168: fprint(2, "%s copy done, %s is %.1f%% full\n", timenow(), out->vol_id,
169: out->myblock*100.0/(float)out->nblocks);
170: return((char *)0);
171: }
172:
173: dcopy(in, out, n)
174: Superblock *in, *out;
175: long n;
176: {
177: char buf[BIGBLOCK];
178: long bs;
179:
180: bs = BIGBLOCK/in->blocksize;
181: Seek(in, in->myblock+1);
182: Seek(out, out->myblock+1);
183: while(n > 0){
184: if(bs > n) bs = n;
185: if(Read(in, buf, bs)){
186: fprint(2, "wcopy: warning: data read error at %d\n", in->myblock);
187: }
188: if(Write(out, buf, bs)){
189: fprint(2, "wcopy: dcopy write error\n");
190: exit(1);
191: }
192: n -= bs;
193: }
194: }
195:
196: char *
197: timenow()
198: {
199: long tim;
200: char *tims;
201:
202: time(&tim);
203: tims = ctime(&tim);
204: tims[19] = 0;
205: return(tims);
206: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.