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