![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dumptraverse.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / old / dump.4.1|
Return to dumptraverse.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / old / dump.4.1 |
1.1 root 1: /*
2: * Copyright (c) 1980 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: */
6:
7: #ifndef lint
8: static char sccsid[] = "@(#)dumptraverse.c 5.1 (Berkeley) 6/5/85";
9: #endif not lint
10:
11: #include "dump.h"
12:
13: struct filsys sblock;
14: struct dinode itab[INOPB * NI];
15:
16: pass(fn, map)
17: int (*fn)();
18: short *map;
19: {
20: register i, j;
21: int bits;
22: ino_t mino;
23: daddr_t d;
24:
25: sync();
26: bread((daddr_t)1, (char *)&sblock, sizeof(sblock));
27: mino = (sblock.s_isize-2) * INOPB;
28: ino = 0;
29: for(i=2;; i+=NI) {
30: if(ino >= mino)
31: break;
32: d = (unsigned)i;
33: for(j=0; j<INOPB*NI; j++) {
34: if(ino >= mino)
35: break;
36: if((ino % MLEN) == 0) {
37: bits = ~0;
38: if(map != NULL)
39: bits = *map++;
40: }
41: ino++;
42: if(bits & 1) {
43: if(d != 0) {
44: bread(d, (char *)itab, sizeof(itab));
45: d = 0;
46: }
47: (*fn)(&itab[j]);
48: }
49: bits >>= 1;
50: }
51: }
52: }
53:
54: icat(ip, fn1, fn2)
55: struct dinode *ip;
56: int (*fn1)(), (*fn2)();
57: {
58: register i;
59: daddr_t d[NADDR];
60:
61: l3tol(&d[0], &ip->di_addr[0], NADDR);
62: (*fn2)(d, NADDR-3);
63: for(i=0; i<NADDR; i++) {
64: if(d[i] != 0) {
65: if(i < NADDR-3)
66: (*fn1)(d[i]); else
67: indir(d[i], fn1, fn2, i-(NADDR-3));
68: }
69: }
70: }
71:
72: indir(d, fn1, fn2, n)
73: daddr_t d;
74: int (*fn1)(), (*fn2)();
75: {
76: register i;
77: daddr_t idblk[NINDIR];
78:
79: bread(d, (char *)idblk, sizeof(idblk));
80: if(n <= 0) {
81: spcl.c_type = TS_ADDR;
82: (*fn2)(idblk, NINDIR);
83: for(i=0; i<NINDIR; i++) {
84: d = idblk[i];
85: if(d != 0)
86: (*fn1)(d);
87: }
88: } else {
89: n--;
90: for(i=0; i<NINDIR; i++) {
91: d = idblk[i];
92: if(d != 0)
93: indir(d, fn1, fn2, n);
94: }
95: }
96: }
97:
98: mark(ip)
99: struct dinode *ip;
100: {
101: register f;
102:
103: f = ip->di_mode & IFMT;
104: if(f == 0)
105: return;
106: BIS(ino, clrmap);
107: if(f == IFDIR)
108: BIS(ino, dirmap);
109: if(ip->di_mtime >= spcl.c_ddate ||
110: ip->di_ctime >= spcl.c_ddate) {
111: BIS(ino, nodmap);
112: if (f != IFREG){
113: esize += 1;
114: return;
115: }
116: est(ip);
117: }
118: }
119:
120: add(ip)
121: struct dinode *ip;
122: {
123:
124: if(BIT(ino, nodmap))
125: return;
126: nsubdir = 0;
127: dadded = 0;
128: icat(ip, dsrch, nullf);
129: if(dadded) {
130: BIS(ino, nodmap);
131: est(ip);
132: nadded++;
133: }
134: if(nsubdir == 0)
135: if(!BIT(ino, nodmap))
136: BIC(ino, dirmap);
137: }
138:
139: dump(ip)
140: struct dinode *ip;
141: {
142: register i;
143:
144: if(newtape) {
145: newtape = 0;
146: bitmap(nodmap, TS_BITS);
147: }
148: BIC(ino, nodmap);
149: spcl.c_dinode = *ip;
150: spcl.c_type = TS_INODE;
151: spcl.c_count = 0;
152: i = ip->di_mode & IFMT;
153: if(i != IFDIR && i != IFREG) {
154: spclrec();
155: return;
156: }
157: icat(ip, tapsrec, dmpspc);
158: }
159:
160: dmpspc(dp, n)
161: daddr_t *dp;
162: {
163: register i, t;
164:
165: spcl.c_count = n;
166: for(i=0; i<n; i++) {
167: t = 0;
168: if(dp[i] != 0)
169: t++;
170: spcl.c_addr[i] = t;
171: }
172: spclrec();
173: }
174:
175: bitmap(map, typ)
176: short *map;
177: {
178: register i, n;
179: char *cp;
180:
181: n = -1;
182: for(i=0; i<MSIZ; i++)
183: if(map[i])
184: n = i;
185: if(n < 0)
186: return;
187: spcl.c_type = typ;
188: spcl.c_count = (n*sizeof(map[0]) + BSIZE)/BSIZE;
189: spclrec();
190: cp = (char *)map;
191: for(i=0; i<spcl.c_count; i++) {
192: taprec(cp);
193: cp += BSIZE;
194: }
195: }
196:
197: spclrec()
198: {
199: register i, *ip, s;
200:
201: spcl.c_inumber = ino;
202: spcl.c_magic = MAGIC;
203: spcl.c_checksum = 0;
204: ip = (int *)&spcl;
205: s = 0;
206: for(i=0; i<BSIZE/sizeof(*ip); i++)
207: s += *ip++;
208: spcl.c_checksum = CHECKSUM - s;
209: taprec((char *)&spcl);
210: }
211:
212: dsrch(d)
213: daddr_t d;
214: {
215: register char *cp;
216: register i;
217: register ino_t in;
218: struct direct dblk[DIRPB];
219:
220: if(dadded)
221: return;
222: bread(d, (char *)dblk, sizeof(dblk));
223: for(i=0; i<DIRPB; i++) {
224: in = dblk[i].d_ino;
225: if(in == 0)
226: continue;
227: cp = dblk[i].d_name;
228: if(cp[0] == '.') {
229: if(cp[1] == '\0')
230: continue;
231: if(cp[1] == '.' && cp[2] == '\0')
232: continue;
233: }
234: if(BIT(in, nodmap)) {
235: dadded++;
236: return;
237: }
238: if(BIT(in, dirmap))
239: nsubdir++;
240: }
241: }
242:
243: nullf()
244: {
245: }
246:
247: int breaderrors = 0;
248: #define BREADEMAX 32
249:
250: bread(da, ba, c)
251: daddr_t da;
252: char *ba;
253: int c;
254: {
255: register n;
256: register regc;
257:
258: if (lseek(fi, (long)(da*BSIZE), 0) < 0){
259: msg("bread: lseek fails\n");
260: }
261: regc = c; /* put c someplace safe; it gets clobbered */
262: n = read(fi, ba, c);
263: if(n != c || regc != c){
264: msg("(This should not happen)bread from %s [block %d]: c=0x%x, regc=0x%x, &c=0x%x, n=0x%x\n",
265: disk, da, c, regc, &c, n);
266: #ifdef ERNIE
267: msg("Notify Robert Henry of this error.\n");
268: #endif
269: if (++breaderrors > BREADEMAX){
270: msg("More than %d block read errors from %d\n",
271: BREADEMAX, disk);
272: broadcast("DUMP IS AILING!\n");
273: msg("This is an unrecoverable error.\n");
274: if (!query("Do you want to attempt to continue?")){
275: dumpabort();
276: /*NOTREACHED*/
277: } else
278: breaderrors = 0;
279: }
280: }
281: }
282:
283: CLR(map)
284: register short *map;
285: {
286: register n;
287:
288: n = MSIZ;
289: do
290: *map++ = 0;
291: while(--n);
292: }
293:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.