![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to diskpart.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 diskpart.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[] = "@(#)diskpart.c 5.5 (Berkeley) 5/30/86";
15: #endif not lint
16:
17: /*
18: * Program to calculate standard disk partition sizes.
19: */
20: #include <sys/param.h>
21:
22: #include <stdio.h>
23: #include <disktab.h>
24:
25: #define NPARTITIONS 8
26: #define PART(x) (x - 'a')
27:
28: /*
29: * Default partition sizes, where they exist.
30: */
31: #define NDEFAULTS 4
32: int defpart[NDEFAULTS][NPARTITIONS] = {
33: { 15884, 66880, 0, 15884, 307200, 0, 0, 291346 }, /* ~ 356+ Mbytes */
34: { 15884, 33440, 0, 15884, 55936, 0, 0, 291346 }, /* ~ 206-355 Mbytes */
35: { 15884, 33440, 0, 15884, 55936, 0, 0, 0 }, /* ~ 61-205 Mbytes */
36: { 15884, 10032, 0, 15884, 0, 0, 0, 0 }, /* ~ 20-60 Mbytes */
37: };
38:
39: /*
40: * Each array defines a layout for a disk;
41: * that is, the collection of partitions totally
42: * covers the physical space on a disk.
43: */
44: #define NLAYOUTS 3
45: char layouts[NLAYOUTS][NPARTITIONS] = {
46: { 'a', 'b', 'h', 'g' },
47: { 'a', 'b', 'h', 'd', 'e', 'f' },
48: { 'c' },
49: };
50:
51: /*
52: * Default disk block and disk block fragment
53: * sizes for each file system. Those file systems
54: * with zero block and frag sizes are special cases
55: * (e.g. swap areas or for access to the entire device).
56: */
57: struct defparam {
58: int p_bsize; /* block size */
59: int p_fsize; /* frag size */
60: } defparam[NPARTITIONS] = {
61: { 8192, 1024 }, /* a */
62: { 8192, 1024 }, /* b */
63: { 8192, 1024 }, /* c */
64: { 4096, 512 }, /* d */
65: { 8192, 1024 }, /* e */
66: { 8192, 1024 }, /* f */
67: { 8192, 1024 }, /* g */
68: { 8192, 1024 } /* h */
69: };
70:
71: /*
72: * Each disk has some space reserved for a bad sector
73: * forwarding table. DEC standard 144 uses the first
74: * 5 even numbered sectors in the last track of the
75: * last cylinder for replicated storage of the bad sector
76: * table; another 126 sectors past this is needed as a
77: * pool of replacement sectors.
78: */
79: int badsecttable = 126; /* # sectors */
80:
81: int pflag; /* print device driver partition tables */
82: int dflag; /* print disktab entry */
83:
84: struct disktab *promptfordisk();
85:
86: main(argc, argv)
87: int argc;
88: char *argv[];
89: {
90: struct disktab *dp;
91: register int curcyl, spc, def, part, layout;
92: int threshhold, numcyls[NPARTITIONS], startcyl[NPARTITIONS];
93: char *lp;
94:
95: argc--, argv++;
96: if (argc < 1) {
97: fprintf(stderr, "usage: disktab [ -p ] [ -d ] disk-type\n");
98: exit(1);
99: }
100: if (argc > 0 && strcmp(*argv, "-p") == 0) {
101: pflag++;
102: argc--, argv++;
103: }
104: if (argc > 0 && strcmp(*argv, "-d") == 0) {
105: dflag++;
106: argc--, argv++;
107: }
108: dp = getdiskbyname(*argv);
109: if (dp == NULL) {
110: if (isatty(0))
111: dp = promptfordisk(*argv);
112: if (dp == NULL) {
113: fprintf(stderr, "%s: unknown disk type\n", *argv);
114: exit(2);
115: }
116: }
117: spc = dp->d_nsectors * dp->d_ntracks;
118: /*
119: * Bad sector table contains one track for the replicated
120: * copies of the table and enough full tracks preceding
121: * the last track to hold the pool of free blocks to which
122: * bad sectors are mapped.
123: */
124: badsecttable = dp->d_nsectors + roundup(badsecttable, dp->d_nsectors);
125: threshhold = howmany(spc, badsecttable);
126: if (dp->d_badsectforw == 0) {
127: badsecttable = 0;
128: threshhold = 0;
129: }
130:
131: /*
132: * Figure out if disk is large enough for
133: * expanded swap area and 'd', 'e', and 'f'
134: * partitions. Otherwise, use smaller defaults
135: * based on RK07.
136: */
137: for (def = 0; def < NDEFAULTS; def++) {
138: curcyl = 0;
139: for (part = PART('a'); part < NPARTITIONS; part++)
140: curcyl += howmany(defpart[def][part], spc);
141: if (curcyl < dp->d_ncylinders - threshhold)
142: break;
143: }
144: if (def >= NDEFAULTS) {
145: fprintf(stderr, "%s: disk too small, calculate by hand\n",
146: *argv);
147: exit(3);
148: }
149:
150: /*
151: * Calculate number of cylinders allocated to each disk
152: * partition. We may waste a bit of space here, but it's
153: * in the interest of compatibility (for mixed disk systems).
154: */
155: for (curcyl = 0, part = PART('a'); part < NPARTITIONS; part++) {
156: numcyls[part] = 0;
157: if (defpart[def][part] != 0) {
158: numcyls[part] = howmany(defpart[def][part], spc);
159: curcyl += numcyls[part];
160: }
161: }
162: numcyls[PART('f')] = dp->d_ncylinders - curcyl;
163: numcyls[PART('g')] =
164: numcyls[PART('d')] + numcyls[PART('e')] + numcyls[PART('f')];
165: numcyls[PART('c')] = dp->d_ncylinders;
166: defpart[def][PART('f')] = numcyls[PART('f')] * spc - badsecttable;
167: defpart[def][PART('g')] = numcyls[PART('g')] * spc - badsecttable;
168: defpart[def][PART('c')] = numcyls[PART('c')] * spc;
169: if (!pflag)
170: defpart[def][PART('c')] -= badsecttable;
171:
172: /*
173: * Calculate starting cylinder number for each partition.
174: * Note the 'h' partition is physically located before the
175: * 'g' or 'd' partition. This is reflected in the layout
176: * arrays defined above.
177: */
178: for (layout = 0; layout < NLAYOUTS; layout++) {
179: curcyl = 0;
180: for (lp = layouts[layout]; *lp != 0; lp++) {
181: startcyl[PART(*lp)] = curcyl;
182: curcyl += numcyls[PART(*lp)];
183: }
184: }
185:
186: if (pflag) {
187: printf("}, %s_sizes[%d] = {\n", dp->d_name, NPARTITIONS);
188: for (part = PART('a'); part < NPARTITIONS; part++) {
189: if (numcyls[part] == 0) {
190: printf("\t0,\t0,\n");
191: continue;
192: }
193: if (dp->d_sectoffset == 0) {
194: printf("\t%d,\t%d,\t\t/* %c=cyl %d thru %d */\n",
195: defpart[def][part], startcyl[part],
196: 'A' + part, startcyl[part],
197: startcyl[part] + numcyls[part] - 1);
198: continue;
199: }
200: printf("\t%d,\t%d,\t\t/* %c=sectors %d thru %d */\n",
201: defpart[def][part], spc * startcyl[part],
202: 'A' + part, spc * startcyl[part],
203: spc * startcyl[part] + defpart[def][part] - 1);
204: }
205: exit(0);
206: }
207: if (dflag) {
208: int nparts;
209:
210: /*
211: * In case the disk is in the ``in-between'' range
212: * where the 'g' partition is smaller than the 'h'
213: * partition, reverse the frag sizes so the /usr partition
214: * is always set up with a frag size larger than the
215: * user's partition.
216: */
217: if (defpart[def][PART('g')] < defpart[def][PART('h')]) {
218: int temp;
219:
220: temp = defparam[PART('h')].p_fsize;
221: defparam[PART('h')].p_fsize =
222: defparam[PART('g')].p_fsize;
223: defparam[PART('g')].p_fsize = temp;
224: }
225: printf("%s:\\\n", dp->d_name);
226: printf("\t:ty=%s:ns#%d:nt#%d:nc#%d:%s%s\\\n", dp->d_type,
227: dp->d_nsectors, dp->d_ntracks, dp->d_ncylinders,
228: dp->d_badsectforw ? "sf:" : "",
229: dp->d_sectoffset ? "so:" : "");
230: for (nparts = 0, part = PART('a'); part < NPARTITIONS; part++)
231: if (defpart[def][part] != 0)
232: nparts++;
233: for (part = PART('a'); part < NPARTITIONS; part++) {
234: if (defpart[def][part] == 0)
235: continue;
236: printf("\t:p%c#%d:", 'a' + part, defpart[def][part]);
237: if (defparam[part].p_bsize != 0) {
238: printf("b%c#%d:f%c#%d:",
239: 'a' + part, defparam[part].p_bsize,
240: 'a' + part, defparam[part].p_fsize);
241: }
242: nparts--;
243: printf("%s\n", nparts > 0 ? "\\" : "");
244: }
245: exit(0);
246: }
247: printf("%s: #sectors/track=%d, #tracks/cylinder=%d #cylinders=%d\n",
248: dp->d_name, dp->d_nsectors, dp->d_ntracks, dp->d_ncylinders);
249: printf("\n Partition\t Size\t Range\n");
250: for (part = PART('a'); part < NPARTITIONS; part++) {
251: printf("\t%c\t", 'a' + part);
252: if (numcyls[part] == 0) {
253: printf(" unused\n");
254: continue;
255: }
256: printf("%7d\t%4d - %d\n", defpart[def][part], startcyl[part],
257: startcyl[part] + numcyls[part] - 1);
258: }
259: }
260:
261: struct disktab disk;
262:
263: struct field {
264: char *f_name;
265: char *f_defaults;
266: int *f_location;
267: } fields[] = {
268: { "sector size", "512", &disk.d_secsize },
269: { "#sectors/track", 0, &disk.d_nsectors },
270: { "#tracks/cylinder", 0, &disk.d_ntracks },
271: { "#cylinders", 0, &disk.d_ncylinders },
272: { "revolutions/minute", "3600", &disk.d_rpm },
273: { 0, 0, 0 },
274: };
275:
276: struct disktab *
277: promptfordisk(name)
278: char *name;
279: {
280: register struct disktab *dp = &disk;
281: register struct field *fp;
282: static char type[BUFSIZ];
283: char buf[BUFSIZ], *cp, *gets();
284:
285: dp->d_name = name;
286: fprintf(stderr,
287: "%s: unknown disk type, want to supply parameters (y/n)? ",
288: name);
289: (void) gets(buf);
290: if (*buf != 'y')
291: return ((struct disktab *)0);
292: gettype:
293: fprintf(stderr, "type (winchester|removable|simulated)? ");
294: (void) gets(type);
295: if (strcmp(type, "winchester") && strcmp(type, "removable") &&
296: strcmp(type, "simulated")) {
297: fprintf(stderr, "%s: bad disk type\n", type);
298: goto gettype;
299: }
300: dp->d_type = type;
301: fprintf(stderr, "(type <cr> to get default value, if only one)\n");
302: fprintf(stderr, "Do %ss require sector or cylinder offsets (%s)? ",
303: dp->d_name, "cylinder");
304: (void) gets(buf);
305: if (*buf == 's')
306: dp->d_sectoffset = 1;
307: else
308: dp->d_sectoffset = 0;
309: fprintf(stderr, "Do %ss support bad144 bad block forwarding (yes)? ",
310: dp->d_name);
311: (void) gets(buf);
312: if (*buf != 'n')
313: dp->d_badsectforw = 1;
314: else
315: dp->d_badsectforw = 0;
316: for (fp = fields; fp->f_name != NULL; fp++) {
317: again:
318: fprintf(stderr, "%s ", fp->f_name);
319: if (fp->f_defaults != NULL)
320: fprintf(stderr, "(%s)", fp->f_defaults);
321: fprintf(stderr, "? ");
322: cp = gets(buf);
323: if (*cp == '\0') {
324: if (fp->f_defaults == NULL) {
325: fprintf(stderr, "no default value\n");
326: goto again;
327: }
328: cp = fp->f_defaults;
329: }
330: *fp->f_location = atoi(cp);
331: if (*fp->f_location == 0) {
332: fprintf(stderr, "%s: bad value\n", cp);
333: goto again;
334: }
335: }
336: return (dp);
337: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.