![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to copyout.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / undoc|
Return to copyout.c CVS log | Up to [CSRG BSD Unix] / 42BSD / undoc |
1.1 root 1: #include <stdio.h>
2: #include <sys/param.h>
3: #include <sys/systm.h>
4: #include <sys/dir.h>
5: #include <sys/user.h>
6: #include <sys/vm.h>
7: #include <sys/proc.h>
8: #include <sys/pte.h>
9: #include <sys/cmap.h>
10: #include <sys/inode.h>
11: #include <sys/buf.h>
12: #include <sys/text.h>
13: #include <sys/ino.h>
14:
15: struct buf *bread();
16: struct buf b;
17: char bc[BSIZE];
18: int bflag;
19:
20: main(argc, argv)
21: char *argv[];
22: {
23: struct dinode di;
24: struct inode i;
25: struct proc p;
26: struct user u;
27: struct text x;
28: struct pte *pte;
29: int j,k,l;
30:
31: if (argc > 1 && !strcmp(argv[1], "-b"))
32: argc--, argv++, bflag++;
33: if (argc != 3) {
34: fprintf(stderr, "usage: copyout [ -b ] inum disk\n");
35: exit(1);
36: }
37: close(0);
38: if (open(argv[2], 0) != 0) {
39: perror(argv[2]);
40: exit(1);
41: }
42: lseek(0, itod(atoi(argv[1])) * BSIZE + itoo(atoi(argv[1])) * sizeof (di), 0);
43: if (read(0, &di, sizeof (di)) != sizeof (di)) {
44: fprintf(stderr, "error reading inode ");
45: perror(argv[1]);
46: exit(1);
47: }
48: i.i_dev = 0;
49: i.i_number = atoi(argv[1]);
50: i.i_flag = ILOCK;
51: i.i_count = 1;
52: i.i_un.i_lastr = 0;
53: i.i_mode = di.di_mode;
54: i.i_nlink = di.di_nlink;
55: i.i_uid = di.di_uid;
56: i.i_size = di.di_size;
57: l3tol(i.i_un.i_addr, di.di_addr, NADDR);
58: p.p_textp = &x;
59: x.x_iptr = &i;
60: b.b_un.b_addr = bc;
61: pte = (struct pte *)calloc(btoc(i.i_size), sizeof (struct pte));
62: if (pte == NULL) {
63: fprintf(stderr, "Not enough core for block pointers\n");
64: exit(1);
65: }
66: vinizfod(&p, pte, 0, (btoc(i.i_size)+(CLSIZE-1)) / CLSIZE);
67: l = i.i_size;
68: for (j = 0; j < (btoc(i.i_size)+(CLSIZE-1)) / CLSIZE; j++)
69: if (bflag)
70: printf("#%d: block %d\n", j, pte[j].pg_pfnum);
71: else {
72: k = imin(l, BSIZE);
73: write(1, bread(0, pte[j].pg_pfnum)->b_un.b_words, k);
74: brelse(&b);
75: l -= BSIZE;
76: }
77: exit(0);
78: }
79:
80: int bused;
81:
82: struct buf *
83: bread(dev, blk)
84: {
85:
86: if (bused)
87: abort();
88: bused = 1;
89: printf("getblk %x\n", blk);
90: lseek(0, blk * BSIZE, 0);
91: if (read(0, b.b_un.b_addr, BSIZE) != BSIZE) {
92: printf("block %d: ", blk);
93: perror("bread");
94: }
95: return (&b);
96: }
97:
98: brelse(bp)
99: struct buf *bp;
100: {
101:
102: if (bp != &b)
103: abort();
104: bused = 0;
105: }
106:
107: struct buf *vbmap();
108: /*
109: * Initialize the page tables for paging from an inode,
110: * by scouring up the indirect blocks in order.
111: */
112: vinizfod(p, pte, bstart, count)
113: struct proc *p;
114: register struct pte *pte;
115: daddr_t bstart;
116: int count;
117: {
118: register struct inode *ip = p->p_textp->x_iptr;
119: register int i;
120: struct buf *bp;
121: int indx;
122: register daddr_t *pp;
123:
124: while (count > 0) {
125: if (bstart < NADDR - 3) {
126: pte++->pg_pfnum = ip->i_un.i_addr[bstart];
127: bstart++;
128: count--;
129: } else {
130: bp = vbmap(ip, bstart);
131: indx = (bstart - (NADDR - 3)) % NINDIR;
132: i = imin(NINDIR - indx, count);
133: bstart += i;
134: count -= i;
135: if (bp) {
136: pp = &bp->b_un.b_daddr[indx];
137: do
138: pte++->pg_pfnum = *pp++;
139: while (--i > 0);
140: brelse(bp);
141: } else
142: pte += i;
143: }
144: }
145: }
146:
147: /*
148: * Vbmap returns a block full of indirect pointers for a given block offset
149: * in a file. It returns 0 if a missing address block was encountered,
150: * in which case the pages can be normal zfod pages.
151: */
152: struct buf *
153: vbmap(ip, bn)
154: register struct inode *ip;
155: daddr_t bn;
156: {
157: register i;
158: struct buf *bp;
159: int j, sh;
160: daddr_t nb;
161: dev_t dev = ip->i_dev;
162:
163: if (bn < NADDR-3)
164: panic("vbmap");
165:
166: /*
167: * addresses NADDR-3, NADDR-2, and NADDR-1
168: * have single, double, triple indirect blocks.
169: * the first step is to determine
170: * how many levels of indirection.
171: */
172: sh = 0;
173: nb = 1;
174: bn -= NADDR-3;
175: for (j = 3; j > 0; j--) {
176: sh += NSHIFT;
177: nb <<= NSHIFT;
178: if(bn < nb)
179: break;
180: bn -= nb;
181: }
182: if (j == 0)
183: goto noblk;
184:
185: /*
186: * fetch the address from the inode
187: */
188: nb = ip->i_un.i_addr[NADDR-j];
189:
190: /*
191: * fetch through the indirect blocks
192: */
193: for (;;) {
194: if (nb == 0)
195: return ((daddr_t)0);
196: bp = bread(dev, nb);
197: if (bp->b_flags & B_ERROR) {
198: brelse(bp);
199: goto noblk;
200: }
201: if (j == 3)
202: break;
203: j++;
204: sh -= NSHIFT;
205: i = (bn>>sh) & NMASK;
206: nb = bp->b_un.b_daddr[i];
207: brelse(bp);
208: if (nb == 0)
209: goto noblk;
210: }
211: return (bp);
212:
213: noblk:
214: return ((struct buf *)0);
215: }
216:
217: imin(a,b)
218: {
219: return (a<b?a:b);
220: }
221:
222: panic(cp)
223: {
224: printf(cp);
225: abort();
226: }
227:
228: char vmmap[1];
229: char version[1];
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.