![[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] / 43BSDTahoe / etc|
Return to diskpart.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / etc |
1.1 root 1: /*
2: * Copyright (c) 1983, 1988 Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms are permitted
6: * provided that the above copyright notice and this paragraph are
7: * duplicated in all such forms and that any documentation,
8: * advertising materials, and other materials related to such
9: * distribution and use acknowledge that the software was developed
10: * by the University of California, Berkeley. The name of the
11: * University may not be used to endorse or promote products derived
12: * from this software without specific prior written permission.
13: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
14: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
15: * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
16: */
17:
18: #ifndef lint
19: char copyright[] =
20: "@(#) Copyright (c) 1983, 1988 Regents of the University of California.\n\
21: All rights reserved.\n";
22: #endif /* not lint */
23:
24: #ifndef lint
25: static char sccsid[] = "@(#)diskpart.c 5.10 (Berkeley) 7/12/88";
26: #endif /* not lint */
27:
28: /*
29: * Program to calculate standard disk partition sizes.
30: */
31: #include <sys/param.h>
32: #define DKTYPENAMES
33: #include <sys/disklabel.h>
34:
35: #include <stdio.h>
36: #include <ctype.h>
37:
38: #define for_now /* show all of `c' partition for disklabel */
39: #define NPARTITIONS 8
40: #define PART(x) (x - 'a')
41:
42: /*
43: * Default partition sizes, where they exist.
44: */
45: #define NDEFAULTS 4
46: int defpart[NDEFAULTS][NPARTITIONS] = {
47: { 15884, 66880, 0, 15884, 307200, 0, 0, 291346 }, /* ~ 356+ Mbytes */
48: { 15884, 33440, 0, 15884, 55936, 0, 0, 291346 }, /* ~ 206-355 Mbytes */
49: { 15884, 33440, 0, 15884, 55936, 0, 0, 0 }, /* ~ 61-205 Mbytes */
50: { 15884, 10032, 0, 15884, 0, 0, 0, 0 }, /* ~ 20-60 Mbytes */
51: };
52:
53: /*
54: * Each array defines a layout for a disk;
55: * that is, the collection of partitions totally
56: * covers the physical space on a disk.
57: */
58: #define NLAYOUTS 3
59: char layouts[NLAYOUTS][NPARTITIONS] = {
60: { 'a', 'b', 'h', 'g' },
61: { 'a', 'b', 'h', 'd', 'e', 'f' },
62: { 'c' },
63: };
64:
65: /*
66: * Default disk block and disk block fragment
67: * sizes for each file system. Those file systems
68: * with zero block and frag sizes are special cases
69: * (e.g. swap areas or for access to the entire device).
70: */
71: struct partition defparam[NPARTITIONS] = {
72: { 0, 0, 1024, FS_UNUSED, 8, 0 }, /* a */
73: { 0, 0, 1024, FS_SWAP, 8, 0 }, /* b */
74: { 0, 0, 1024, FS_UNUSED, 8, 0 }, /* c */
75: { 0, 0, 512, FS_UNUSED, 8, 0 }, /* d */
76: { 0, 0, 1024, FS_UNUSED, 8, 0 }, /* e */
77: { 0, 0, 1024, FS_UNUSED, 8, 0 }, /* f */
78: { 0, 0, 1024, FS_UNUSED, 8, 0 }, /* g */
79: { 0, 0, 1024, FS_UNUSED, 8, 0 } /* h */
80: };
81:
82: /*
83: * Each disk has some space reserved for a bad sector
84: * forwarding table. DEC standard 144 uses the first
85: * 5 even numbered sectors in the last track of the
86: * last cylinder for replicated storage of the bad sector
87: * table; another 126 sectors past this is needed as a
88: * pool of replacement sectors.
89: */
90: int badsecttable = 126; /* # sectors */
91:
92: int pflag; /* print device driver partition tables */
93: int dflag; /* print disktab entry */
94:
95: struct disklabel *promptfordisk();
96:
97: main(argc, argv)
98: int argc;
99: char *argv[];
100: {
101: struct disklabel *dp;
102: register int curcyl, spc, def, part, layout, j;
103: int threshhold, numcyls[NPARTITIONS], startcyl[NPARTITIONS];
104: int totsize = 0;
105: char *lp, *tyname;
106:
107: argc--, argv++;
108: if (argc < 1) {
109: fprintf(stderr,
110: "usage: disktab [ -p ] [ -d ] [ -s size ] disk-type\n");
111: exit(1);
112: }
113: if (argc > 0 && strcmp(*argv, "-p") == 0) {
114: pflag++;
115: argc--, argv++;
116: }
117: if (argc > 0 && strcmp(*argv, "-d") == 0) {
118: dflag++;
119: argc--, argv++;
120: }
121: if (argc > 1 && strcmp(*argv, "-s") == 0) {
122: totsize = atoi(argv[1]);
123: argc += 2, argv += 2;
124: }
125: dp = getdiskbyname(*argv);
126: if (dp == NULL) {
127: if (isatty(0))
128: dp = promptfordisk(*argv);
129: if (dp == NULL) {
130: fprintf(stderr, "%s: unknown disk type\n", *argv);
131: exit(2);
132: }
133: } else {
134: if (dp->d_flags & D_REMOVABLE)
135: tyname = "removable";
136: else if (dp->d_flags & D_RAMDISK)
137: tyname = "simulated";
138: else
139: tyname = "winchester";
140: }
141: spc = dp->d_secpercyl;
142: /*
143: * Bad sector table contains one track for the replicated
144: * copies of the table and enough full tracks preceding
145: * the last track to hold the pool of free blocks to which
146: * bad sectors are mapped.
147: * If disk size was specified explicitly, use specified size.
148: */
149: if (dp->d_type == DTYPE_SMD && dp->d_flags & D_BADSECT &&
150: totsize == 0) {
151: badsecttable = dp->d_nsectors +
152: roundup(badsecttable, dp->d_nsectors);
153: threshhold = howmany(spc, badsecttable);
154: } else {
155: badsecttable = 0;
156: threshhold = 0;
157: }
158: /*
159: * If disk size was specified, recompute number of cylinders
160: * that may be used, and set badsecttable to any remaining
161: * fraction of the last cylinder.
162: */
163: if (totsize != 0) {
164: dp->d_ncylinders = howmany(totsize, spc);
165: badsecttable = spc * dp->d_ncylinders - totsize;
166: }
167:
168: /*
169: * Figure out if disk is large enough for
170: * expanded swap area and 'd', 'e', and 'f'
171: * partitions. Otherwise, use smaller defaults
172: * based on RK07.
173: */
174: for (def = 0; def < NDEFAULTS; def++) {
175: curcyl = 0;
176: for (part = PART('a'); part < NPARTITIONS; part++)
177: curcyl += howmany(defpart[def][part], spc);
178: if (curcyl < dp->d_ncylinders - threshhold)
179: break;
180: }
181: if (def >= NDEFAULTS) {
182: fprintf(stderr, "%s: disk too small, calculate by hand\n",
183: *argv);
184: exit(3);
185: }
186:
187: /*
188: * Calculate number of cylinders allocated to each disk
189: * partition. We may waste a bit of space here, but it's
190: * in the interest of (very backward) compatibility
191: * (for mixed disk systems).
192: */
193: for (curcyl = 0, part = PART('a'); part < NPARTITIONS; part++) {
194: numcyls[part] = 0;
195: if (defpart[def][part] != 0) {
196: numcyls[part] = howmany(defpart[def][part], spc);
197: curcyl += numcyls[part];
198: }
199: }
200: numcyls[PART('f')] = dp->d_ncylinders - curcyl;
201: numcyls[PART('g')] =
202: numcyls[PART('d')] + numcyls[PART('e')] + numcyls[PART('f')];
203: numcyls[PART('c')] = dp->d_ncylinders;
204: defpart[def][PART('f')] = numcyls[PART('f')] * spc - badsecttable;
205: defpart[def][PART('g')] = numcyls[PART('g')] * spc - badsecttable;
206: defpart[def][PART('c')] = numcyls[PART('c')] * spc;
207: #ifndef for_now
208: if (totsize || !pflag)
209: #else
210: if (totsize)
211: #endif
212: defpart[def][PART('c')] -= badsecttable;
213:
214: /*
215: * Calculate starting cylinder number for each partition.
216: * Note the 'h' partition is physically located before the
217: * 'g' or 'd' partition. This is reflected in the layout
218: * arrays defined above.
219: */
220: for (layout = 0; layout < NLAYOUTS; layout++) {
221: curcyl = 0;
222: for (lp = layouts[layout]; *lp != 0; lp++) {
223: startcyl[PART(*lp)] = curcyl;
224: curcyl += numcyls[PART(*lp)];
225: }
226: }
227:
228: if (pflag) {
229: printf("}, %s_sizes[%d] = {\n", dp->d_typename, NPARTITIONS);
230: for (part = PART('a'); part < NPARTITIONS; part++) {
231: if (numcyls[part] == 0) {
232: printf("\t0,\t0,\n");
233: continue;
234: }
235: if (dp->d_type != DTYPE_MSCP) {
236: printf("\t%d,\t%d,\t\t/* %c=cyl %d thru %d */\n",
237: defpart[def][part], startcyl[part],
238: 'A' + part, startcyl[part],
239: startcyl[part] + numcyls[part] - 1);
240: continue;
241: }
242: printf("\t%d,\t%d,\t\t/* %c=sectors %d thru %d */\n",
243: defpart[def][part], spc * startcyl[part],
244: 'A' + part, spc * startcyl[part],
245: spc * startcyl[part] + defpart[def][part] - 1);
246: }
247: exit(0);
248: }
249: if (dflag) {
250: int nparts;
251:
252: /*
253: * In case the disk is in the ``in-between'' range
254: * where the 'g' partition is smaller than the 'h'
255: * partition, reverse the frag sizes so the /usr partition
256: * is always set up with a frag size larger than the
257: * user's partition.
258: */
259: if (defpart[def][PART('g')] < defpart[def][PART('h')]) {
260: int temp;
261:
262: temp = defparam[PART('h')].p_fsize;
263: defparam[PART('h')].p_fsize =
264: defparam[PART('g')].p_fsize;
265: defparam[PART('g')].p_fsize = temp;
266: }
267: printf("%s:\\\n", dp->d_typename);
268: printf("\t:ty=%s:ns#%d:nt#%d:nc#%d:", tyname,
269: dp->d_nsectors, dp->d_ntracks, dp->d_ncylinders);
270: if (dp->d_secpercyl != dp->d_nsectors * dp->d_ntracks)
271: printf("sc#%d:", dp->d_secpercyl);
272: if (dp->d_type == DTYPE_SMD && dp->d_flags & D_BADSECT)
273: printf("sf:");
274: printf("\\\n\t:dt=%s:", dktypenames[dp->d_type]);
275: for (part = NDDATA - 1; part >= 0; part--)
276: if (dp->d_drivedata[part])
277: break;
278: for (j = 0; j <= part; j++)
279: printf("d%d#%d:", j, dp->d_drivedata[j]);
280: printf("\\\n");
281: for (nparts = 0, part = PART('a'); part < NPARTITIONS; part++)
282: if (defpart[def][part] != 0)
283: nparts++;
284: for (part = PART('a'); part < NPARTITIONS; part++) {
285: if (defpart[def][part] == 0)
286: continue;
287: printf("\t:p%c#%d:", 'a' + part, defpart[def][part]);
288: printf("o%c#%d:b%c#%d:f%c#%d:",
289: 'a' + part, spc * startcyl[part],
290: 'a' + part,
291: defparam[part].p_frag * defparam[part].p_fsize,
292: 'a' + part, defparam[part].p_fsize);
293: if (defparam[part].p_fstype == FS_SWAP)
294: printf("t%c=swap:", 'a' + part);
295: nparts--;
296: printf("%s\n", nparts > 0 ? "\\" : "");
297: }
298: #ifdef for_now
299: defpart[def][PART('c')] -= badsecttable;
300: part = PART('c');
301: printf("#\t:p%c#%d:", 'a' + part, defpart[def][part]);
302: printf("o%c#%d:b%c#%d:f%c#%d:\n",
303: 'a' + part, spc * startcyl[part],
304: 'a' + part,
305: defparam[part].p_frag * defparam[part].p_fsize,
306: 'a' + part, defparam[part].p_fsize);
307: #endif
308: exit(0);
309: }
310: printf("%s: #sectors/track=%d, #tracks/cylinder=%d #cylinders=%d\n",
311: dp->d_typename, dp->d_nsectors, dp->d_ntracks,
312: dp->d_ncylinders);
313: printf("\n Partition\t Size\t Offset\t Range\n");
314: for (part = PART('a'); part < NPARTITIONS; part++) {
315: printf("\t%c\t", 'a' + part);
316: if (numcyls[part] == 0) {
317: printf(" unused\n");
318: continue;
319: }
320: printf("%7d\t%7d\t%4d - %d%s\n",
321: defpart[def][part], startcyl[part] * spc,
322: startcyl[part], startcyl[part] + numcyls[part] - 1,
323: defpart[def][part] % spc ? "*" : "");
324: }
325: }
326:
327: struct disklabel disk;
328:
329: struct field {
330: char *f_name;
331: char *f_defaults;
332: u_long *f_location;
333: } fields[] = {
334: { "sector size", "512", &disk.d_secsize },
335: { "#sectors/track", 0, &disk.d_nsectors },
336: { "#tracks/cylinder", 0, &disk.d_ntracks },
337: { "#cylinders", 0, &disk.d_ncylinders },
338: { 0, 0, 0 },
339: };
340:
341: struct disklabel *
342: promptfordisk(name)
343: char *name;
344: {
345: register struct disklabel *dp = &disk;
346: register struct field *fp;
347: register i;
348: char buf[BUFSIZ], **tp, *cp, *gets();
349:
350: strncpy(dp->d_typename, name, sizeof(dp->d_typename));
351: fprintf(stderr,
352: "%s: unknown disk type, want to supply parameters (y/n)? ",
353: name);
354: (void) gets(buf);
355: if (*buf != 'y')
356: return ((struct disklabel *)0);
357: for (;;) {
358: fprintf(stderr, "Disk/controller type (%s)? ", dktypenames[1]);
359: (void) gets(buf);
360: if (buf[0] == 0)
361: dp->d_type = 1;
362: else
363: dp->d_type = gettype(buf, dktypenames);
364: if (dp->d_type >= 0)
365: break;
366: fprintf(stderr, "%s: unrecognized controller type\n", buf);
367: fprintf(stderr, "use one of:\n", buf);
368: for (tp = dktypenames; *tp; tp++)
369: if (index(*tp, ' ') == 0)
370: fprintf(stderr, "\t%s\n", *tp);
371: }
372: gettype:
373: dp->d_flags = 0;
374: fprintf(stderr, "type (winchester|removable|simulated)? ");
375: (void) gets(buf);
376: if (strcmp(buf, "removable") == 0)
377: dp->d_flags = D_REMOVABLE;
378: else if (strcmp(buf, "simulated") == 0)
379: dp->d_flags = D_RAMDISK;
380: else if (strcmp(buf, "winchester")) {
381: fprintf(stderr, "%s: bad disk type\n", buf);
382: goto gettype;
383: }
384: strncpy(dp->d_typename, buf, sizeof(dp->d_typename));
385: fprintf(stderr, "(type <cr> to get default value, if only one)\n");
386: if (dp->d_type == DTYPE_SMD)
387: fprintf(stderr, "Do %ss support bad144 bad block forwarding (yes)? ",
388: dp->d_typename);
389: (void) gets(buf);
390: if (*buf != 'n')
391: dp->d_flags |= D_BADSECT;
392: for (fp = fields; fp->f_name != NULL; fp++) {
393: again:
394: fprintf(stderr, "%s ", fp->f_name);
395: if (fp->f_defaults != NULL)
396: fprintf(stderr, "(%s)", fp->f_defaults);
397: fprintf(stderr, "? ");
398: cp = gets(buf);
399: if (*cp == '\0') {
400: if (fp->f_defaults == NULL) {
401: fprintf(stderr, "no default value\n");
402: goto again;
403: }
404: cp = fp->f_defaults;
405: }
406: *fp->f_location = atol(cp);
407: if (*fp->f_location == 0) {
408: fprintf(stderr, "%s: bad value\n", cp);
409: goto again;
410: }
411: }
412: fprintf(stderr, "sectors/cylinder (%d)? ",
413: dp->d_nsectors * dp->d_ntracks);
414: (void) gets(buf);
415: if (buf[0] == 0)
416: dp->d_secpercyl = dp->d_nsectors * dp->d_ntracks;
417: else
418: dp->d_secpercyl = atol(buf);
419: fprintf(stderr, "Drive-type-specific parameters, <cr> to terminate:\n");
420: for (i = 0; i < NDDATA; i++) {
421: fprintf(stderr, "d%d? ", i);
422: (void) gets(buf);
423: if (buf[0] == 0)
424: break;
425: dp->d_drivedata[i] = atol(buf);
426: }
427: return (dp);
428: }
429:
430: gettype(t, names)
431: char *t;
432: char **names;
433: {
434: register char **nm;
435:
436: for (nm = names; *nm; nm++)
437: if (ustrcmp(t, *nm) == 0)
438: return (nm - names);
439: if (isdigit(*t))
440: return (atoi(t));
441: return (-1);
442: }
443:
444: ustrcmp(s1, s2)
445: register char *s1, *s2;
446: {
447: #define lower(c) (islower(c) ? (c) : tolower(c))
448:
449: for (; *s1; s1++, s2++) {
450: if (*s1 == *s2)
451: continue;
452: if (isalpha(*s1) && isalpha(*s2) &&
453: lower(*s1) == lower(*s2))
454: continue;
455: return (*s2 - *s1);
456: }
457: return (0);
458: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.