![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to newfs.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / etc|
Return to newfs.c CVS log | Up to [CSRG BSD Unix] / 43BSD / 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) 1983 Regents of the University of California.\n\
10: All rights reserved.\n";
11: #endif not lint
12:
13: #ifndef lint
14: static char sccsid[] = "@(#)newfs.c 5.2 (Berkeley) 9/11/85";
15: #endif not lint
16:
17: /*
18: * newfs: friendly front end to mkfs
19: */
20: #include <sys/param.h>
21: #include <sys/stat.h>
22: #include <sys/fs.h>
23: #include <sys/dir.h>
24:
25: #include <stdio.h>
26: #include <disktab.h>
27:
28: #define BOOTDIR "/usr/mdec" /* directory for boot blocks */
29:
30: int Nflag; /* run mkfs without writing file system */
31: int verbose; /* show mkfs line before exec */
32: int noboot; /* do not fill boot blocks */
33: int fssize; /* file system size */
34: int fsize; /* fragment size */
35: int bsize; /* block size */
36: int ntracks; /* # tracks/cylinder */
37: int nsectors; /* # sectors/track */
38: int sectorsize; /* bytes/sector */
39: int cpg; /* cylinders/cylinder group */
40: int minfree = -1; /* free space threshold */
41: int opt; /* optimization preference (space or time) */
42: int rpm; /* revolutions/minute of drive */
43: int density; /* number of bytes per inode */
44:
45: char *av[20]; /* argv array and buffers for exec */
46: char a2[20];
47: char a3[20];
48: char a4[20];
49: char a5[20];
50: char a6[20];
51: char a7[20];
52: char a8[20];
53: char a9[20];
54: char a10[20];
55: char device[MAXPATHLEN];
56: char cmd[BUFSIZ];
57:
58: char *index();
59: char *rindex();
60: char *sprintf();
61:
62: main(argc, argv)
63: int argc;
64: char *argv[];
65: {
66: char *cp, *special;
67: register struct disktab *dp;
68: register struct partition *pp;
69: struct stat st;
70: register int i;
71: int status;
72:
73: argc--, argv++;
74: while (argc > 0 && argv[0][0] == '-') {
75: for (cp = &argv[0][1]; *cp; cp++)
76: switch (*cp) {
77:
78: case 'v':
79: verbose++;
80: break;
81:
82: case 'N':
83: Nflag++;
84: /* fall through to */
85:
86: case 'n':
87: noboot++;
88: break;
89:
90: case 's':
91: if (argc < 1)
92: fatal("-s: missing file system size");
93: argc--, argv++;
94: fssize = atoi(*argv);
95: if (fssize < 0)
96: fatal("%s: bad file system size",
97: *argv);
98: goto next;
99:
100: case 't':
101: if (argc < 1)
102: fatal("-t: missing track total");
103: argc--, argv++;
104: ntracks = atoi(*argv);
105: if (ntracks < 0)
106: fatal("%s: bad total tracks", *argv);
107: goto next;
108:
109: case 'o':
110: if (argc < 1)
111: fatal("-o: missing optimization preference");
112: argc--, argv++;
113: if (strcmp(*argv, "space") == 0)
114: opt = FS_OPTSPACE;
115: else if (strcmp(*argv, "time") == 0)
116: opt = FS_OPTTIME;
117: else
118: fatal("%s: bad optimization preference %s",
119: *argv,
120: "(options are `space' or `time')");
121: goto next;
122:
123: case 'b':
124: if (argc < 1)
125: fatal("-b: missing block size");
126: argc--, argv++;
127: bsize = atoi(*argv);
128: if (bsize < 0 || bsize < MINBSIZE)
129: fatal("%s: bad block size", *argv);
130: goto next;
131:
132: case 'f':
133: if (argc < 1)
134: fatal("-f: missing frag size");
135: argc--, argv++;
136: fsize = atoi(*argv);
137: if (fsize < 0)
138: fatal("%s: bad frag size", *argv);
139: goto next;
140:
141: case 'S':
142: if (argc < 1)
143: fatal("-S: missing sector size");
144: argc--, argv++;
145: sectorsize = atoi(*argv);
146: if (sectorsize < 0)
147: fatal("%s: bad sector size", *argv);
148: goto next;
149:
150: case 'c':
151: if (argc < 1)
152: fatal("-c: missing cylinders/group");
153: argc--, argv++;
154: cpg = atoi(*argv);
155: if (cpg < 0)
156: fatal("%s: bad cylinders/group", *argv);
157: goto next;
158:
159: case 'm':
160: if (argc < 1)
161: fatal("-m: missing free space %%\n");
162: argc--, argv++;
163: minfree = atoi(*argv);
164: if (minfree < 0 || minfree > 99)
165: fatal("%s: bad free space %%\n",
166: *argv);
167: goto next;
168:
169: case 'r':
170: if (argc < 1)
171: fatal("-r: missing revs/minute\n");
172: argc--, argv++;
173: rpm = atoi(*argv);
174: if (rpm < 0)
175: fatal("%s: bad revs/minute\n", *argv);
176: goto next;
177:
178: case 'i':
179: if (argc < 1)
180: fatal("-i: missing bytes per inode\n");
181: argc--, argv++;
182: density = atoi(*argv);
183: if (density < 0)
184: fatal("%s: bad bytes per inode\n",
185: *argv);
186: goto next;
187:
188: default:
189: fatal("-%c: unknown flag", cp);
190: }
191: next:
192: argc--, argv++;
193: }
194: if (argc < 2) {
195: fprintf(stderr, "usage: newfs [ -v ] [ mkfs-options ] %s\n",
196: "special-device device-type");
197: fprintf(stderr, "where mkfs-options are:\n");
198: fprintf(stderr, "\t-N do not create file system, %s\n",
199: "just print out parameters");
200: fprintf(stderr, "\t-s file system size (sectors)\n");
201: fprintf(stderr, "\t-b block size\n");
202: fprintf(stderr, "\t-f frag size\n");
203: fprintf(stderr, "\t-t tracks/cylinder\n");
204: fprintf(stderr, "\t-c cylinders/group\n");
205: fprintf(stderr, "\t-m minimum free space %%\n");
206: fprintf(stderr, "\t-o optimization preference %s\n",
207: "(`space' or `time')");
208: fprintf(stderr, "\t-r revolutions/minute\n");
209: fprintf(stderr, "\t-S sector size\n");
210: fprintf(stderr, "\t-i number of bytes per inode\n");
211: exit(1);
212: }
213: special = argv[0];
214: cp = rindex(special, '/');
215: if (cp != 0)
216: special = cp + 1;
217: if (*special == 'r' && special[1] != 'a' && special[1] != 'b')
218: special++;
219: special = sprintf(device, "/dev/r%s", special);
220: if (stat(special, &st) < 0) {
221: fprintf(stderr, "newfs: "); perror(special);
222: exit(2);
223: }
224: if ((st.st_mode & S_IFMT) != S_IFCHR)
225: fatal("%s: not a character device", special);
226: dp = getdiskbyname(argv[1]);
227: if (dp == 0)
228: fatal("%s: unknown disk type", argv[1]);
229: cp = index(argv[0], '\0') - 1;
230: if (cp == 0 || *cp < 'a' || *cp > 'h')
231: fatal("%s: can't figure out file system partition", argv[0]);
232: pp = &dp->d_partitions[*cp - 'a'];
233: if (fssize == 0) {
234: fssize = pp->p_size;
235: if (fssize < 0)
236: fatal("%s: no default size for `%c' partition",
237: argv[1], *cp);
238: }
239: if (nsectors == 0) {
240: nsectors = dp->d_nsectors;
241: if (nsectors < 0)
242: fatal("%s: no default #sectors/track", argv[1]);
243: }
244: if (ntracks == 0) {
245: ntracks = dp->d_ntracks;
246: if (ntracks < 0)
247: fatal("%s: no default #tracks", argv[1]);
248: }
249: if (sectorsize == 0) {
250: sectorsize = dp->d_secsize;
251: if (sectorsize < 0)
252: fatal("%s: no default sector size", argv[1]);
253: }
254: if (bsize == 0) {
255: bsize = pp->p_bsize;
256: if (bsize < 0)
257: fatal("%s: no default block size for `%c' partition",
258: argv[1], *cp);
259: }
260: if (fsize == 0) {
261: fsize = pp->p_fsize;
262: if (fsize < 0)
263: fatal("%s: no default frag size for `%c' partition",
264: argv[1], *cp);
265: }
266: if (rpm == 0) {
267: rpm = dp->d_rpm;
268: if (rpm < 0)
269: fatal("%s: no default revolutions/minute value",
270: argv[1]);
271: }
272: if (density <= 0)
273: density = 2048;
274: if (minfree < 0)
275: minfree = 10;
276: if (minfree < 10 && opt != FS_OPTSPACE) {
277: fprintf(stderr, "setting optimization for space ");
278: fprintf(stderr, "with minfree less than 10%\n");
279: opt = FS_OPTSPACE;
280: }
281: if (cpg == 0)
282: cpg = 16;
283: i = 0;
284: if (Nflag)
285: av[i++] = "-N";
286: av[i++] = special;
287: av[i++] = sprintf(a2, "%d", fssize);
288: av[i++] = sprintf(a3, "%d", nsectors);
289: av[i++] = sprintf(a4, "%d", ntracks);
290: av[i++] = sprintf(a5, "%d", bsize);
291: av[i++] = sprintf(a6, "%d", fsize);
292: av[i++] = sprintf(a7, "%d", cpg);
293: av[i++] = sprintf(a8, "%d", minfree);
294: av[i++] = sprintf(a9, "%d", rpm / 60);
295: av[i++] = sprintf(a10, "%d", density);
296: av[i++] = opt == FS_OPTSPACE ? "s" : "t";
297: av[i++] = 0;
298: strcpy(cmd, "/etc/mkfs");
299: for (i = 0; av[i] != 0; i++) {
300: strcat(cmd, " ");
301: strcat(cmd, av[i]);
302: }
303: if (verbose)
304: printf("%s\n", cmd);
305: if (status = system(cmd))
306: exit(status >> 8);
307: if (*cp == 'a' && !noboot) {
308: char type[3];
309: struct stat sb;
310:
311: cp = rindex(special, '/');
312: if (cp == NULL)
313: fatal("%s: can't figure out disk type from name",
314: special);
315: if (stat(special, &sb) >= 0 && (sb.st_mode & S_IFMT) == S_IFCHR)
316: cp++;
317: type[0] = *++cp;
318: type[1] = *++cp;
319: type[2] = '\0';
320: installboot(special, type);
321: }
322: exit(0);
323: }
324:
325: installboot(dev, type)
326: char *dev, *type;
327: {
328: int fd;
329: char bootblock[MAXPATHLEN], standalonecode[MAXPATHLEN];
330: char bootimage[BBSIZE];
331:
332: sprintf(bootblock, "%s/%sboot", BOOTDIR, type);
333: sprintf(standalonecode, "%s/boot%s", BOOTDIR, type);
334: if (verbose) {
335: printf("installing boot code\n");
336: printf("sector 0 boot = %s\n", bootblock);
337: printf("1st level boot = %s\n", standalonecode);
338: }
339: fd = open(bootblock, 0);
340: if (fd < 0) {
341: fprintf(stderr, "newfs: "); perror(bootblock);
342: exit(1);
343: }
344: if (read(fd, bootimage, DEV_BSIZE) < 0) {
345: fprintf(stderr, "newfs: "); perror(bootblock);
346: exit(2);
347: }
348: close(fd);
349: fd = open(standalonecode, 0);
350: if (fd < 0) {
351: fprintf(stderr, "newfs: "); perror(standalonecode);
352: exit(1);
353: }
354: if (read(fd, &bootimage[DEV_BSIZE], BBSIZE - DEV_BSIZE) < 0) {
355: fprintf(stderr, "newfs: "); perror(standalonecode);
356: exit(2);
357: }
358: close(fd);
359: fd = open(dev, 1);
360: if (fd < 0) {
361: fprintf(stderr, "newfs: "); perror(dev);
362: exit(1);
363: }
364: if (write(fd, bootimage, BBSIZE) != BBSIZE) {
365: fprintf(stderr, "newfs: "); perror(dev);
366: exit(2);
367: }
368: close(fd);
369: }
370:
371: /*VARARGS*/
372: fatal(fmt, arg1, arg2)
373: char *fmt;
374: {
375:
376: fprintf(stderr, "newfs: ");
377: fprintf(stderr, fmt, arg1, arg2);
378: putc('\n', stderr);
379: exit(10);
380: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.