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