![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mkproto.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / etc|
Return to mkproto.c CVS log | Up to [CSRG BSD Unix] / 42BSD / etc |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)mkproto.c 4.4 (Berkeley) 8/11/83";
3: #endif
4:
5: /*
6: * Make a file system prototype.
7: * usage: mkproto filsys proto
8: */
9: #include <stdio.h>
10: #include <sys/param.h>
11: #include <sys/inode.h>
12: #include <sys/fs.h>
13: #include <sys/dir.h>
14:
15: union {
16: struct fs fs;
17: char fsx[SBSIZE];
18: } ufs;
19: #define sblock ufs.fs
20: union {
21: struct cg cg;
22: char cgx[MAXBSIZE];
23: } ucg;
24: #define acg ucg.cg
25: struct fs *fs;
26: struct csum *fscs;
27: int fso, fsi;
28: FILE *proto;
29: char token[BUFSIZ];
30: int errs;
31: int ino = 10;
32: long getnum();
33: char *strcpy();
34:
35: main(argc, argv)
36: int argc;
37: char *argv[];
38: {
39: int i;
40:
41: if (argc != 3) {
42: fprintf(stderr, "usage: mkproto filsys proto\n");
43: exit(1);
44: }
45: fso = open(argv[1], 1);
46: fsi = open(argv[1], 0);
47: if (fso < 0 || fsi < 0) {
48: perror(argv[1]);
49: exit(1);
50: }
51: fs = &sblock;
52: rdfs(SBLOCK, SBSIZE, (char *)fs);
53: fscs = (struct csum *)calloc(1, fs->fs_cssize);
54: for (i = 0; i < fs->fs_cssize; i += fs->fs_bsize)
55: rdfs(fsbtodb(fs, fs->fs_csaddr + numfrags(fs, i)),
56: (int)(fs->fs_cssize - i < fs->fs_bsize ?
57: fs->fs_cssize - i : fs->fs_bsize),
58: ((char *)fscs) + i);
59: proto = fopen(argv[2], "r");
60: descend((struct inode *)0);
61: wtfs(SBLOCK, SBSIZE, (char *)fs);
62: for (i = 0; i < fs->fs_cssize; i += fs->fs_bsize)
63: wtfs(fsbtodb(&sblock, fs->fs_csaddr + numfrags(&sblock, i)),
64: (int)(fs->fs_cssize - i < fs->fs_bsize ?
65: fs->fs_cssize - i : fs->fs_bsize),
66: ((char *)fscs) + i);
67: exit(errs);
68: }
69:
70: descend(par)
71: struct inode *par;
72: {
73: struct inode in;
74: int ibc = 0;
75: int i, f, c;
76: struct dinode *dip, inos[MAXBSIZE / sizeof (struct dinode)];
77: daddr_t ib[MAXBSIZE / sizeof (daddr_t)];
78: char buf[MAXBSIZE];
79:
80: getstr();
81: in.i_mode = gmode(token[0], "-bcd", IFREG, IFBLK, IFCHR, IFDIR);
82: in.i_mode |= gmode(token[1], "-u", 0, ISUID, 0, 0);
83: in.i_mode |= gmode(token[2], "-g", 0, ISGID, 0, 0);
84: for (i = 3; i < 6; i++) {
85: c = token[i];
86: if (c < '0' || c > '7') {
87: printf("%c/%s: bad octal mode digit\n", c, token);
88: errs++;
89: c = 0;
90: }
91: in.i_mode |= (c-'0')<<(15-3*i);
92: }
93: in.i_uid = getnum(); in.i_gid = getnum();
94: for (i = 0; i < fs->fs_bsize; i++)
95: buf[i] = 0;
96: for (i = 0; i < NINDIR(fs); i++)
97: ib[i] = (daddr_t)0;
98: in.i_nlink = 1;
99: in.i_size = 0;
100: for (i = 0; i < NDADDR; i++)
101: in.i_db[i] = (daddr_t)0;
102: for (i = 0; i < NIADDR; i++)
103: in.i_ib[i] = (daddr_t)0;
104: if (par != (struct inode *)0) {
105: ialloc(&in);
106: } else {
107: par = ∈
108: i = itod(fs, ROOTINO);
109: rdfs(fsbtodb(fs, i), fs->fs_bsize, (char *)inos);
110: dip = &inos[ROOTINO % INOPB(fs)];
111: in.i_number = ROOTINO;
112: in.i_nlink = dip->di_nlink;
113: in.i_size = dip->di_size;
114: in.i_db[0] = dip->di_db[0];
115: rdfs(fsbtodb(fs, in.i_db[0]), fs->fs_bsize, buf);
116: }
117:
118: switch (in.i_mode&IFMT) {
119:
120: case IFREG:
121: getstr();
122: f = open(token, 0);
123: if (f < 0) {
124: printf("%s: cannot open\n", token);
125: errs++;
126: break;
127: }
128: while ((i = read(f, buf, (int)fs->fs_bsize)) > 0) {
129: in.i_size += i;
130: newblk(buf, &ibc, ib, (int)blksize(fs, &in, ibc));
131: }
132: close(f);
133: break;
134:
135: case IFBLK:
136: case IFCHR:
137: /*
138: * special file
139: * content is maj/min types
140: */
141:
142: i = getnum() & 0377;
143: f = getnum() & 0377;
144: in.i_rdev = (i << 8) | f;
145: break;
146:
147: case IFDIR:
148: /*
149: * directory
150: * put in extra links
151: * call recursively until
152: * name of "$" found
153: */
154:
155: if (in.i_number != ROOTINO) {
156: par->i_nlink++;
157: in.i_nlink++;
158: entry(&in, in.i_number, ".", buf);
159: entry(&in, par->i_number, "..", buf);
160: }
161: for (;;) {
162: getstr();
163: if (token[0]=='$' && token[1]=='\0')
164: break;
165: entry(&in, (ino_t)(ino+1), token, buf);
166: descend(&in);
167: }
168: if (in.i_number != ROOTINO)
169: newblk(buf, &ibc, ib, (int)blksize(fs, &in, 0));
170: else
171: wtfs(fsbtodb(fs, in.i_db[0]), (int)fs->fs_bsize, buf);
172: break;
173: }
174: iput(&in, &ibc, ib);
175: }
176:
177: /*ARGSUSED*/
178: gmode(c, s, m0, m1, m2, m3)
179: char c, *s;
180: {
181: int i;
182:
183: for (i = 0; s[i]; i++)
184: if (c == s[i])
185: return((&m0)[i]);
186: printf("%c/%s: bad mode\n", c, token);
187: errs++;
188: return(0);
189: }
190:
191: long
192: getnum()
193: {
194: int i, c;
195: long n;
196:
197: getstr();
198: n = 0;
199: i = 0;
200: for (i = 0; c=token[i]; i++) {
201: if (c<'0' || c>'9') {
202: printf("%s: bad number\n", token);
203: errs++;
204: return((long)0);
205: }
206: n = n*10 + (c-'0');
207: }
208: return(n);
209: }
210:
211: getstr()
212: {
213: int i, c;
214:
215: loop:
216: switch (c = getc(proto)) {
217:
218: case ' ':
219: case '\t':
220: case '\n':
221: goto loop;
222:
223: case EOF:
224: printf("Unexpected EOF\n");
225: exit(1);
226:
227: case ':':
228: while (getc(proto) != '\n')
229: ;
230: goto loop;
231:
232: }
233: i = 0;
234: do {
235: token[i++] = c;
236: c = getc(proto);
237: } while (c != ' ' && c != '\t' && c != '\n' && c != '\0');
238: token[i] = 0;
239: }
240:
241: entry(ip, inum, str, buf)
242: struct inode *ip;
243: ino_t inum;
244: char *str;
245: char *buf;
246: {
247: register struct direct *dp, *odp;
248: int oldsize, newsize, spacefree;
249:
250: odp = dp = (struct direct *)buf;
251: while ((int)dp - (int)buf < ip->i_size) {
252: odp = dp;
253: dp = (struct direct *)((int)dp + dp->d_reclen);
254: }
255: if (odp != dp)
256: oldsize = DIRSIZ(odp);
257: else
258: oldsize = 0;
259: spacefree = odp->d_reclen - oldsize;
260: dp = (struct direct *)((int)odp + oldsize);
261: dp->d_ino = inum;
262: dp->d_namlen = strlen(str);
263: newsize = DIRSIZ(dp);
264: if (spacefree >= newsize) {
265: odp->d_reclen = oldsize;
266: dp->d_reclen = spacefree;
267: } else {
268: dp = (struct direct *)((int)odp + odp->d_reclen);
269: if ((int)dp - (int)buf >= fs->fs_bsize) {
270: printf("directory too large\n");
271: exit(1);
272: }
273: dp->d_ino = inum;
274: dp->d_namlen = strlen(str);
275: dp->d_reclen = DIRBLKSIZ;
276: }
277: strcpy(dp->d_name, str);
278: ip->i_size = (int)dp - (int)buf + newsize;
279: }
280:
281: newblk(buf, aibc, ib, size)
282: int *aibc;
283: char *buf;
284: daddr_t *ib;
285: int size;
286: {
287: int i;
288: daddr_t bno;
289:
290: bno = alloc(size);
291: wtfs(fsbtodb(fs, bno), (int)fs->fs_bsize, buf);
292: for (i = 0; i < fs->fs_bsize; i++)
293: buf[i] = 0;
294: ib[(*aibc)++] = bno;
295: if (*aibc >= NINDIR(fs)) {
296: printf("indirect block full\n");
297: errs++;
298: *aibc = 0;
299: }
300: }
301:
302: iput(ip, aibc, ib)
303: struct inode *ip;
304: int *aibc;
305: daddr_t *ib;
306: {
307: daddr_t d;
308: int i;
309: struct dinode buf[MAXBSIZE / sizeof (struct dinode)];
310:
311: ip->i_atime = ip->i_mtime = ip->i_ctime = time((long *)0);
312: switch (ip->i_mode&IFMT) {
313:
314: case IFDIR:
315: case IFREG:
316: for (i = 0; i < *aibc; i++) {
317: if (i >= NDADDR)
318: break;
319: ip->i_db[i] = ib[i];
320: }
321: if (*aibc > NDADDR) {
322: ip->i_ib[0] = alloc((int)fs->fs_bsize);
323: for (i = 0; i < NINDIR(fs) - NDADDR; i++) {
324: ib[i] = ib[i+NDADDR];
325: ib[i+NDADDR] = (daddr_t)0;
326: }
327: wtfs(fsbtodb(fs, ip->i_ib[0]),
328: (int)fs->fs_bsize, (char *)ib);
329: }
330: break;
331:
332: case IFBLK:
333: case IFCHR:
334: break;
335:
336: default:
337: printf("bad mode %o\n", ip->i_mode);
338: exit(1);
339: }
340: d = fsbtodb(fs, itod(fs, ip->i_number));
341: rdfs(d, (int)fs->fs_bsize, (char *)buf);
342: buf[itoo(fs, ip->i_number)].di_ic = ip->i_ic;
343: wtfs(d, (int)fs->fs_bsize, (char *)buf);
344: }
345:
346: daddr_t
347: alloc(size)
348: int size;
349: {
350: int i, frag;
351: daddr_t d;
352: static int cg = 0;
353:
354: again:
355: rdfs(fsbtodb(&sblock, cgtod(&sblock, cg)), (int)sblock.fs_cgsize,
356: (char *)&acg);
357: if (acg.cg_magic != CG_MAGIC) {
358: printf("cg %d: bad magic number\n", cg);
359: return (0);
360: }
361: if (acg.cg_cs.cs_nbfree == 0) {
362: cg++;
363: if (cg >= fs->fs_ncg) {
364: printf("ran out of space\n");
365: return (0);
366: }
367: goto again;
368: }
369: for (d = 0; d < acg.cg_ndblk; d += sblock.fs_frag)
370: if (isblock(&sblock, (u_char *)acg.cg_free, d / sblock.fs_frag))
371: goto goth;
372: printf("internal error: can't find block in cyl %d\n", cg);
373: return (0);
374: goth:
375: clrblock(&sblock, (u_char *)acg.cg_free, d / sblock.fs_frag);
376: acg.cg_cs.cs_nbfree--;
377: sblock.fs_cstotal.cs_nbfree--;
378: fscs[cg].cs_nbfree--;
379: acg.cg_btot[cbtocylno(&sblock, d)]--;
380: acg.cg_b[cbtocylno(&sblock, d)][cbtorpos(&sblock, d)]--;
381: if (size != sblock.fs_bsize) {
382: frag = howmany(size, sblock.fs_fsize);
383: fscs[cg].cs_nffree += sblock.fs_frag - frag;
384: sblock.fs_cstotal.cs_nffree += sblock.fs_frag - frag;
385: acg.cg_cs.cs_nffree += sblock.fs_frag - frag;
386: acg.cg_frsum[sblock.fs_frag - frag]++;
387: for (i = frag; i < sblock.fs_frag; i++)
388: setbit(acg.cg_free, d + i);
389: }
390: wtfs(fsbtodb(&sblock, cgtod(&sblock, cg)), (int)sblock.fs_cgsize,
391: (char *)&acg);
392: return (acg.cg_cgx * fs->fs_fpg + d);
393: }
394:
395: /*
396: * Allocate an inode on the disk
397: */
398: ialloc(ip)
399: register struct inode *ip;
400: {
401: struct dinode buf[MAXBSIZE / sizeof (struct dinode)];
402: daddr_t d;
403: int c;
404:
405: ip->i_number = ++ino;
406: c = itog(&sblock, ip->i_number);
407: rdfs(fsbtodb(&sblock, cgtod(&sblock, c)), (int)sblock.fs_cgsize,
408: (char *)&acg);
409: if (acg.cg_magic != CG_MAGIC) {
410: printf("cg %d: bad magic number\n", c);
411: exit(1);
412: }
413: if (ip->i_mode & IFDIR) {
414: acg.cg_cs.cs_ndir++;
415: sblock.fs_cstotal.cs_ndir++;
416: fscs[c].cs_ndir++;
417: }
418: acg.cg_cs.cs_nifree--;
419: setbit(acg.cg_iused, ip->i_number);
420: wtfs(fsbtodb(&sblock, cgtod(&sblock, c)), (int)sblock.fs_cgsize,
421: (char *)&acg);
422: sblock.fs_cstotal.cs_nifree--;
423: fscs[c].cs_nifree--;
424: if(ip->i_number >= sblock.fs_ipg * sblock.fs_ncg) {
425: printf("fsinit: inode value out of range (%d).\n",
426: ip->i_number);
427: exit(1);
428: }
429: return (ip->i_number);
430: }
431:
432: /*
433: * read a block from the file system
434: */
435: rdfs(bno, size, bf)
436: int bno, size;
437: char *bf;
438: {
439: int n;
440:
441: if (lseek(fsi, bno * DEV_BSIZE, 0) < 0) {
442: printf("seek error: %ld\n", bno);
443: perror("rdfs");
444: exit(1);
445: }
446: n = read(fsi, bf, size);
447: if(n != size) {
448: printf("read error: %ld\n", bno);
449: perror("rdfs");
450: exit(1);
451: }
452: }
453:
454: /*
455: * write a block to the file system
456: */
457: wtfs(bno, size, bf)
458: int bno, size;
459: char *bf;
460: {
461: int n;
462:
463: lseek(fso, bno * DEV_BSIZE, 0);
464: if (lseek(fso, bno * DEV_BSIZE, 0) < 0) {
465: printf("seek error: %ld\n", bno);
466: perror("wtfs");
467: exit(1);
468: }
469: n = write(fso, bf, size);
470: if(n != size) {
471: printf("write error: %D\n", bno);
472: perror("wtfs");
473: exit(1);
474: }
475: }
476: /*
477: * check if a block is available
478: */
479: isblock(fs, cp, h)
480: struct fs *fs;
481: unsigned char *cp;
482: int h;
483: {
484: unsigned char mask;
485:
486: switch (fs->fs_frag) {
487: case 8:
488: return (cp[h] == 0xff);
489: case 4:
490: mask = 0x0f << ((h & 0x1) << 2);
491: return ((cp[h >> 1] & mask) == mask);
492: case 2:
493: mask = 0x03 << ((h & 0x3) << 1);
494: return ((cp[h >> 2] & mask) == mask);
495: case 1:
496: mask = 0x01 << (h & 0x7);
497: return ((cp[h >> 3] & mask) == mask);
498: default:
499: fprintf(stderr, "isblock bad fs_frag %d\n", fs->fs_frag);
500: return (0);
501: }
502: /*NOTREACHED*/
503: }
504:
505: /*
506: * take a block out of the map
507: */
508: clrblock(fs, cp, h)
509: struct fs *fs;
510: unsigned char *cp;
511: int h;
512: {
513: switch ((fs)->fs_frag) {
514: case 8:
515: cp[h] = 0;
516: return;
517: case 4:
518: cp[h >> 1] &= ~(0x0f << ((h & 0x1) << 2));
519: return;
520: case 2:
521: cp[h >> 2] &= ~(0x03 << ((h & 0x3) << 1));
522: return;
523: case 1:
524: cp[h >> 3] &= ~(0x01 << (h & 0x7));
525: return;
526: default:
527: fprintf(stderr, "clrblock bad fs_frag %d\n", fs->fs_frag);
528: return;
529: }
530: }
531:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.